# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.2
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.

from sys import version_info as _swig_python_version_info
if _swig_python_version_info < (2, 7, 0):
    raise RuntimeError("Python 2.7 or later required")

# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _ifcopenshell_wrapper
else:
    import _ifcopenshell_wrapper

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "thisown":
            self.this.own(value)
        elif name == "this":
            set(self, name, value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


class SwigPyIterator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _ifcopenshell_wrapper.delete_SwigPyIterator

    def value(self):
        return _ifcopenshell_wrapper.SwigPyIterator_value(self)

    def incr(self, n=1):
        return _ifcopenshell_wrapper.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        return _ifcopenshell_wrapper.SwigPyIterator_decr(self, n)

    def distance(self, x):
        return _ifcopenshell_wrapper.SwigPyIterator_distance(self, x)

    def equal(self, x):
        return _ifcopenshell_wrapper.SwigPyIterator_equal(self, x)

    def copy(self):
        return _ifcopenshell_wrapper.SwigPyIterator_copy(self)

    def next(self):
        return _ifcopenshell_wrapper.SwigPyIterator_next(self)

    def __next__(self):
        return _ifcopenshell_wrapper.SwigPyIterator___next__(self)

    def previous(self):
        return _ifcopenshell_wrapper.SwigPyIterator_previous(self)

    def advance(self, n):
        return _ifcopenshell_wrapper.SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        return _ifcopenshell_wrapper.SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        return _ifcopenshell_wrapper.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        return _ifcopenshell_wrapper.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        return _ifcopenshell_wrapper.SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        return _ifcopenshell_wrapper.SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        return _ifcopenshell_wrapper.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self

# Register SwigPyIterator in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.SwigPyIterator_swigregister(SwigPyIterator)

SHARED_PTR_DISOWN = _ifcopenshell_wrapper.SHARED_PTR_DISOWN
class DoubleArray3(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        return _ifcopenshell_wrapper.DoubleArray3_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _ifcopenshell_wrapper.DoubleArray3___nonzero__(self)

    def __bool__(self):
        return _ifcopenshell_wrapper.DoubleArray3___bool__(self)

    def __len__(self):
        return _ifcopenshell_wrapper.DoubleArray3___len__(self)

    def __getslice__(self, i, j):
        return _ifcopenshell_wrapper.DoubleArray3___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _ifcopenshell_wrapper.DoubleArray3___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _ifcopenshell_wrapper.DoubleArray3___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _ifcopenshell_wrapper.DoubleArray3___delitem__(self, *args)

    def __getitem__(self, *args):
        return _ifcopenshell_wrapper.DoubleArray3___getitem__(self, *args)

    def __setitem__(self, *args):
        return _ifcopenshell_wrapper.DoubleArray3___setitem__(self, *args)

    def __init__(self, *args):
        _ifcopenshell_wrapper.DoubleArray3_swiginit(self, _ifcopenshell_wrapper.new_DoubleArray3(*args))

    def empty(self):
        return _ifcopenshell_wrapper.DoubleArray3_empty(self)

    def size(self):
        return _ifcopenshell_wrapper.DoubleArray3_size(self)

    def swap(self, v):
        return _ifcopenshell_wrapper.DoubleArray3_swap(self, v)

    def begin(self):
        return _ifcopenshell_wrapper.DoubleArray3_begin(self)

    def end(self):
        return _ifcopenshell_wrapper.DoubleArray3_end(self)

    def rbegin(self):
        return _ifcopenshell_wrapper.DoubleArray3_rbegin(self)

    def rend(self):
        return _ifcopenshell_wrapper.DoubleArray3_rend(self)

    def front(self):
        return _ifcopenshell_wrapper.DoubleArray3_front(self)

    def back(self):
        return _ifcopenshell_wrapper.DoubleArray3_back(self)

    def fill(self, u):
        return _ifcopenshell_wrapper.DoubleArray3_fill(self, u)
    __swig_destroy__ = _ifcopenshell_wrapper.delete_DoubleArray3

# Register DoubleArray3 in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.DoubleArray3_swigregister(DoubleArray3)


def taxonomy_item_repr(i):
    r"""taxonomy_item_repr(ifcopenshell::geometry::taxonomy::item::ptr i) -> std::string"""
    return _ifcopenshell_wrapper.taxonomy_item_repr(i)
class OpaqueNumber(object):
    r"""Proxy of C++ IfcGeom::OpaqueNumber class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def to_double(self):
        r"""to_double(OpaqueNumber self) -> double"""
        return _ifcopenshell_wrapper.OpaqueNumber_to_double(self)

    def to_string(self):
        r"""to_string(OpaqueNumber self) -> std::string"""
        return _ifcopenshell_wrapper.OpaqueNumber_to_string(self)
    __swig_destroy__ = _ifcopenshell_wrapper.delete_OpaqueNumber

    def __add__(self, other):
        r"""__add__(OpaqueNumber self, OpaqueNumber other) -> OpaqueNumber"""
        return _ifcopenshell_wrapper.OpaqueNumber___add__(self, other)

    def __sub__(self, other):
        r"""__sub__(OpaqueNumber self, OpaqueNumber other) -> OpaqueNumber"""
        return _ifcopenshell_wrapper.OpaqueNumber___sub__(self, other)

    def __mul__(self, other):
        r"""__mul__(OpaqueNumber self, OpaqueNumber other) -> OpaqueNumber"""
        return _ifcopenshell_wrapper.OpaqueNumber___mul__(self, other)

    def __truediv__(self, *args):
        return _ifcopenshell_wrapper.OpaqueNumber___truediv__(self, *args)
    __div__ = __truediv__



    def __eq__(self, other):
        r"""__eq__(OpaqueNumber self, OpaqueNumber other) -> bool"""
        return _ifcopenshell_wrapper.OpaqueNumber___eq__(self, other)

    def __lt__(self, other):
        r"""__lt__(OpaqueNumber self, OpaqueNumber other) -> bool"""
        return _ifcopenshell_wrapper.OpaqueNumber___lt__(self, other)

    def __neg__(self):
        r"""__neg__(OpaqueNumber self) -> OpaqueNumber"""
        return _ifcopenshell_wrapper.OpaqueNumber___neg__(self)

    def clone(self):
        r"""clone(OpaqueNumber self) -> OpaqueNumber"""
        return _ifcopenshell_wrapper.OpaqueNumber_clone(self)

# Register OpaqueNumber in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.OpaqueNumber_swigregister(OpaqueNumber)

class ConversionResultShape(object):
    r"""Proxy of C++ IfcGeom::ConversionResultShape class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def Triangulate(self, *args):
        r"""
        Triangulate(ConversionResultShape self, Settings settings, matrix4 place, Triangulation t, int item_id, int surface_style_id)
        Triangulate(ConversionResultShape self, Settings settings) -> Triangulation
        """
        return _ifcopenshell_wrapper.ConversionResultShape_Triangulate(self, *args)

    def Serialize(self, place, arg3):
        r"""Serialize(ConversionResultShape self, matrix4 place, std::string & arg3)"""
        return _ifcopenshell_wrapper.ConversionResultShape_Serialize(self, place, arg3)

    def surface_genus(self):
        r"""surface_genus(ConversionResultShape self) -> int"""
        return _ifcopenshell_wrapper.ConversionResultShape_surface_genus(self)

    def is_manifold(self):
        r"""is_manifold(ConversionResultShape self) -> bool"""
        return _ifcopenshell_wrapper.ConversionResultShape_is_manifold(self)

    def num_vertices(self):
        r"""num_vertices(ConversionResultShape self) -> int"""
        return _ifcopenshell_wrapper.ConversionResultShape_num_vertices(self)

    def num_edges(self):
        r"""num_edges(ConversionResultShape self) -> int"""
        return _ifcopenshell_wrapper.ConversionResultShape_num_edges(self)

    def num_faces(self):
        r"""num_faces(ConversionResultShape self) -> int"""
        return _ifcopenshell_wrapper.ConversionResultShape_num_faces(self)

    def bounding_box(self, *args):
        r"""
        bounding_box(ConversionResultShape self, void *& arg2) -> double
        bounding_box(ConversionResultShape self) -> std::pair< IfcGeom::OpaqueCoordinate< 3 >,IfcGeom::OpaqueCoordinate< 3 > >
        """
        return _ifcopenshell_wrapper.ConversionResultShape_bounding_box(self, *args)

    def set_box(self, b):
        r"""set_box(ConversionResultShape self, void * b)"""
        return _ifcopenshell_wrapper.ConversionResultShape_set_box(self, b)

    def length(self):
        r"""length(ConversionResultShape self) -> OpaqueNumber"""
        return _ifcopenshell_wrapper.ConversionResultShape_length(self)

    def area(self):
        r"""area(ConversionResultShape self) -> OpaqueNumber"""
        return _ifcopenshell_wrapper.ConversionResultShape_area(self)

    def volume(self):
        r"""volume(ConversionResultShape self) -> OpaqueNumber"""
        return _ifcopenshell_wrapper.ConversionResultShape_volume(self)

    def position(self):
        r"""position(ConversionResultShape self) -> OpaqueCoordinate_3"""
        return _ifcopenshell_wrapper.ConversionResultShape_position(self)

    def axis(self):
        r"""axis(ConversionResultShape self) -> OpaqueCoordinate_3"""
        return _ifcopenshell_wrapper.ConversionResultShape_axis(self)

    def plane_equation(self):
        r"""plane_equation(ConversionResultShape self) -> OpaqueCoordinate_4"""
        return _ifcopenshell_wrapper.ConversionResultShape_plane_equation(self)

    def convex_decomposition(self):
        r"""convex_decomposition(ConversionResultShape self) -> std::vector< IfcGeom::ConversionResultShape *,std::allocator< IfcGeom::ConversionResultShape * > >"""
        return _ifcopenshell_wrapper.ConversionResultShape_convex_decomposition(self)

    def halfspaces(self):
        r"""halfspaces(ConversionResultShape self) -> ConversionResultShape"""
        return _ifcopenshell_wrapper.ConversionResultShape_halfspaces(self)

    def box(self):
        r"""box(ConversionResultShape self) -> ConversionResultShape"""
        return _ifcopenshell_wrapper.ConversionResultShape_box(self)

    def solid(self):
        r"""solid(ConversionResultShape self) -> ConversionResultShape"""
        return _ifcopenshell_wrapper.ConversionResultShape_solid(self)

    def vertices(self):
        r"""vertices(ConversionResultShape self) -> std::vector< IfcGeom::ConversionResultShape *,std::allocator< IfcGeom::ConversionResultShape * > >"""
        return _ifcopenshell_wrapper.ConversionResultShape_vertices(self)

    def edges(self):
        r"""edges(ConversionResultShape self) -> std::vector< IfcGeom::ConversionResultShape *,std::allocator< IfcGeom::ConversionResultShape * > >"""
        return _ifcopenshell_wrapper.ConversionResultShape_edges(self)

    def facets(self):
        r"""facets(ConversionResultShape self) -> std::vector< IfcGeom::ConversionResultShape *,std::allocator< IfcGeom::ConversionResultShape * > >"""
        return _ifcopenshell_wrapper.ConversionResultShape_facets(self)

    def add(self, arg2):
        r"""add(ConversionResultShape self, ConversionResultShape arg2) -> ConversionResultShape"""
        return _ifcopenshell_wrapper.ConversionResultShape_add(self, arg2)

    def subtract(self, arg2):
        r"""subtract(ConversionResultShape self, ConversionResultShape arg2) -> ConversionResultShape"""
        return _ifcopenshell_wrapper.ConversionResultShape_subtract(self, arg2)

    def intersect(self, arg2):
        r"""intersect(ConversionResultShape self, ConversionResultShape arg2) -> ConversionResultShape"""
        return _ifcopenshell_wrapper.ConversionResultShape_intersect(self, arg2)

    def map(self, *args):
        r"""
        map(ConversionResultShape self, OpaqueCoordinate_4 _from, OpaqueCoordinate_4 to)
        map(ConversionResultShape self, std::vector< IfcGeom::OpaqueCoordinate< 4 >,std::allocator< IfcGeom::OpaqueCoordinate< 4 > > > const & _from, std::vector< IfcGeom::OpaqueCoordinate< 4 >,std::allocator< IfcGeom::OpaqueCoordinate< 4 > > > const & to)
        """
        return _ifcopenshell_wrapper.ConversionResultShape_map(self, *args)

    def moved(self, arg2):
        r"""moved(ConversionResultShape self, ifcopenshell::geometry::taxonomy::matrix4::ptr arg2) -> ConversionResultShape"""
        return _ifcopenshell_wrapper.ConversionResultShape_moved(self, arg2)
    __swig_destroy__ = _ifcopenshell_wrapper.delete_ConversionResultShape

    def serialize_obj(self):
        r"""serialize_obj(ConversionResultShape self) -> std::string"""
        return _ifcopenshell_wrapper.ConversionResultShape_serialize_obj(self)

    def convex_tag(self, b):
        r"""convex_tag(ConversionResultShape self, bool b)"""
        return _ifcopenshell_wrapper.ConversionResultShape_convex_tag(self, b)

    def serialize(self):
        r"""serialize(ConversionResultShape self) -> std::string"""
        return _ifcopenshell_wrapper.ConversionResultShape_serialize(self)

    def solid_mt(self):
        r"""solid_mt(ConversionResultShape self) -> ConversionResultShape"""
        return _ifcopenshell_wrapper.ConversionResultShape_solid_mt(self)

# Register ConversionResultShape in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.ConversionResultShape_swigregister(ConversionResultShape)

class ConversionResult(object):
    r"""Proxy of C++ IfcGeom::ConversionResult class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(ConversionResult self, int id, ifcopenshell::geometry::taxonomy::matrix4::ptr placement, ConversionResultShape shape, ifcopenshell::geometry::taxonomy::style::ptr style) -> ConversionResult
        __init__(ConversionResult self, int id, ifcopenshell::geometry::taxonomy::matrix4::ptr placement, ConversionResultShape shape) -> ConversionResult
        __init__(ConversionResult self, int id, ConversionResultShape shape, ifcopenshell::geometry::taxonomy::style::ptr style) -> ConversionResult
        __init__(ConversionResult self, int id, ConversionResultShape shape) -> ConversionResult
        """
        _ifcopenshell_wrapper.ConversionResult_swiginit(self, _ifcopenshell_wrapper.new_ConversionResult(*args))

    def append(self, trsf):
        r"""append(ConversionResult self, ifcopenshell::geometry::taxonomy::matrix4::ptr trsf)"""
        return _ifcopenshell_wrapper.ConversionResult_append(self, trsf)

    def prepend(self, trsf):
        r"""prepend(ConversionResult self, ifcopenshell::geometry::taxonomy::matrix4::ptr trsf)"""
        return _ifcopenshell_wrapper.ConversionResult_prepend(self, trsf)

    def Shape(self):
        r"""Shape(ConversionResult self) -> std::shared_ptr< IfcGeom::ConversionResultShape >"""
        return _ifcopenshell_wrapper.ConversionResult_Shape(self)

    def Placement(self):
        r"""Placement(ConversionResult self) -> ifcopenshell::geometry::taxonomy::matrix4::ptr"""
        return _ifcopenshell_wrapper.ConversionResult_Placement(self)

    def hasStyle(self):
        r"""hasStyle(ConversionResult self) -> bool"""
        return _ifcopenshell_wrapper.ConversionResult_hasStyle(self)

    def Style(self):
        r"""Style(ConversionResult self) -> style"""
        return _ifcopenshell_wrapper.ConversionResult_Style(self)

    def StylePtr(self):
        r"""StylePtr(ConversionResult self) -> ifcopenshell::geometry::taxonomy::style::ptr"""
        return _ifcopenshell_wrapper.ConversionResult_StylePtr(self)

    def setStyle(self, newStyle):
        r"""setStyle(ConversionResult self, ifcopenshell::geometry::taxonomy::style::ptr newStyle)"""
        return _ifcopenshell_wrapper.ConversionResult_setStyle(self, newStyle)

    def ItemId(self):
        r"""ItemId(ConversionResult self) -> int"""
        return _ifcopenshell_wrapper.ConversionResult_ItemId(self)
    __swig_destroy__ = _ifcopenshell_wrapper.delete_ConversionResult

# Register ConversionResult in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.ConversionResult_swigregister(ConversionResult)

CURVES = _ifcopenshell_wrapper.CURVES

SURFACES_AND_SOLIDS = _ifcopenshell_wrapper.SURFACES_AND_SOLIDS

CURVES_SURFACES_AND_SOLIDS = _ifcopenshell_wrapper.CURVES_SURFACES_AND_SOLIDS

TRIANGULATED = _ifcopenshell_wrapper.TRIANGULATED

NATIVE = _ifcopenshell_wrapper.NATIVE

SERIALIZED = _ifcopenshell_wrapper.SERIALIZED

MAXSTEPSIZE = _ifcopenshell_wrapper.MAXSTEPSIZE

MINSTEPS = _ifcopenshell_wrapper.MINSTEPS

TRIANGLE_MESH = _ifcopenshell_wrapper.TRIANGLE_MESH

POLYHEDRON_WITHOUT_HOLES = _ifcopenshell_wrapper.POLYHEDRON_WITHOUT_HOLES

POLYHEDRON_WITH_HOLES = _ifcopenshell_wrapper.POLYHEDRON_WITH_HOLES


def __rshift__(*args):
    r"""
    __rshift__(std::istream & _in, ifcopenshell::geometry::settings::OutputDimensionalityTypes & ioo) -> std::istream
    __rshift__(std::istream & _in, ifcopenshell::geometry::settings::IteratorOutputOptions & ioo) -> std::istream
    __rshift__(std::istream & _in, ifcopenshell::geometry::settings::FunctionStepMethod & ioo) -> std::istream
    __rshift__(std::istream & _in, ifcopenshell::geometry::settings::TriangulationMethod & ioo) -> std::istream &
    """
    return _ifcopenshell_wrapper.__rshift__(*args)
class Settings(object):
    r"""Proxy of C++ ifcopenshell::geometry::Settings class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def set_(self, *args):
        r"""
        set_(Settings self, std::string const & name, bool val)
        set_(Settings self, std::string const & name, int val)
        set_(Settings self, std::string const & name, ifcopenshell::geometry::settings::IteratorOutputOptions val)
        set_(Settings self, std::string const & name, ifcopenshell::geometry::settings::FunctionStepMethod val)
        set_(Settings self, std::string const & name, ifcopenshell::geometry::settings::OutputDimensionalityTypes val)
        set_(Settings self, std::string const & name, double val)
        set_(Settings self, std::string const & name, std::string const & val)
        set_(Settings self, std::string const & name, std::set< int > const & val)
        set_(Settings self, std::string const & name, std::set< std::string > const & val)
        set_(Settings self, std::string const & name, std::vector< double,std::allocator< double > > const & val)
        """
        return _ifcopenshell_wrapper.Settings_set_(self, *args)

    def get_(self, name):
        r"""get_(Settings self, std::string const & name) -> ifcopenshell::geometry::Settings::value_variant_t"""
        return _ifcopenshell_wrapper.Settings_get_(self, name)

    def setting_names(self):
        r"""setting_names(Settings self) -> std::vector< std::string,std::allocator< std::string > >"""
        return _ifcopenshell_wrapper.Settings_setting_names(self)

    def get_type(self, name):
        r"""get_type(Settings self, std::string const & name) -> std::string"""
        return _ifcopenshell_wrapper.Settings_get_type(self, name)

    def __init__(self):
        r"""__init__(Settings self) -> Settings"""
        _ifcopenshell_wrapper.Settings_swiginit(self, _ifcopenshell_wrapper.new_Settings())
    __swig_destroy__ = _ifcopenshell_wrapper.delete_Settings

# Register Settings in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.Settings_swigregister(Settings)

class geometry_exception(object):
    r"""Proxy of C++ IfcGeom::geometry_exception class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, m):
        r"""__init__(geometry_exception self, std::string const & m) -> geometry_exception"""
        _ifcopenshell_wrapper.geometry_exception_swiginit(self, _ifcopenshell_wrapper.new_geometry_exception(m))
    __swig_destroy__ = _ifcopenshell_wrapper.delete_geometry_exception

    def what(self):
        r"""what(geometry_exception self) -> char const *"""
        return _ifcopenshell_wrapper.geometry_exception_what(self)

# Register geometry_exception in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.geometry_exception_swigregister(geometry_exception)

class too_many_faces_exception(geometry_exception):
    r"""Proxy of C++ IfcGeom::too_many_faces_exception class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(too_many_faces_exception self) -> too_many_faces_exception"""
        _ifcopenshell_wrapper.too_many_faces_exception_swiginit(self, _ifcopenshell_wrapper.new_too_many_faces_exception())
    __swig_destroy__ = _ifcopenshell_wrapper.delete_too_many_faces_exception

# Register too_many_faces_exception in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.too_many_faces_exception_swigregister(too_many_faces_exception)

class Transformation(object):
    r"""Proxy of C++ IfcGeom::Transformation class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, settings, matrix):
        r"""__init__(Transformation self, Settings settings, ifcopenshell::geometry::taxonomy::matrix4::ptr const & matrix) -> Transformation"""
        _ifcopenshell_wrapper.Transformation_swiginit(self, _ifcopenshell_wrapper.new_Transformation(settings, matrix))

    def data(self):
        r"""data(Transformation self) -> ifcopenshell::geometry::taxonomy::matrix4::ptr const &"""
        return _ifcopenshell_wrapper.Transformation_data(self)

    def matrix_(self):
        r"""matrix_(Transformation self) -> PyObject *"""
        return _ifcopenshell_wrapper.Transformation_matrix_(self)

            # Hide the getters with read-only property implementations
    matrix = property(matrix_)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_Transformation

# Register Transformation in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.Transformation_swigregister(Transformation)

class Element(object):
    r"""Proxy of C++ IfcGeom::Element class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def id(self):
        r"""id(Element self) -> int"""
        return _ifcopenshell_wrapper.Element_id(self)

    def parent_id(self):
        r"""parent_id(Element self) -> int"""
        return _ifcopenshell_wrapper.Element_parent_id(self)

    def name(self):
        r"""name(Element self) -> std::string const &"""
        return _ifcopenshell_wrapper.Element_name(self)

    def type(self):
        r"""type(Element self) -> std::string const &"""
        return _ifcopenshell_wrapper.Element_type(self)

    def guid(self):
        r"""guid(Element self) -> std::string const &"""
        return _ifcopenshell_wrapper.Element_guid(self)

    def context(self):
        r"""context(Element self) -> std::string const &"""
        return _ifcopenshell_wrapper.Element_context(self)

    def unique_id(self):
        r"""unique_id(Element self) -> std::string const &"""
        return _ifcopenshell_wrapper.Element_unique_id(self)

    def transformation(self):
        r"""transformation(Element self) -> Transformation"""
        return _ifcopenshell_wrapper.Element_transformation(self)

    def product(self):
        r"""product(Element self) -> IfcBaseEntity"""
        return _ifcopenshell_wrapper.Element_product(self)

    def parents(self):
        r"""parents(Element self) -> std::vector< IfcGeom::Element const *,std::allocator< IfcGeom::Element const * > > const &"""
        return _ifcopenshell_wrapper.Element_parents(self)

    def SetParents(self, newparents):
        r"""SetParents(Element self, std::vector< IfcGeom::Element const *,std::allocator< IfcGeom::Element const * > > & newparents)"""
        return _ifcopenshell_wrapper.Element_SetParents(self, newparents)

    def __init__(self, settings, id, parent_id, name, type, guid, context, trsf, product):
        r"""__init__(Element self, Settings settings, int id, int parent_id, std::string const & name, std::string const & type, std::string const & guid, std::string const & context, ifcopenshell::geometry::taxonomy::matrix4::ptr const & trsf, IfcBaseEntity product) -> Element"""
        _ifcopenshell_wrapper.Element_swiginit(self, _ifcopenshell_wrapper.new_Element(settings, id, parent_id, name, type, guid, context, trsf, product))
    __swig_destroy__ = _ifcopenshell_wrapper.delete_Element

    def transformation_buffer(self):
        r"""transformation_buffer(Element self) -> std::pair< char const *,size_t >"""
        return _ifcopenshell_wrapper.Element_transformation_buffer(self)

    def product_(self):
        r"""product_(Element self) -> entity_instance"""
        return _ifcopenshell_wrapper.Element_product_(self)

            # Hide the getters with read-only property implementations
    id = property(id)
    parent_id = property(parent_id)
    name = property(name)
    type = property(type)
    guid = property(guid)
    context = property(context)
    unique_id = property(unique_id)
    transformation = property(transformation)
    product = property(product_)

    transformation_buffer = property(transformation_buffer)


# Register Element in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.Element_swigregister(Element)

def __eq__(element1, element2):
    r"""__eq__(Element element1, Element element2) -> bool"""
    return _ifcopenshell_wrapper.__eq__(element1, element2)

def __lt__(element1, element2):
    r"""__lt__(Element element1, Element element2) -> bool"""
    return _ifcopenshell_wrapper.__lt__(element1, element2)

class BRepElement(Element):
    r"""Proxy of C++ IfcGeom::BRepElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def geometry_pointer(self):
        r"""geometry_pointer(BRepElement self) -> boost::shared_ptr< IfcGeom::Representation::BRep > const &"""
        return _ifcopenshell_wrapper.BRepElement_geometry_pointer(self)

    def geometry(self):
        r"""geometry(BRepElement self) -> BRep"""
        return _ifcopenshell_wrapper.BRepElement_geometry(self)

    def __init__(self, id, parent_id, name, type, guid, context, trsf, geometry, product):
        r"""__init__(BRepElement self, int id, int parent_id, std::string const & name, std::string const & type, std::string const & guid, std::string const & context, ifcopenshell::geometry::taxonomy::matrix4::ptr const & trsf, boost::shared_ptr< IfcGeom::Representation::BRep > const & geometry, IfcBaseEntity product) -> BRepElement"""
        _ifcopenshell_wrapper.BRepElement_swiginit(self, _ifcopenshell_wrapper.new_BRepElement(id, parent_id, name, type, guid, context, trsf, geometry, product))

    def calculate_projected_surface_area(self, along_x, along_y, along_z):
        r"""calculate_projected_surface_area(BRepElement self, double & along_x, double & along_y, double & along_z) -> bool"""
        return _ifcopenshell_wrapper.BRepElement_calculate_projected_surface_area(self, along_x, along_y, along_z)

    def calc_volume_(self):
        r"""calc_volume_(BRepElement self) -> double"""
        return _ifcopenshell_wrapper.BRepElement_calc_volume_(self)

    def calc_surface_area_(self):
        r"""calc_surface_area_(BRepElement self) -> double"""
        return _ifcopenshell_wrapper.BRepElement_calc_surface_area_(self)

            # Hide the getters with read-only property implementations
    geometry = property(geometry)
    volume = property(calc_volume_)
    surface_area = property(calc_surface_area_)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_BRepElement

# Register BRepElement in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.BRepElement_swigregister(BRepElement)

class TriangulationElement(Element):
    r"""Proxy of C++ IfcGeom::TriangulationElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def geometry(self):
        r"""geometry(TriangulationElement self) -> Triangulation"""
        return _ifcopenshell_wrapper.TriangulationElement_geometry(self)

    def geometry_pointer(self):
        r"""geometry_pointer(TriangulationElement self) -> boost::shared_ptr< IfcGeom::Representation::Triangulation > const &"""
        return _ifcopenshell_wrapper.TriangulationElement_geometry_pointer(self)

    def __init__(self, *args):
        r"""
        __init__(TriangulationElement self, BRepElement shape_model) -> TriangulationElement
        __init__(TriangulationElement self, Element element, boost::shared_ptr< IfcGeom::Representation::Triangulation > const & geometry) -> TriangulationElement
        """
        _ifcopenshell_wrapper.TriangulationElement_swiginit(self, _ifcopenshell_wrapper.new_TriangulationElement(*args))

            # Hide the getters with read-only property implementations
    geometry = property(geometry)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_TriangulationElement

# Register TriangulationElement in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.TriangulationElement_swigregister(TriangulationElement)

class SerializedElement(Element):
    r"""Proxy of C++ IfcGeom::SerializedElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def geometry(self):
        r"""geometry(SerializedElement self) -> Serialization"""
        return _ifcopenshell_wrapper.SerializedElement_geometry(self)

    def __init__(self, shape_model):
        r"""__init__(SerializedElement self, BRepElement shape_model) -> SerializedElement"""
        _ifcopenshell_wrapper.SerializedElement_swiginit(self, _ifcopenshell_wrapper.new_SerializedElement(shape_model))
    __swig_destroy__ = _ifcopenshell_wrapper.delete_SerializedElement

            # Hide the getters with read-only property implementations
    geometry = property(geometry)


# Register SerializedElement in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.SerializedElement_swigregister(SerializedElement)

class Representation(object):
    r"""Proxy of C++ IfcGeom::Representation::Representation class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, settings, entity, id):
        r"""__init__(Representation self, Settings settings, std::string const & entity, std::string const & id) -> Representation"""
        _ifcopenshell_wrapper.Representation_swiginit(self, _ifcopenshell_wrapper.new_Representation(settings, entity, id))

    def settings(self):
        r"""settings(Representation self) -> Settings"""
        return _ifcopenshell_wrapper.Representation_settings(self)

    def entity(self):
        r"""entity(Representation self) -> std::string const &"""
        return _ifcopenshell_wrapper.Representation_entity(self)

    def id(self):
        r"""id(Representation self) -> std::string const &"""
        return _ifcopenshell_wrapper.Representation_id(self)
    __swig_destroy__ = _ifcopenshell_wrapper.delete_Representation

            # Hide the getters with read-only property implementations
    id = property(id)


# Register Representation in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.Representation_swigregister(Representation)

class BRep(Representation):
    r"""Proxy of C++ IfcGeom::Representation::BRep class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, settings, entity, id, shapes):
        r"""__init__(BRep self, Settings settings, std::string const & entity, std::string const & id, IfcGeom::ConversionResults const & shapes) -> BRep"""
        _ifcopenshell_wrapper.BRep_swiginit(self, _ifcopenshell_wrapper.new_BRep(settings, entity, id, shapes))
    __swig_destroy__ = _ifcopenshell_wrapper.delete_BRep

    def begin(self):
        r"""begin(BRep self) -> IfcGeom::ConversionResults::const_iterator"""
        return _ifcopenshell_wrapper.BRep_begin(self)

    def end(self):
        r"""end(BRep self) -> IfcGeom::ConversionResults::const_iterator"""
        return _ifcopenshell_wrapper.BRep_end(self)

    def shapes(self):
        r"""shapes(BRep self) -> IfcGeom::ConversionResults const &"""
        return _ifcopenshell_wrapper.BRep_shapes(self)

    def as_compound(self, force_meters=False):
        r"""as_compound(BRep self, bool force_meters=False) -> ConversionResultShape"""
        return _ifcopenshell_wrapper.BRep_as_compound(self, force_meters)

    def calculate_volume(self, arg2):
        r"""calculate_volume(BRep self, double & arg2) -> bool"""
        return _ifcopenshell_wrapper.BRep_calculate_volume(self, arg2)

    def calculate_surface_area(self, arg2):
        r"""calculate_surface_area(BRep self, double & arg2) -> bool"""
        return _ifcopenshell_wrapper.BRep_calculate_surface_area(self, arg2)

    def calculate_projected_surface_area(self, ax, along_x, along_y, along_z):
        r"""calculate_projected_surface_area(BRep self, matrix4 ax, double & along_x, double & along_y, double & along_z) -> bool"""
        return _ifcopenshell_wrapper.BRep_calculate_projected_surface_area(self, ax, along_x, along_y, along_z)

    def size(self):
        r"""size(BRep self) -> int"""
        return _ifcopenshell_wrapper.BRep_size(self)

    def item(self, i):
        r"""item(BRep self, int i) -> ConversionResultShape"""
        return _ifcopenshell_wrapper.BRep_item(self, i)

    def item_id(self, i):
        r"""item_id(BRep self, int i) -> int"""
        return _ifcopenshell_wrapper.BRep_item_id(self, i)

# Register BRep in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.BRep_swigregister(BRep)

class Serialization(Representation):
    r"""Proxy of C++ IfcGeom::Representation::Serialization class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def brep_data(self):
        r"""brep_data(Serialization self) -> std::string const &"""
        return _ifcopenshell_wrapper.Serialization_brep_data(self)

    def surface_styles(self):
        r"""surface_styles(Serialization self) -> std::vector< double,std::allocator< double > > const &"""
        return _ifcopenshell_wrapper.Serialization_surface_styles(self)

    def surface_style_ids(self):
        r"""surface_style_ids(Serialization self) -> std::vector< int,std::allocator< int > > const &"""
        return _ifcopenshell_wrapper.Serialization_surface_style_ids(self)

    def __init__(self, brep):
        r"""__init__(Serialization self, BRep brep) -> Serialization"""
        _ifcopenshell_wrapper.Serialization_swiginit(self, _ifcopenshell_wrapper.new_Serialization(brep))
    __swig_destroy__ = _ifcopenshell_wrapper.delete_Serialization

            # Hide the getters with read-only property implementations
    brep_data = property(brep_data)
    surface_styles = property(surface_styles)
    surface_style_ids = property(surface_style_ids)


# Register Serialization in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.Serialization_swigregister(Serialization)

class Triangulation(Representation):
    r"""Proxy of C++ IfcGeom::Representation::Triangulation class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def verts(self):
        r"""verts(Triangulation self) -> std::vector< double,std::allocator< double > > const &"""
        return _ifcopenshell_wrapper.Triangulation_verts(self)

    def faces(self):
        r"""faces(Triangulation self) -> std::vector< int,std::allocator< int > > const &"""
        return _ifcopenshell_wrapper.Triangulation_faces(self)

    def polyhedral_faces_without_holes(self):
        r"""polyhedral_faces_without_holes(Triangulation self) -> std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &"""
        return _ifcopenshell_wrapper.Triangulation_polyhedral_faces_without_holes(self)

    def polyhedral_faces_with_holes(self):
        r"""polyhedral_faces_with_holes(Triangulation self) -> std::vector< std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >,std::allocator< std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > > > const &"""
        return _ifcopenshell_wrapper.Triangulation_polyhedral_faces_with_holes(self)

    def edges(self):
        r"""edges(Triangulation self) -> std::vector< int,std::allocator< int > > const &"""
        return _ifcopenshell_wrapper.Triangulation_edges(self)

    def normals(self):
        r"""normals(Triangulation self) -> std::vector< double,std::allocator< double > > const &"""
        return _ifcopenshell_wrapper.Triangulation_normals(self)

    def uvs(self):
        r"""uvs(Triangulation self) -> std::vector< double,std::allocator< double > > const &"""
        return _ifcopenshell_wrapper.Triangulation_uvs(self)

    def uvs_ref(self):
        r"""uvs_ref(Triangulation self) -> std::vector< double,std::allocator< double > > &"""
        return _ifcopenshell_wrapper.Triangulation_uvs_ref(self)

    def material_ids(self):
        r"""material_ids(Triangulation self) -> std::vector< int,std::allocator< int > > const &"""
        return _ifcopenshell_wrapper.Triangulation_material_ids(self)

    def materials(self):
        r"""materials(Triangulation self) -> std::vector< ifcopenshell::geometry::taxonomy::style::ptr,std::allocator< ifcopenshell::geometry::taxonomy::style::ptr > > const &"""
        return _ifcopenshell_wrapper.Triangulation_materials(self)

    def item_ids(self):
        r"""item_ids(Triangulation self) -> std::vector< int,std::allocator< int > > const &"""
        return _ifcopenshell_wrapper.Triangulation_item_ids(self)

    def edges_item_ids(self):
        r"""edges_item_ids(Triangulation self) -> std::vector< int,std::allocator< int > > const &"""
        return _ifcopenshell_wrapper.Triangulation_edges_item_ids(self)

    def __init__(self, *args):
        r"""
        __init__(Triangulation self, BRep shape_model) -> Triangulation
        __init__(Triangulation self, Settings settings, std::string const & entity, std::string const & id, std::vector< double,std::allocator< double > > const & verts, std::vector< int,std::allocator< int > > const & faces, std::vector< int,std::allocator< int > > const & edges, std::vector< double,std::allocator< double > > const & normals, std::vector< double,std::allocator< double > > const & uvs, std::vector< int,std::allocator< int > > const & material_ids, std::vector< ifcopenshell::geometry::taxonomy::style::ptr,std::allocator< ifcopenshell::geometry::taxonomy::style::ptr > > const & materials, std::vector< int,std::allocator< int > > const & item_ids, std::vector< int,std::allocator< int > > const & edges_item_ids) -> Triangulation
        """
        _ifcopenshell_wrapper.Triangulation_swiginit(self, _ifcopenshell_wrapper.new_Triangulation(*args))
    __swig_destroy__ = _ifcopenshell_wrapper.delete_Triangulation

    @staticmethod
    def box_project_uvs(vertices, normals):
        r"""box_project_uvs(std::vector< double,std::allocator< double > > const & vertices, std::vector< double,std::allocator< double > > const & normals) -> std::vector< double,std::allocator< double > >"""
        return _ifcopenshell_wrapper.Triangulation_box_project_uvs(vertices, normals)

    @staticmethod
    def empty(settings):
        r"""empty(Settings settings) -> Triangulation"""
        return _ifcopenshell_wrapper.Triangulation_empty(settings)

    def addVertex(self, item_index, material_index, X, Y, Z):
        r"""addVertex(Triangulation self, int item_index, int material_index, double X, double Y, double Z) -> int"""
        return _ifcopenshell_wrapper.Triangulation_addVertex(self, item_index, material_index, X, Y, Z)

    def addNormal(self, X, Y, Z):
        r"""addNormal(Triangulation self, double X, double Y, double Z)"""
        return _ifcopenshell_wrapper.Triangulation_addNormal(self, X, Y, Z)

    def addFace(self, *args):
        r"""
        addFace(Triangulation self, int item_id, int style, int i0, int i1, int i2)
        addFace(Triangulation self, int item_id, int style, std::vector< int,std::allocator< int > > const & outer_bound)
        addFace(Triangulation self, int item_id, int style, std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const & bounds)
        """
        return _ifcopenshell_wrapper.Triangulation_addFace(self, *args)

    def addEdge(self, item_id, style, i0, i1):
        r"""addEdge(Triangulation self, int item_id, int style, int i0, int i1)"""
        return _ifcopenshell_wrapper.Triangulation_addEdge(self, item_id, style, i0, i1)

    def registerEdge(self, item_id, i0, i1):
        r"""registerEdge(Triangulation self, int item_id, int i0, int i1)"""
        return _ifcopenshell_wrapper.Triangulation_registerEdge(self, item_id, i0, i1)

    def registerEdgeCount(self, n1, n2, edgecount):
        r"""registerEdgeCount(Triangulation self, int n1, int n2, std::map< std::pair< int,int >,int > & edgecount)"""
        return _ifcopenshell_wrapper.Triangulation_registerEdgeCount(self, n1, n2, edgecount)

    def resetWelds(self):
        r"""resetWelds(Triangulation self)"""
        return _ifcopenshell_wrapper.Triangulation_resetWelds(self)

    def faces_buffer(self):
        r"""faces_buffer(Triangulation self) -> std::pair< char const *,size_t >"""
        return _ifcopenshell_wrapper.Triangulation_faces_buffer(self)

    def edges_buffer(self):
        r"""edges_buffer(Triangulation self) -> std::pair< char const *,size_t >"""
        return _ifcopenshell_wrapper.Triangulation_edges_buffer(self)

    def material_ids_buffer(self):
        r"""material_ids_buffer(Triangulation self) -> std::pair< char const *,size_t >"""
        return _ifcopenshell_wrapper.Triangulation_material_ids_buffer(self)

    def item_ids_buffer(self):
        r"""item_ids_buffer(Triangulation self) -> std::pair< char const *,size_t >"""
        return _ifcopenshell_wrapper.Triangulation_item_ids_buffer(self)

    def edges_item_ids_buffer(self):
        r"""edges_item_ids_buffer(Triangulation self) -> std::pair< char const *,size_t >"""
        return _ifcopenshell_wrapper.Triangulation_edges_item_ids_buffer(self)

    def verts_buffer(self):
        r"""verts_buffer(Triangulation self) -> std::pair< char const *,size_t >"""
        return _ifcopenshell_wrapper.Triangulation_verts_buffer(self)

    def normals_buffer(self):
        r"""normals_buffer(Triangulation self) -> std::pair< char const *,size_t >"""
        return _ifcopenshell_wrapper.Triangulation_normals_buffer(self)

    def colors_buffer(self):
        r"""colors_buffer(Triangulation self) -> PyObject *"""
        return _ifcopenshell_wrapper.Triangulation_colors_buffer(self)

            # Hide the getters with read-only property implementations
    faces_tri = property(faces)
    polyhedral_faces_without_holes = property(polyhedral_faces_without_holes)
    polyhedral_faces_with_holes = property(polyhedral_faces_with_holes)
    def get_faces(self):
        if self.faces_tri: 
            return self.faces_tri
        elif self.polyhedral_faces_without_holes:
            return self.polyhedral_faces_without_holes
        else:
            return self.polyhedral_faces_with_holes
    faces = property(get_faces)
    edges = property(edges)
    material_ids = property(material_ids)
    materials = property(materials)
    verts = property(verts)
    normals = property(normals)
    item_ids = property(item_ids)
    uvs = property(uvs)
    edges_item_ids = property(edges_item_ids)

    faces_buffer = property(faces_buffer)
    edges_buffer = property(edges_buffer)
    material_ids_buffer = property(material_ids_buffer)
    item_ids_buffer = property(item_ids_buffer)
    edges_item_ids_buffer = property(edges_item_ids_buffer)
    verts_buffer = property(verts_buffer)
    normals_buffer = property(normals_buffer)
    colors_buffer = property(colors_buffer)


# Register Triangulation in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.Triangulation_swigregister(Triangulation)

def Triangulation_box_project_uvs(vertices, normals):
    r"""Triangulation_box_project_uvs(std::vector< double,std::allocator< double > > const & vertices, std::vector< double,std::allocator< double > > const & normals) -> std::vector< double,std::allocator< double > >"""
    return _ifcopenshell_wrapper.Triangulation_box_project_uvs(vertices, normals)

def Triangulation_empty(settings):
    r"""Triangulation_empty(Settings settings) -> Triangulation"""
    return _ifcopenshell_wrapper.Triangulation_empty(settings)

class geometry_conversion_result(object):
    r"""Proxy of C++ IfcGeom::geometry_conversion_result class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    index = property(_ifcopenshell_wrapper.geometry_conversion_result_index_get, _ifcopenshell_wrapper.geometry_conversion_result_index_set, doc=r"""index : int""")
    item = property(_ifcopenshell_wrapper.geometry_conversion_result_item_get, _ifcopenshell_wrapper.geometry_conversion_result_item_set, doc=r"""item : ifcopenshell::geometry::taxonomy::ptr""")
    products = property(_ifcopenshell_wrapper.geometry_conversion_result_products_get, _ifcopenshell_wrapper.geometry_conversion_result_products_set, doc=r"""products : std::vector<(std::pair<(p.IfcUtil::IfcBaseEntity,ifcopenshell::geometry::taxonomy::matrix4::ptr)>,std::allocator<(std::pair<(p.IfcUtil::IfcBaseEntity,ifcopenshell::geometry::taxonomy::matrix4::ptr)>)>)>""")
    representation = property(_ifcopenshell_wrapper.geometry_conversion_result_representation_get, _ifcopenshell_wrapper.geometry_conversion_result_representation_set, doc=r"""representation : p.IfcUtil::IfcBaseEntity""")
    products_2 = property(_ifcopenshell_wrapper.geometry_conversion_result_products_2_get, _ifcopenshell_wrapper.geometry_conversion_result_products_2_set, doc=r"""products_2 : aggregate_of_instance::ptr""")
    breps = property(_ifcopenshell_wrapper.geometry_conversion_result_breps_get, _ifcopenshell_wrapper.geometry_conversion_result_breps_set, doc=r"""breps : std::vector<(p.IfcGeom::BRepElement,std::allocator<(p.IfcGeom::BRepElement)>)>""")
    elements = property(_ifcopenshell_wrapper.geometry_conversion_result_elements_get, _ifcopenshell_wrapper.geometry_conversion_result_elements_set, doc=r"""elements : std::vector<(p.IfcGeom::Element,std::allocator<(p.IfcGeom::Element)>)>""")

    def __init__(self):
        r"""__init__(geometry_conversion_result self) -> geometry_conversion_result"""
        _ifcopenshell_wrapper.geometry_conversion_result_swiginit(self, _ifcopenshell_wrapper.new_geometry_conversion_result())
    __swig_destroy__ = _ifcopenshell_wrapper.delete_geometry_conversion_result

# Register geometry_conversion_result in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.geometry_conversion_result_swigregister(geometry_conversion_result)

class Iterator(object):
    r"""Proxy of C++ IfcGeom::Iterator class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(Iterator self, std::string const & geometry_library, Settings settings, file file, std::vector< IfcGeom::filter_t,std::allocator< IfcGeom::filter_t > > const & filters, int num_threads) -> Iterator
        __init__(Iterator self, Settings settings, file file, std::vector< IfcGeom::filter_t,std::allocator< IfcGeom::filter_t > > const & filters, int num_threads) -> Iterator
        __init__(Iterator self, Settings settings, file file) -> Iterator
        __init__(Iterator self, std::string const & geometry_library, Settings settings, file file) -> Iterator
        __init__(Iterator self, std::string const & geometry_library, Settings settings, file file, int num_threads) -> Iterator
        """
        _ifcopenshell_wrapper.Iterator_swiginit(self, _ifcopenshell_wrapper.new_Iterator(*args))
    __swig_destroy__ = _ifcopenshell_wrapper.delete_Iterator

    def set_cache(self, cache):
        r"""set_cache(Iterator self, GeometrySerializer cache)"""
        return _ifcopenshell_wrapper.Iterator_set_cache(self, cache)

    def get_task_items(self):
        r"""get_task_items(Iterator self) -> std::vector< ifcopenshell::geometry::taxonomy::item::ptr,std::allocator< ifcopenshell::geometry::taxonomy::item::ptr > >"""
        return _ifcopenshell_wrapper.Iterator_get_task_items(self)

    def get_task_products(self):
        r"""get_task_products(Iterator self) -> aggregate_of_aggregate_of_instance::ptr"""
        return _ifcopenshell_wrapper.Iterator_get_task_products(self)

    def unit_name(self):
        r"""unit_name(Iterator self) -> std::string const &"""
        return _ifcopenshell_wrapper.Iterator_unit_name(self)

    def unit_magnitude(self):
        r"""unit_magnitude(Iterator self) -> double"""
        return _ifcopenshell_wrapper.Iterator_unit_magnitude(self)

    def had_error_processing_elements(self):
        r"""had_error_processing_elements(Iterator self) -> bool"""
        return _ifcopenshell_wrapper.Iterator_had_error_processing_elements(self)
    initialization_outcome_ = property(_ifcopenshell_wrapper.Iterator_initialization_outcome__get, _ifcopenshell_wrapper.Iterator_initialization_outcome__set, doc=r"""initialization_outcome_ : boost::optional<(bool)>""")

    def initialize(self):
        r"""initialize(Iterator self) -> bool"""
        return _ifcopenshell_wrapper.Iterator_initialize(self)
    processed_ = property(_ifcopenshell_wrapper.Iterator_processed__get, _ifcopenshell_wrapper.Iterator_processed__set, doc=r"""processed_ : size_t""")

    def process_finished_rep(self, rep):
        r"""process_finished_rep(Iterator self, geometry_conversion_result rep)"""
        return _ifcopenshell_wrapper.Iterator_process_finished_rep(self, rep)

    def process_concurrently(self):
        r"""process_concurrently(Iterator self)"""
        return _ifcopenshell_wrapper.Iterator_process_concurrently(self)

    def compute_bounds(self, with_geometry):
        r"""compute_bounds(Iterator self, bool with_geometry)"""
        return _ifcopenshell_wrapper.Iterator_compute_bounds(self, with_geometry)

    def progress(self):
        r"""progress(Iterator self) -> int"""
        return _ifcopenshell_wrapper.Iterator_progress(self)

    def getLog(self):
        r"""getLog(Iterator self) -> std::string"""
        return _ifcopenshell_wrapper.Iterator_getLog(self)

    def file(self):
        r"""file(Iterator self) -> file"""
        return _ifcopenshell_wrapper.Iterator_file(self)

    def filters(self, *args):
        r"""
        filters(Iterator self) -> std::vector< IfcGeom::filter_t,std::allocator< IfcGeom::filter_t > > const
        filters(Iterator self) -> std::vector< IfcGeom::filter_t,std::allocator< IfcGeom::filter_t > > &
        """
        return _ifcopenshell_wrapper.Iterator_filters(self, *args)

    def bounds_min(self):
        r"""bounds_min(Iterator self) -> point3"""
        return _ifcopenshell_wrapper.Iterator_bounds_min(self)

    def bounds_max(self):
        r"""bounds_max(Iterator self) -> point3"""
        return _ifcopenshell_wrapper.Iterator_bounds_max(self)

    def next(self):
        r"""next(Iterator self) -> entity_instance"""
        return _ifcopenshell_wrapper.Iterator_next(self)

    def get(self):
        r"""get(Iterator self) -> Element"""
        return _ifcopenshell_wrapper.Iterator_get(self)

    def get_native(self):
        r"""get_native(Iterator self) -> BRepElement"""
        return _ifcopenshell_wrapper.Iterator_get_native(self)

    def get_object(self, id):
        r"""get_object(Iterator self, int id) -> Element"""
        return _ifcopenshell_wrapper.Iterator_get_object(self, id)

    def create(self):
        r"""create(Iterator self) -> entity_instance"""
        return _ifcopenshell_wrapper.Iterator_create(self)

# Register Iterator in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.Iterator_swigregister(Iterator)

class SerializerSettings(object):
    r"""Proxy of C++ ifcopenshell::geometry::SerializerSettings class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def set_(self, *args):
        r"""
        set_(SerializerSettings self, std::string const & name, bool val)
        set_(SerializerSettings self, std::string const & name, int val)
        set_(SerializerSettings self, std::string const & name, double val)
        set_(SerializerSettings self, std::string const & name, std::string const & val)
        set_(SerializerSettings self, std::string const & name, std::set< int > const & val)
        """
        return _ifcopenshell_wrapper.SerializerSettings_set_(self, *args)

    def get_(self, name):
        r"""get_(SerializerSettings self, std::string const & name) -> ifcopenshell::geometry::SerializerSettings::value_variant_t"""
        return _ifcopenshell_wrapper.SerializerSettings_get_(self, name)

    def setting_names(self):
        r"""setting_names(SerializerSettings self) -> std::vector< std::string,std::allocator< std::string > >"""
        return _ifcopenshell_wrapper.SerializerSettings_setting_names(self)

    def get_type(self, name):
        r"""get_type(SerializerSettings self, std::string const & name) -> std::string"""
        return _ifcopenshell_wrapper.SerializerSettings_get_type(self, name)

    def __init__(self):
        r"""__init__(SerializerSettings self) -> SerializerSettings"""
        _ifcopenshell_wrapper.SerializerSettings_swiginit(self, _ifcopenshell_wrapper.new_SerializerSettings())
    __swig_destroy__ = _ifcopenshell_wrapper.delete_SerializerSettings

# Register SerializerSettings in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.SerializerSettings_swigregister(SerializerSettings)

class buffer(object):
    r"""Proxy of C++ stream_or_filename class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(buffer self, std::string const & fn) -> buffer
        __init__(buffer self) -> buffer
        """
        _ifcopenshell_wrapper.buffer_swiginit(self, _ifcopenshell_wrapper.new_buffer(*args))

    def get_value(self):
        r"""get_value(buffer self) -> std::string"""
        return _ifcopenshell_wrapper.buffer_get_value(self)

    def filename(self):
        r"""filename(buffer self) -> boost::optional< std::string >"""
        return _ifcopenshell_wrapper.buffer_filename(self)

    def is_ready(self):
        r"""is_ready(buffer self) -> bool"""
        return _ifcopenshell_wrapper.buffer_is_ready(self)
    __swig_destroy__ = _ifcopenshell_wrapper.delete_buffer

# Register buffer in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.buffer_swigregister(buffer)

class GeometrySerializer(object):
    r"""Proxy of C++ GeometrySerializer class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    READ_BREP = _ifcopenshell_wrapper.GeometrySerializer_READ_BREP
    
    READ_TRIANGULATION = _ifcopenshell_wrapper.GeometrySerializer_READ_TRIANGULATION
    
    __swig_destroy__ = _ifcopenshell_wrapper.delete_GeometrySerializer

    def isTesselated(self):
        r"""isTesselated(GeometrySerializer self) -> bool"""
        return _ifcopenshell_wrapper.GeometrySerializer_isTesselated(self)

    def write(self, *args):
        r"""
        write(GeometrySerializer self, TriangulationElement o)
        write(GeometrySerializer self, BRepElement o)
        """
        return _ifcopenshell_wrapper.GeometrySerializer_write(self, *args)

    def setUnitNameAndMagnitude(self, name, magnitude):
        r"""setUnitNameAndMagnitude(GeometrySerializer self, std::string const & name, float magnitude)"""
        return _ifcopenshell_wrapper.GeometrySerializer_setUnitNameAndMagnitude(self, name, magnitude)

    def read(self, *args):
        r"""read(GeometrySerializer self, file f, std::string const & guid, std::string const & representation_id, GeometrySerializer::read_type rt=READ_BREP) -> Element"""
        return _ifcopenshell_wrapper.GeometrySerializer_read(self, *args)

    def settings(self, *args):
        r"""
        settings(GeometrySerializer self) -> SerializerSettings
        settings(GeometrySerializer self) -> SerializerSettings
        """
        return _ifcopenshell_wrapper.GeometrySerializer_settings(self, *args)

    def geometry_settings(self, *args):
        r"""
        geometry_settings(GeometrySerializer self) -> Settings
        geometry_settings(GeometrySerializer self) -> Settings
        """
        return _ifcopenshell_wrapper.GeometrySerializer_geometry_settings(self, *args)

    def object_id(self, o):
        r"""object_id(GeometrySerializer self, Element o) -> std::string"""
        return _ifcopenshell_wrapper.GeometrySerializer_object_id(self, o)

# Register GeometrySerializer in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.GeometrySerializer_swigregister(GeometrySerializer)

class WriteOnlyGeometrySerializer(GeometrySerializer):
    r"""Proxy of C++ WriteOnlyGeometrySerializer class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def read(self, *args):
        r"""read(WriteOnlyGeometrySerializer self, file arg2, std::string const & arg3, std::string const & arg4, GeometrySerializer::read_type arg5=READ_BREP) -> Element"""
        return _ifcopenshell_wrapper.WriteOnlyGeometrySerializer_read(self, *args)
    __swig_destroy__ = _ifcopenshell_wrapper.delete_WriteOnlyGeometrySerializer

# Register WriteOnlyGeometrySerializer in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.WriteOnlyGeometrySerializer_swigregister(WriteOnlyGeometrySerializer)

class topology_error(object):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::topology_error class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(topology_error self) -> topology_error
        __init__(topology_error self, char const *const s) -> topology_error
        """
        _ifcopenshell_wrapper.topology_error_swiginit(self, _ifcopenshell_wrapper.new_topology_error(*args))
    __swig_destroy__ = _ifcopenshell_wrapper.delete_topology_error

# Register topology_error in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.topology_error_swigregister(topology_error)

MATRIX4 = _ifcopenshell_wrapper.MATRIX4

POINT3 = _ifcopenshell_wrapper.POINT3

DIRECTION3 = _ifcopenshell_wrapper.DIRECTION3

LINE = _ifcopenshell_wrapper.LINE

CIRCLE = _ifcopenshell_wrapper.CIRCLE

ELLIPSE = _ifcopenshell_wrapper.ELLIPSE

BSPLINE_CURVE = _ifcopenshell_wrapper.BSPLINE_CURVE

OFFSET_CURVE = _ifcopenshell_wrapper.OFFSET_CURVE

PLANE = _ifcopenshell_wrapper.PLANE

CYLINDER = _ifcopenshell_wrapper.CYLINDER

SPHERE = _ifcopenshell_wrapper.SPHERE

TORUS = _ifcopenshell_wrapper.TORUS

BSPLINE_SURFACE = _ifcopenshell_wrapper.BSPLINE_SURFACE

EDGE = _ifcopenshell_wrapper.EDGE

LOOP = _ifcopenshell_wrapper.LOOP

FACE = _ifcopenshell_wrapper.FACE

SHELL = _ifcopenshell_wrapper.SHELL

SOLID = _ifcopenshell_wrapper.SOLID

LOFT = _ifcopenshell_wrapper.LOFT

EXTRUSION = _ifcopenshell_wrapper.EXTRUSION

REVOLVE = _ifcopenshell_wrapper.REVOLVE

SWEEP_ALONG_CURVE = _ifcopenshell_wrapper.SWEEP_ALONG_CURVE

NODE = _ifcopenshell_wrapper.NODE

COLLECTION = _ifcopenshell_wrapper.COLLECTION

BOOLEAN_RESULT = _ifcopenshell_wrapper.BOOLEAN_RESULT

FUNCTION_ITEM = _ifcopenshell_wrapper.FUNCTION_ITEM

FUNCTOR_ITEM = _ifcopenshell_wrapper.FUNCTOR_ITEM

PIECEWISE_FUNCTION = _ifcopenshell_wrapper.PIECEWISE_FUNCTION

GRADIENT_FUNCTION = _ifcopenshell_wrapper.GRADIENT_FUNCTION

CANT_FUNCTION = _ifcopenshell_wrapper.CANT_FUNCTION

OFFSET_FUNCTION = _ifcopenshell_wrapper.OFFSET_FUNCTION

COLOUR = _ifcopenshell_wrapper.COLOUR

STYLE = _ifcopenshell_wrapper.STYLE


def kind_to_string(k):
    r"""kind_to_string(ifcopenshell::geometry::taxonomy::kinds k) -> std::string const &"""
    return _ifcopenshell_wrapper.kind_to_string(k)
class item(object):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::item class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    instance = property(_ifcopenshell_wrapper.item_instance_get, _ifcopenshell_wrapper.item_instance_set, doc=r"""instance : p.q(const).IfcUtil::IfcBaseInterface""")
    orientation = property(_ifcopenshell_wrapper.item_orientation_get, _ifcopenshell_wrapper.item_orientation_set, doc=r"""orientation : boost::optional<(bool)>""")

    def clone_(self):
        r"""clone_(item self) -> item"""
        return _ifcopenshell_wrapper.item_clone_(self)

    def kind(self):
        r"""kind(item self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.item_kind(self)

    def reverse(self):
        r"""reverse(item self)"""
        return _ifcopenshell_wrapper.item_reverse(self)

    def calc_hash(self):
        r"""calc_hash(item self) -> size_t"""
        return _ifcopenshell_wrapper.item_calc_hash(self)

    def hash(self):
        r"""hash(item self) -> size_t"""
        return _ifcopenshell_wrapper.item_hash(self)
    __swig_destroy__ = _ifcopenshell_wrapper.delete_item

    def identity(self):
        r"""identity(item self) -> uint32_t"""
        return _ifcopenshell_wrapper.item_identity(self)

# Register item in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.item_swigregister(item)

class matrix4(item):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::matrix4 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    IDENTITY = _ifcopenshell_wrapper.matrix4_IDENTITY
    
    AFFINE_WO_SCALE = _ifcopenshell_wrapper.matrix4_AFFINE_WO_SCALE
    
    AFFINE_W_UNIFORM_SCALE = _ifcopenshell_wrapper.matrix4_AFFINE_W_UNIFORM_SCALE
    
    AFFINE_W_NONUNIFORM_SCALE = _ifcopenshell_wrapper.matrix4_AFFINE_W_NONUNIFORM_SCALE
    
    OTHER = _ifcopenshell_wrapper.matrix4_OTHER
    
    tag = property(_ifcopenshell_wrapper.matrix4_tag_get, _ifcopenshell_wrapper.matrix4_tag_set, doc=r"""tag : ifcopenshell::geometry::taxonomy::matrix4::tag_t""")

    def __init__(self, *args):
        r"""
        __init__(matrix4 self) -> matrix4
        __init__(matrix4 self, Eigen::Matrix4d const & c) -> matrix4
        __init__(matrix4 self, Eigen::Vector3d const & o, Eigen::Vector3d const & z, Eigen::Vector3d const & x) -> matrix4
        __init__(matrix4 self, Eigen::Vector3d const & o, Eigen::Vector3d const & z) -> matrix4
        """
        _ifcopenshell_wrapper.matrix4_swiginit(self, _ifcopenshell_wrapper.new_matrix4(*args))

    def is_identity(self):
        r"""is_identity(matrix4 self) -> bool"""
        return _ifcopenshell_wrapper.matrix4_is_identity(self)

    def clone_(self):
        r"""clone_(matrix4 self) -> matrix4"""
        return _ifcopenshell_wrapper.matrix4_clone_(self)

    def kind(self):
        r"""kind(matrix4 self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.matrix4_kind(self)

    def calc_hash(self):
        r"""calc_hash(matrix4 self) -> size_t"""
        return _ifcopenshell_wrapper.matrix4_calc_hash(self)

    def translation_part(self):
        r"""translation_part(matrix4 self) -> Eigen::Vector3d"""
        return _ifcopenshell_wrapper.matrix4_translation_part(self)

    def components_(self):
        r"""components_(matrix4 self) -> PyObject *"""
        return _ifcopenshell_wrapper.matrix4_components_(self)

    components = property(components_)


    __repr__ = taxonomy_item_repr

    __swig_destroy__ = _ifcopenshell_wrapper.delete_matrix4

# Register matrix4 in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.matrix4_swigregister(matrix4)

class colour(item):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::colour class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def clone_(self):
        r"""clone_(colour self) -> colour"""
        return _ifcopenshell_wrapper.colour_clone_(self)

    def kind(self):
        r"""kind(colour self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.colour_kind(self)

    def calc_hash(self):
        r"""calc_hash(colour self) -> size_t"""
        return _ifcopenshell_wrapper.colour_calc_hash(self)

    def __init__(self, *args):
        r"""
        __init__(colour self) -> colour
        __init__(colour self, double r, double g, double b) -> colour
        """
        _ifcopenshell_wrapper.colour_swiginit(self, _ifcopenshell_wrapper.new_colour(*args))

    def r(self):
        r"""r(colour self) -> double const &"""
        return _ifcopenshell_wrapper.colour_r(self)

    def g(self):
        r"""g(colour self) -> double const &"""
        return _ifcopenshell_wrapper.colour_g(self)

    def b(self):
        r"""b(colour self) -> double const &"""
        return _ifcopenshell_wrapper.colour_b(self)

    def components_(self):
        r"""components_(colour self) -> PyObject *"""
        return _ifcopenshell_wrapper.colour_components_(self)

    components = property(components_)


    __repr__ = taxonomy_item_repr

    __swig_destroy__ = _ifcopenshell_wrapper.delete_colour

# Register colour in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.colour_swigregister(colour)

class style(item):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::style class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    name = property(_ifcopenshell_wrapper.style_name_get, _ifcopenshell_wrapper.style_name_set, doc=r"""name : std::string""")
    diffuse = property(_ifcopenshell_wrapper.style_diffuse_get, _ifcopenshell_wrapper.style_diffuse_set, doc=r"""diffuse : ifcopenshell::geometry::taxonomy::colour""")
    surface = property(_ifcopenshell_wrapper.style_surface_get, _ifcopenshell_wrapper.style_surface_set, doc=r"""surface : ifcopenshell::geometry::taxonomy::colour""")
    specular = property(_ifcopenshell_wrapper.style_specular_get, _ifcopenshell_wrapper.style_specular_set, doc=r"""specular : ifcopenshell::geometry::taxonomy::colour""")
    specularity = property(_ifcopenshell_wrapper.style_specularity_get, _ifcopenshell_wrapper.style_specularity_set, doc=r"""specularity : double""")
    transparency = property(_ifcopenshell_wrapper.style_transparency_get, _ifcopenshell_wrapper.style_transparency_set, doc=r"""transparency : double""")
    use_surface_color = property(_ifcopenshell_wrapper.style_use_surface_color_get, _ifcopenshell_wrapper.style_use_surface_color_set, doc=r"""use_surface_color : bool""")

    def clone_(self):
        r"""clone_(style self) -> style"""
        return _ifcopenshell_wrapper.style_clone_(self)

    def kind(self):
        r"""kind(style self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.style_kind(self)

    def calc_hash(self):
        r"""calc_hash(style self) -> size_t"""
        return _ifcopenshell_wrapper.style_calc_hash(self)

    def __eq__(self, other):
        r"""__eq__(style self, style other) -> bool"""
        return _ifcopenshell_wrapper.style___eq__(self, other)

    def __init__(self, *args):
        r"""
        __init__(style self) -> style
        __init__(style self, std::string const & name) -> style
        """
        _ifcopenshell_wrapper.style_swiginit(self, _ifcopenshell_wrapper.new_style(*args))

    def get_color(self):
        r"""get_color(style self) -> colour"""
        return _ifcopenshell_wrapper.style_get_color(self)

    def has_specularity(self):
        r"""has_specularity(style self) -> bool"""
        return _ifcopenshell_wrapper.style_has_specularity(self)

    def has_transparency(self):
        r"""has_transparency(style self) -> bool"""
        return _ifcopenshell_wrapper.style_has_transparency(self)

    def instance_id(self):
        r"""instance_id(style self) -> size_t"""
        return _ifcopenshell_wrapper.style_instance_id(self)

    __repr__ = taxonomy_item_repr

    __swig_destroy__ = _ifcopenshell_wrapper.delete_style

# Register style in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.style_swigregister(style)

class geom_item(item):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::geom_item class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    surface_style = property(_ifcopenshell_wrapper.geom_item_surface_style_get, _ifcopenshell_wrapper.geom_item_surface_style_set, doc=r"""surface_style : ifcopenshell::geometry::taxonomy::style::ptr""")
    matrix = property(_ifcopenshell_wrapper.geom_item_matrix_get, _ifcopenshell_wrapper.geom_item_matrix_set, doc=r"""matrix : ifcopenshell::geometry::taxonomy::matrix4::ptr""")
    __swig_destroy__ = _ifcopenshell_wrapper.delete_geom_item

# Register geom_item in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.geom_item_swigregister(geom_item)

class implicit_item(geom_item):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::implicit_item class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _ifcopenshell_wrapper.delete_implicit_item

# Register implicit_item in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.implicit_item_swigregister(implicit_item)

class function_item(implicit_item):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::function_item class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _ifcopenshell_wrapper.delete_function_item

    def start(self):
        r"""start(function_item self) -> double"""
        return _ifcopenshell_wrapper.function_item_start(self)

    def end(self):
        r"""end(function_item self) -> double"""
        return _ifcopenshell_wrapper.function_item_end(self)

    def length(self):
        r"""length(function_item self) -> double"""
        return _ifcopenshell_wrapper.function_item_length(self)

    def kind(self):
        r"""kind(function_item self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.function_item_kind(self)

    def calc_hash(self):
        r"""calc_hash(function_item self) -> size_t"""
        return _ifcopenshell_wrapper.function_item_calc_hash(self)

    __repr__ = taxonomy_item_repr


# Register function_item in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.function_item_swigregister(function_item)

class functor_item(function_item):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::functor_item class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(functor_item self, double length, std::function< Eigen::Matrix4d (double) > fn, IfcUtil::IfcBaseInterface const * instance=None) -> functor_item
        __init__(functor_item self, functor_item arg2) -> functor_item
        __init__(functor_item self, functor_item arg2) -> functor_item
        """
        _ifcopenshell_wrapper.functor_item_swiginit(self, _ifcopenshell_wrapper.new_functor_item(*args))
    __swig_destroy__ = _ifcopenshell_wrapper.delete_functor_item

    def start(self):
        r"""start(functor_item self) -> double"""
        return _ifcopenshell_wrapper.functor_item_start(self)

    def end(self):
        r"""end(functor_item self) -> double"""
        return _ifcopenshell_wrapper.functor_item_end(self)

    def __call__(self, u):
        r"""__call__(functor_item self, double u) -> Eigen::Matrix4d"""
        return _ifcopenshell_wrapper.functor_item___call__(self, u)

    def clone_(self):
        r"""clone_(functor_item self) -> functor_item"""
        return _ifcopenshell_wrapper.functor_item_clone_(self)

    def kind(self):
        r"""kind(functor_item self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.functor_item_kind(self)

    def calc_hash(self):
        r"""calc_hash(functor_item self) -> size_t"""
        return _ifcopenshell_wrapper.functor_item_calc_hash(self)

    __repr__ = taxonomy_item_repr


# Register functor_item in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.functor_item_swigregister(functor_item)

class piecewise_function(function_item):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::piecewise_function class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(piecewise_function self, double start, ifcopenshell::geometry::taxonomy::piecewise_function::spans_t const & s, IfcUtil::IfcBaseInterface const * instance=None) -> piecewise_function
        __init__(piecewise_function self, double start, std::vector< ifcopenshell::geometry::taxonomy::piecewise_function::ptr,std::allocator< ifcopenshell::geometry::taxonomy::piecewise_function::ptr > > const & pwfs, IfcUtil::IfcBaseInterface const * instance=None) -> piecewise_function
        __init__(piecewise_function self, piecewise_function arg2) -> piecewise_function
        __init__(piecewise_function self, piecewise_function arg2) -> piecewise_function
        """
        _ifcopenshell_wrapper.piecewise_function_swiginit(self, _ifcopenshell_wrapper.new_piecewise_function(*args))
    __swig_destroy__ = _ifcopenshell_wrapper.delete_piecewise_function

    def spans(self):
        r"""spans(piecewise_function self) -> ifcopenshell::geometry::taxonomy::piecewise_function::spans_t const &"""
        return _ifcopenshell_wrapper.piecewise_function_spans(self)

    def span_count(self):
        r"""span_count(piecewise_function self) -> size_t"""
        return _ifcopenshell_wrapper.piecewise_function_span_count(self)

    def span_fn(self, i):
        r"""span_fn(piecewise_function self, size_t i) -> ifcopenshell::geometry::taxonomy::function_item::const_ptr"""
        return _ifcopenshell_wrapper.piecewise_function_span_fn(self, i)

    def is_empty(self):
        r"""is_empty(piecewise_function self) -> bool"""
        return _ifcopenshell_wrapper.piecewise_function_is_empty(self)

    def start(self):
        r"""start(piecewise_function self) -> double"""
        return _ifcopenshell_wrapper.piecewise_function_start(self)

    def end(self):
        r"""end(piecewise_function self) -> double"""
        return _ifcopenshell_wrapper.piecewise_function_end(self)

    def length(self):
        r"""length(piecewise_function self) -> double"""
        return _ifcopenshell_wrapper.piecewise_function_length(self)

    def clone_(self):
        r"""clone_(piecewise_function self) -> piecewise_function"""
        return _ifcopenshell_wrapper.piecewise_function_clone_(self)

    def kind(self):
        r"""kind(piecewise_function self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.piecewise_function_kind(self)

    def calc_hash(self):
        r"""calc_hash(piecewise_function self) -> size_t"""
        return _ifcopenshell_wrapper.piecewise_function_calc_hash(self)

    __repr__ = taxonomy_item_repr


# Register piecewise_function in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.piecewise_function_swigregister(piecewise_function)

class gradient_function(function_item):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::gradient_function class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(gradient_function self, ifcopenshell::geometry::taxonomy::piecewise_function::const_ptr horizontal, ifcopenshell::geometry::taxonomy::piecewise_function::const_ptr vertical, IfcUtil::IfcBaseInterface const * instance=None) -> gradient_function
        __init__(gradient_function self, gradient_function arg2) -> gradient_function
        __init__(gradient_function self, gradient_function arg2) -> gradient_function
        """
        _ifcopenshell_wrapper.gradient_function_swiginit(self, _ifcopenshell_wrapper.new_gradient_function(*args))
    __swig_destroy__ = _ifcopenshell_wrapper.delete_gradient_function

    def start(self):
        r"""start(gradient_function self) -> double"""
        return _ifcopenshell_wrapper.gradient_function_start(self)

    def end(self):
        r"""end(gradient_function self) -> double"""
        return _ifcopenshell_wrapper.gradient_function_end(self)

    def get_horizontal(self):
        r"""get_horizontal(gradient_function self) -> ifcopenshell::geometry::taxonomy::piecewise_function::const_ptr"""
        return _ifcopenshell_wrapper.gradient_function_get_horizontal(self)

    def get_vertical(self):
        r"""get_vertical(gradient_function self) -> ifcopenshell::geometry::taxonomy::piecewise_function::const_ptr"""
        return _ifcopenshell_wrapper.gradient_function_get_vertical(self)

    def clone_(self):
        r"""clone_(gradient_function self) -> gradient_function"""
        return _ifcopenshell_wrapper.gradient_function_clone_(self)

    def kind(self):
        r"""kind(gradient_function self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.gradient_function_kind(self)

    def calc_hash(self):
        r"""calc_hash(gradient_function self) -> size_t"""
        return _ifcopenshell_wrapper.gradient_function_calc_hash(self)

    __repr__ = taxonomy_item_repr


# Register gradient_function in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.gradient_function_swigregister(gradient_function)

class cant_function(function_item):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::cant_function class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(cant_function self, ifcopenshell::geometry::taxonomy::gradient_function::const_ptr gradient, ifcopenshell::geometry::taxonomy::piecewise_function::const_ptr cant, IfcUtil::IfcBaseInterface const * instance=None) -> cant_function
        __init__(cant_function self, cant_function arg2) -> cant_function
        __init__(cant_function self, cant_function arg2) -> cant_function
        """
        _ifcopenshell_wrapper.cant_function_swiginit(self, _ifcopenshell_wrapper.new_cant_function(*args))
    __swig_destroy__ = _ifcopenshell_wrapper.delete_cant_function

    def start(self):
        r"""start(cant_function self) -> double"""
        return _ifcopenshell_wrapper.cant_function_start(self)

    def end(self):
        r"""end(cant_function self) -> double"""
        return _ifcopenshell_wrapper.cant_function_end(self)

    def get_gradient(self):
        r"""get_gradient(cant_function self) -> ifcopenshell::geometry::taxonomy::gradient_function::const_ptr"""
        return _ifcopenshell_wrapper.cant_function_get_gradient(self)

    def get_cant(self):
        r"""get_cant(cant_function self) -> ifcopenshell::geometry::taxonomy::piecewise_function::const_ptr"""
        return _ifcopenshell_wrapper.cant_function_get_cant(self)

    def clone_(self):
        r"""clone_(cant_function self) -> cant_function"""
        return _ifcopenshell_wrapper.cant_function_clone_(self)

    def kind(self):
        r"""kind(cant_function self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.cant_function_kind(self)

    def calc_hash(self):
        r"""calc_hash(cant_function self) -> size_t"""
        return _ifcopenshell_wrapper.cant_function_calc_hash(self)

    __repr__ = taxonomy_item_repr


# Register cant_function in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.cant_function_swigregister(cant_function)

class offset_function(function_item):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::offset_function class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(offset_function self, ifcopenshell::geometry::taxonomy::function_item::const_ptr basis, ifcopenshell::geometry::taxonomy::piecewise_function::const_ptr offset, IfcUtil::IfcBaseInterface const * instance=None) -> offset_function
        __init__(offset_function self, offset_function arg2) -> offset_function
        __init__(offset_function self, offset_function arg2) -> offset_function
        """
        _ifcopenshell_wrapper.offset_function_swiginit(self, _ifcopenshell_wrapper.new_offset_function(*args))
    __swig_destroy__ = _ifcopenshell_wrapper.delete_offset_function

    def start(self):
        r"""start(offset_function self) -> double"""
        return _ifcopenshell_wrapper.offset_function_start(self)

    def end(self):
        r"""end(offset_function self) -> double"""
        return _ifcopenshell_wrapper.offset_function_end(self)

    def get_basis(self):
        r"""get_basis(offset_function self) -> ifcopenshell::geometry::taxonomy::function_item::const_ptr"""
        return _ifcopenshell_wrapper.offset_function_get_basis(self)

    def get_offset(self):
        r"""get_offset(offset_function self) -> ifcopenshell::geometry::taxonomy::piecewise_function::const_ptr"""
        return _ifcopenshell_wrapper.offset_function_get_offset(self)

    def clone_(self):
        r"""clone_(offset_function self) -> offset_function"""
        return _ifcopenshell_wrapper.offset_function_clone_(self)

    def kind(self):
        r"""kind(offset_function self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.offset_function_kind(self)

    def calc_hash(self):
        r"""calc_hash(offset_function self) -> size_t"""
        return _ifcopenshell_wrapper.offset_function_calc_hash(self)

    __repr__ = taxonomy_item_repr


# Register offset_function in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.offset_function_swigregister(offset_function)


def less(arg1, arg2):
    r"""less(ifcopenshell::geometry::taxonomy::item::const_ptr arg1, ifcopenshell::geometry::taxonomy::item::const_ptr arg2) -> bool"""
    return _ifcopenshell_wrapper.less(arg1, arg2)
class less_functor(object):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::less_functor class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __call__(self, a, b):
        r"""__call__(less_functor self, ifcopenshell::geometry::taxonomy::item::const_ptr a, ifcopenshell::geometry::taxonomy::item::const_ptr b) -> bool"""
        return _ifcopenshell_wrapper.less_functor___call__(self, a, b)

    def __init__(self):
        r"""__init__(less_functor self) -> less_functor"""
        _ifcopenshell_wrapper.less_functor_swiginit(self, _ifcopenshell_wrapper.new_less_functor())
    __swig_destroy__ = _ifcopenshell_wrapper.delete_less_functor

# Register less_functor in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.less_functor_swigregister(less_functor)

class equal_functor(object):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::equal_functor class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __call__(self, a, b):
        r"""__call__(equal_functor self, ifcopenshell::geometry::taxonomy::item::ptr const & a, ifcopenshell::geometry::taxonomy::item::ptr const & b) -> bool"""
        return _ifcopenshell_wrapper.equal_functor___call__(self, a, b)

    def __init__(self):
        r"""__init__(equal_functor self) -> equal_functor"""
        _ifcopenshell_wrapper.equal_functor_swiginit(self, _ifcopenshell_wrapper.new_equal_functor())
    __swig_destroy__ = _ifcopenshell_wrapper.delete_equal_functor

# Register equal_functor in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.equal_functor_swigregister(equal_functor)

class hash_functor(object):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::hash_functor class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __call__(self, a):
        r"""__call__(hash_functor self, ifcopenshell::geometry::taxonomy::item::ptr const & a) -> size_t"""
        return _ifcopenshell_wrapper.hash_functor___call__(self, a)

    def __init__(self):
        r"""__init__(hash_functor self) -> hash_functor"""
        _ifcopenshell_wrapper.hash_functor_swiginit(self, _ifcopenshell_wrapper.new_hash_functor())
    __swig_destroy__ = _ifcopenshell_wrapper.delete_hash_functor

# Register hash_functor in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.hash_functor_swigregister(hash_functor)

class point3(object):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::point3 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def clone_(self):
        r"""clone_(point3 self) -> point3"""
        return _ifcopenshell_wrapper.point3_clone_(self)

    def kind(self):
        r"""kind(point3 self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.point3_kind(self)

    def calc_hash(self):
        r"""calc_hash(point3 self) -> size_t"""
        return _ifcopenshell_wrapper.point3_calc_hash(self)

    def _print(self, o, indent=0):
        r"""_print(point3 self, std::ostream & o, int indent=0)"""
        return _ifcopenshell_wrapper.point3__print(self, o, indent)

    def __init__(self, *args):
        r"""
        __init__(point3 self) -> point3
        __init__(point3 self, Eigen::Vector3d const & c) -> point3
        __init__(point3 self, double x, double y, double z=0.) -> point3
        """
        _ifcopenshell_wrapper.point3_swiginit(self, _ifcopenshell_wrapper.new_point3(*args))

    def components_(self):
        r"""components_(point3 self) -> PyObject *"""
        return _ifcopenshell_wrapper.point3_components_(self)

    components = property(components_)


    __repr__ = taxonomy_item_repr

    __swig_destroy__ = _ifcopenshell_wrapper.delete_point3

# Register point3 in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.point3_swigregister(point3)

class direction3(object):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::direction3 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def clone_(self):
        r"""clone_(direction3 self) -> direction3"""
        return _ifcopenshell_wrapper.direction3_clone_(self)

    def kind(self):
        r"""kind(direction3 self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.direction3_kind(self)

    def calc_hash(self):
        r"""calc_hash(direction3 self) -> size_t"""
        return _ifcopenshell_wrapper.direction3_calc_hash(self)

    def _print(self, o, indent=0):
        r"""_print(direction3 self, std::ostream & o, int indent=0)"""
        return _ifcopenshell_wrapper.direction3__print(self, o, indent)

    def __init__(self, *args):
        r"""
        __init__(direction3 self) -> direction3
        __init__(direction3 self, Eigen::Vector3d const & c) -> direction3
        __init__(direction3 self, double x, double y, double z=0.) -> direction3
        """
        _ifcopenshell_wrapper.direction3_swiginit(self, _ifcopenshell_wrapper.new_direction3(*args))

    def components_(self):
        r"""components_(direction3 self) -> PyObject *"""
        return _ifcopenshell_wrapper.direction3_components_(self)

    components = property(components_)


    __repr__ = taxonomy_item_repr

    __swig_destroy__ = _ifcopenshell_wrapper.delete_direction3

# Register direction3 in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.direction3_swigregister(direction3)

class curve(geom_item):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::curve class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def print_impl(self, o, classname, indent=0):
        r"""print_impl(curve self, std::ostream & o, std::string const & classname, int indent=0)"""
        return _ifcopenshell_wrapper.curve_print_impl(self, o, classname, indent)
    __swig_destroy__ = _ifcopenshell_wrapper.delete_curve

# Register curve in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.curve_swigregister(curve)

class line(curve):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::line class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def clone_(self):
        r"""clone_(line self) -> line"""
        return _ifcopenshell_wrapper.line_clone_(self)

    def kind(self):
        r"""kind(line self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.line_kind(self)

    def calc_hash(self):
        r"""calc_hash(line self) -> size_t"""
        return _ifcopenshell_wrapper.line_calc_hash(self)

    def matrix_(self):
        r"""matrix_(line self) -> ifcopenshell::geometry::taxonomy::matrix4::ptr const &"""
        return _ifcopenshell_wrapper.line_matrix_(self)

    matrix = property(matrix_)


    __repr__ = taxonomy_item_repr


    def __init__(self):
        r"""__init__(line self) -> line"""
        _ifcopenshell_wrapper.line_swiginit(self, _ifcopenshell_wrapper.new_line())
    __swig_destroy__ = _ifcopenshell_wrapper.delete_line

# Register line in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.line_swigregister(line)

class circle(curve):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::circle class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    radius = property(_ifcopenshell_wrapper.circle_radius_get, _ifcopenshell_wrapper.circle_radius_set, doc=r"""radius : double""")

    def clone_(self):
        r"""clone_(circle self) -> circle"""
        return _ifcopenshell_wrapper.circle_clone_(self)

    def kind(self):
        r"""kind(circle self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.circle_kind(self)

    def calc_hash(self):
        r"""calc_hash(circle self) -> size_t"""
        return _ifcopenshell_wrapper.circle_calc_hash(self)

    @staticmethod
    def from_3_points(p1, p2, p3):
        r"""from_3_points(Eigen::Vector3d const & p1, Eigen::Vector3d const & p2, Eigen::Vector3d const & p3) -> ifcopenshell::geometry::taxonomy::circle::ptr"""
        return _ifcopenshell_wrapper.circle_from_3_points(p1, p2, p3)

    def matrix_(self):
        r"""matrix_(circle self) -> ifcopenshell::geometry::taxonomy::matrix4::ptr const &"""
        return _ifcopenshell_wrapper.circle_matrix_(self)

    matrix = property(matrix_)


    __repr__ = taxonomy_item_repr


    def __init__(self):
        r"""__init__(circle self) -> circle"""
        _ifcopenshell_wrapper.circle_swiginit(self, _ifcopenshell_wrapper.new_circle())
    __swig_destroy__ = _ifcopenshell_wrapper.delete_circle

# Register circle in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.circle_swigregister(circle)

def circle_from_3_points(p1, p2, p3):
    r"""circle_from_3_points(Eigen::Vector3d const & p1, Eigen::Vector3d const & p2, Eigen::Vector3d const & p3) -> ifcopenshell::geometry::taxonomy::circle::ptr"""
    return _ifcopenshell_wrapper.circle_from_3_points(p1, p2, p3)

class ellipse(curve):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::ellipse class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    radius = property(_ifcopenshell_wrapper.ellipse_radius_get, _ifcopenshell_wrapper.ellipse_radius_set, doc=r"""radius : double""")
    radius2 = property(_ifcopenshell_wrapper.ellipse_radius2_get, _ifcopenshell_wrapper.ellipse_radius2_set, doc=r"""radius2 : double""")

    def clone_(self):
        r"""clone_(ellipse self) -> ellipse"""
        return _ifcopenshell_wrapper.ellipse_clone_(self)

    def kind(self):
        r"""kind(ellipse self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.ellipse_kind(self)

    def calc_hash(self):
        r"""calc_hash(ellipse self) -> size_t"""
        return _ifcopenshell_wrapper.ellipse_calc_hash(self)

    def matrix_(self):
        r"""matrix_(ellipse self) -> ifcopenshell::geometry::taxonomy::matrix4::ptr const &"""
        return _ifcopenshell_wrapper.ellipse_matrix_(self)

    matrix = property(matrix_)


    __repr__ = taxonomy_item_repr


    def __init__(self):
        r"""__init__(ellipse self) -> ellipse"""
        _ifcopenshell_wrapper.ellipse_swiginit(self, _ifcopenshell_wrapper.new_ellipse())
    __swig_destroy__ = _ifcopenshell_wrapper.delete_ellipse

# Register ellipse in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.ellipse_swigregister(ellipse)

class bspline_curve(curve):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::bspline_curve class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def clone_(self):
        r"""clone_(bspline_curve self) -> bspline_curve"""
        return _ifcopenshell_wrapper.bspline_curve_clone_(self)

    def kind(self):
        r"""kind(bspline_curve self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.bspline_curve_kind(self)

    def calc_hash(self):
        r"""calc_hash(bspline_curve self) -> size_t"""
        return _ifcopenshell_wrapper.bspline_curve_calc_hash(self)
    control_points = property(_ifcopenshell_wrapper.bspline_curve_control_points_get, _ifcopenshell_wrapper.bspline_curve_control_points_set, doc=r"""control_points : std::vector<(ifcopenshell::geometry::taxonomy::point3::ptr,std::allocator<(ifcopenshell::geometry::taxonomy::point3::ptr)>)>""")
    multiplicities = property(_ifcopenshell_wrapper.bspline_curve_multiplicities_get, _ifcopenshell_wrapper.bspline_curve_multiplicities_set, doc=r"""multiplicities : std::vector<(int,std::allocator<(int)>)>""")
    knots = property(_ifcopenshell_wrapper.bspline_curve_knots_get, _ifcopenshell_wrapper.bspline_curve_knots_set, doc=r"""knots : std::vector<(double,std::allocator<(double)>)>""")
    weights = property(_ifcopenshell_wrapper.bspline_curve_weights_get, _ifcopenshell_wrapper.bspline_curve_weights_set, doc=r"""weights : boost::optional<(std::vector<(double,std::allocator<(double)>)>)>""")
    degree = property(_ifcopenshell_wrapper.bspline_curve_degree_get, _ifcopenshell_wrapper.bspline_curve_degree_set, doc=r"""degree : int""")

    __repr__ = taxonomy_item_repr


    def __init__(self):
        r"""__init__(bspline_curve self) -> bspline_curve"""
        _ifcopenshell_wrapper.bspline_curve_swiginit(self, _ifcopenshell_wrapper.new_bspline_curve())
    __swig_destroy__ = _ifcopenshell_wrapper.delete_bspline_curve

# Register bspline_curve in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.bspline_curve_swigregister(bspline_curve)

class offset_curve(curve):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::offset_curve class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    reference = property(_ifcopenshell_wrapper.offset_curve_reference_get, _ifcopenshell_wrapper.offset_curve_reference_set, doc=r"""reference : ifcopenshell::geometry::taxonomy::direction3::ptr""")
    offset = property(_ifcopenshell_wrapper.offset_curve_offset_get, _ifcopenshell_wrapper.offset_curve_offset_set, doc=r"""offset : double""")
    basis = property(_ifcopenshell_wrapper.offset_curve_basis_get, _ifcopenshell_wrapper.offset_curve_basis_set, doc=r"""basis : ifcopenshell::geometry::taxonomy::item::ptr""")

    def clone_(self):
        r"""clone_(offset_curve self) -> offset_curve"""
        return _ifcopenshell_wrapper.offset_curve_clone_(self)

    def kind(self):
        r"""kind(offset_curve self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.offset_curve_kind(self)

    def calc_hash(self):
        r"""calc_hash(offset_curve self) -> size_t"""
        return _ifcopenshell_wrapper.offset_curve_calc_hash(self)

    __repr__ = taxonomy_item_repr


    def __init__(self):
        r"""__init__(offset_curve self) -> offset_curve"""
        _ifcopenshell_wrapper.offset_curve_swiginit(self, _ifcopenshell_wrapper.new_offset_curve())
    __swig_destroy__ = _ifcopenshell_wrapper.delete_offset_curve

# Register offset_curve in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.offset_curve_swigregister(offset_curve)

class trimmed_curve(geom_item):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::trimmed_curve class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    start = property(_ifcopenshell_wrapper.trimmed_curve_start_get, _ifcopenshell_wrapper.trimmed_curve_start_set, doc=r"""start : boost::variant<(boost::blank,ifcopenshell::geometry::taxonomy::point3::ptr,double)>""")
    end = property(_ifcopenshell_wrapper.trimmed_curve_end_get, _ifcopenshell_wrapper.trimmed_curve_end_set, doc=r"""end : boost::variant<(boost::blank,ifcopenshell::geometry::taxonomy::point3::ptr,double)>""")
    basis = property(_ifcopenshell_wrapper.trimmed_curve_basis_get, _ifcopenshell_wrapper.trimmed_curve_basis_set, doc=r"""basis : ifcopenshell::geometry::taxonomy::item::ptr""")
    curve_sense = property(_ifcopenshell_wrapper.trimmed_curve_curve_sense_get, _ifcopenshell_wrapper.trimmed_curve_curve_sense_set, doc=r"""curve_sense : boost::optional<(bool)>""")

    def reverse(self):
        r"""reverse(trimmed_curve self)"""
        return _ifcopenshell_wrapper.trimmed_curve_reverse(self)
    __swig_destroy__ = _ifcopenshell_wrapper.delete_trimmed_curve

# Register trimmed_curve in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.trimmed_curve_swigregister(trimmed_curve)

class edge(trimmed_curve):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::edge class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(edge self) -> edge
        __init__(edge self, ifcopenshell::geometry::taxonomy::point3::ptr const & a, ifcopenshell::geometry::taxonomy::point3::ptr const & b) -> edge
        """
        _ifcopenshell_wrapper.edge_swiginit(self, _ifcopenshell_wrapper.new_edge(*args))

    def clone_(self):
        r"""clone_(edge self) -> edge"""
        return _ifcopenshell_wrapper.edge_clone_(self)

    def kind(self):
        r"""kind(edge self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.edge_kind(self)

    def calc_hash(self):
        r"""calc_hash(edge self) -> size_t"""
        return _ifcopenshell_wrapper.edge_calc_hash(self)

    __repr__ = taxonomy_item_repr

    __swig_destroy__ = _ifcopenshell_wrapper.delete_edge

# Register edge in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.edge_swigregister(edge)

class collection(object):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::collection class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def clone_(self):
        r"""clone_(collection self) -> collection"""
        return _ifcopenshell_wrapper.collection_clone_(self)

    def kind(self):
        r"""kind(collection self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.collection_kind(self)

    def calc_hash(self):
        r"""calc_hash(collection self) -> size_t"""
        return _ifcopenshell_wrapper.collection_calc_hash(self)

    def children_(self):
        r"""children_(collection self) -> std::vector< ifcopenshell::geometry::taxonomy::geom_item::ptr,std::allocator< ifcopenshell::geometry::taxonomy::geom_item::ptr > > const &"""
        return _ifcopenshell_wrapper.collection_children_(self)

    def __getitem__(self, index):
        r"""__getitem__(collection self, int index) -> ifcopenshell::geometry::taxonomy::geom_item::ptr const &"""
        return _ifcopenshell_wrapper.collection___getitem__(self, index)

    children = property(children_)
    def __iter__(self):
    	return iter(self.children)


    def matrix_(self):
        r"""matrix_(collection self) -> ifcopenshell::geometry::taxonomy::matrix4::ptr const &"""
        return _ifcopenshell_wrapper.collection_matrix_(self)

    matrix = property(matrix_)


    __repr__ = taxonomy_item_repr


    def __init__(self):
        r"""__init__(collection self) -> collection"""
        _ifcopenshell_wrapper.collection_swiginit(self, _ifcopenshell_wrapper.new_collection())
    __swig_destroy__ = _ifcopenshell_wrapper.delete_collection

# Register collection in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.collection_swigregister(collection)

class loop(object):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::loop class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    external = property(_ifcopenshell_wrapper.loop_external_get, _ifcopenshell_wrapper.loop_external_set, doc=r"""external : boost::optional<(bool)>""")
    closed = property(_ifcopenshell_wrapper.loop_closed_get, _ifcopenshell_wrapper.loop_closed_set, doc=r"""closed : boost::optional<(bool)>""")
    fi = property(_ifcopenshell_wrapper.loop_fi_get, _ifcopenshell_wrapper.loop_fi_set, doc=r"""fi : boost::optional<(ifcopenshell::geometry::taxonomy::function_item::ptr)>""")

    def is_polyhedron(self):
        r"""is_polyhedron(loop self) -> bool"""
        return _ifcopenshell_wrapper.loop_is_polyhedron(self)

    def calculate_linear_edge_curves(self):
        r"""calculate_linear_edge_curves(loop self)"""
        return _ifcopenshell_wrapper.loop_calculate_linear_edge_curves(self)

    def remove_linear_edge_curves(self):
        r"""remove_linear_edge_curves(loop self)"""
        return _ifcopenshell_wrapper.loop_remove_linear_edge_curves(self)

    def clone_(self):
        r"""clone_(loop self) -> loop"""
        return _ifcopenshell_wrapper.loop_clone_(self)

    def kind(self):
        r"""kind(loop self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.loop_kind(self)

    def calc_hash(self):
        r"""calc_hash(loop self) -> size_t"""
        return _ifcopenshell_wrapper.loop_calc_hash(self)

    def centroid(self):
        r"""centroid(loop self) -> ifcopenshell::geometry::taxonomy::point3::ptr"""
        return _ifcopenshell_wrapper.loop_centroid(self)

    def children_(self):
        r"""children_(loop self) -> std::vector< ifcopenshell::geometry::taxonomy::edge::ptr,std::allocator< ifcopenshell::geometry::taxonomy::edge::ptr > > const &"""
        return _ifcopenshell_wrapper.loop_children_(self)

    def __getitem__(self, index):
        r"""__getitem__(loop self, int index) -> ifcopenshell::geometry::taxonomy::edge::ptr const &"""
        return _ifcopenshell_wrapper.loop___getitem__(self, index)

    children = property(children_)
    def __iter__(self):
    	return iter(self.children)


    __repr__ = taxonomy_item_repr


    def __init__(self):
        r"""__init__(loop self) -> loop"""
        _ifcopenshell_wrapper.loop_swiginit(self, _ifcopenshell_wrapper.new_loop())
    __swig_destroy__ = _ifcopenshell_wrapper.delete_loop

# Register loop in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.loop_swigregister(loop)

class face(object):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::face class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    basis = property(_ifcopenshell_wrapper.face_basis_get, _ifcopenshell_wrapper.face_basis_set, doc=r"""basis : ifcopenshell::geometry::taxonomy::item::ptr""")

    def clone_(self):
        r"""clone_(face self) -> face"""
        return _ifcopenshell_wrapper.face_clone_(self)

    def kind(self):
        r"""kind(face self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.face_kind(self)

    def print_impl(self, o, indent):
        r"""print_impl(face self, std::ostream & o, int indent)"""
        return _ifcopenshell_wrapper.face_print_impl(self, o, indent)

    def calc_hash(self):
        r"""calc_hash(face self) -> size_t"""
        return _ifcopenshell_wrapper.face_calc_hash(self)

    def children_(self):
        r"""children_(face self) -> std::vector< ifcopenshell::geometry::taxonomy::loop::ptr,std::allocator< ifcopenshell::geometry::taxonomy::loop::ptr > > const &"""
        return _ifcopenshell_wrapper.face_children_(self)

    def __getitem__(self, index):
        r"""__getitem__(face self, int index) -> ifcopenshell::geometry::taxonomy::loop::ptr const &"""
        return _ifcopenshell_wrapper.face___getitem__(self, index)

    children = property(children_)
    def __iter__(self):
    	return iter(self.children)


    def matrix_(self):
        r"""matrix_(face self) -> ifcopenshell::geometry::taxonomy::matrix4::ptr const &"""
        return _ifcopenshell_wrapper.face_matrix_(self)

    matrix = property(matrix_)


    __repr__ = taxonomy_item_repr


    def __init__(self):
        r"""__init__(face self) -> face"""
        _ifcopenshell_wrapper.face_swiginit(self, _ifcopenshell_wrapper.new_face())
    __swig_destroy__ = _ifcopenshell_wrapper.delete_face

# Register face in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.face_swigregister(face)

class shell(object):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::shell class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    closed = property(_ifcopenshell_wrapper.shell_closed_get, _ifcopenshell_wrapper.shell_closed_set, doc=r"""closed : boost::optional<(bool)>""")

    def print_impl(self, o, indent):
        r"""print_impl(shell self, std::ostream & o, int indent)"""
        return _ifcopenshell_wrapper.shell_print_impl(self, o, indent)

    def clone_(self):
        r"""clone_(shell self) -> shell"""
        return _ifcopenshell_wrapper.shell_clone_(self)

    def kind(self):
        r"""kind(shell self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.shell_kind(self)

    def calc_hash(self):
        r"""calc_hash(shell self) -> size_t"""
        return _ifcopenshell_wrapper.shell_calc_hash(self)

    def centroid(self):
        r"""centroid(shell self) -> ifcopenshell::geometry::taxonomy::point3::ptr"""
        return _ifcopenshell_wrapper.shell_centroid(self)

    def children_(self):
        r"""children_(shell self) -> std::vector< ifcopenshell::geometry::taxonomy::face::ptr,std::allocator< ifcopenshell::geometry::taxonomy::face::ptr > > const &"""
        return _ifcopenshell_wrapper.shell_children_(self)

    def __getitem__(self, index):
        r"""__getitem__(shell self, int index) -> ifcopenshell::geometry::taxonomy::face::ptr const &"""
        return _ifcopenshell_wrapper.shell___getitem__(self, index)

    children = property(children_)
    def __iter__(self):
    	return iter(self.children)


    __repr__ = taxonomy_item_repr


    def __init__(self):
        r"""__init__(shell self) -> shell"""
        _ifcopenshell_wrapper.shell_swiginit(self, _ifcopenshell_wrapper.new_shell())
    __swig_destroy__ = _ifcopenshell_wrapper.delete_shell

# Register shell in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.shell_swigregister(shell)

class solid(object):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::solid class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def clone_(self):
        r"""clone_(solid self) -> solid"""
        return _ifcopenshell_wrapper.solid_clone_(self)

    def kind(self):
        r"""kind(solid self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.solid_kind(self)

    def calc_hash(self):
        r"""calc_hash(solid self) -> size_t"""
        return _ifcopenshell_wrapper.solid_calc_hash(self)

    def children_(self):
        r"""children_(solid self) -> std::vector< ifcopenshell::geometry::taxonomy::shell::ptr,std::allocator< ifcopenshell::geometry::taxonomy::shell::ptr > > const &"""
        return _ifcopenshell_wrapper.solid_children_(self)

    def __getitem__(self, index):
        r"""__getitem__(solid self, int index) -> ifcopenshell::geometry::taxonomy::shell::ptr const &"""
        return _ifcopenshell_wrapper.solid___getitem__(self, index)

    children = property(children_)
    def __iter__(self):
    	return iter(self.children)


    def matrix_(self):
        r"""matrix_(solid self) -> ifcopenshell::geometry::taxonomy::matrix4::ptr const &"""
        return _ifcopenshell_wrapper.solid_matrix_(self)

    matrix = property(matrix_)


    __repr__ = taxonomy_item_repr


    def __init__(self):
        r"""__init__(solid self) -> solid"""
        _ifcopenshell_wrapper.solid_swiginit(self, _ifcopenshell_wrapper.new_solid())
    __swig_destroy__ = _ifcopenshell_wrapper.delete_solid

# Register solid in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.solid_swigregister(solid)

class loft(object):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::loft class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    axis = property(_ifcopenshell_wrapper.loft_axis_get, _ifcopenshell_wrapper.loft_axis_set, doc=r"""axis : ifcopenshell::geometry::taxonomy::item::ptr""")

    def clone_(self):
        r"""clone_(loft self) -> loft"""
        return _ifcopenshell_wrapper.loft_clone_(self)

    def kind(self):
        r"""kind(loft self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.loft_kind(self)

    def print_impl(self, o, indent):
        r"""print_impl(loft self, std::ostream & o, int indent)"""
        return _ifcopenshell_wrapper.loft_print_impl(self, o, indent)

    def calc_hash(self):
        r"""calc_hash(loft self) -> size_t"""
        return _ifcopenshell_wrapper.loft_calc_hash(self)

    def children_(self):
        r"""children_(loft self) -> std::vector< ifcopenshell::geometry::taxonomy::geom_item::ptr,std::allocator< ifcopenshell::geometry::taxonomy::geom_item::ptr > > const &"""
        return _ifcopenshell_wrapper.loft_children_(self)

    def __getitem__(self, index):
        r"""__getitem__(loft self, int index) -> ifcopenshell::geometry::taxonomy::geom_item::ptr const &"""
        return _ifcopenshell_wrapper.loft___getitem__(self, index)

    children = property(children_)
    def __iter__(self):
    	return iter(self.children)


    __repr__ = taxonomy_item_repr


    def __init__(self):
        r"""__init__(loft self) -> loft"""
        _ifcopenshell_wrapper.loft_swiginit(self, _ifcopenshell_wrapper.new_loft())
    __swig_destroy__ = _ifcopenshell_wrapper.delete_loft

# Register loft in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.loft_swigregister(loft)

class surface(geom_item):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::surface class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _ifcopenshell_wrapper.delete_surface

# Register surface in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.surface_swigregister(surface)

class plane(surface):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::plane class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def clone_(self):
        r"""clone_(plane self) -> plane"""
        return _ifcopenshell_wrapper.plane_clone_(self)

    def kind(self):
        r"""kind(plane self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.plane_kind(self)

    def calc_hash(self):
        r"""calc_hash(plane self) -> size_t"""
        return _ifcopenshell_wrapper.plane_calc_hash(self)

    def matrix_(self):
        r"""matrix_(plane self) -> ifcopenshell::geometry::taxonomy::matrix4::ptr const &"""
        return _ifcopenshell_wrapper.plane_matrix_(self)

    matrix = property(matrix_)


    __repr__ = taxonomy_item_repr


    def __init__(self):
        r"""__init__(plane self) -> plane"""
        _ifcopenshell_wrapper.plane_swiginit(self, _ifcopenshell_wrapper.new_plane())
    __swig_destroy__ = _ifcopenshell_wrapper.delete_plane

# Register plane in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.plane_swigregister(plane)

class cylinder(surface):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::cylinder class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    radius = property(_ifcopenshell_wrapper.cylinder_radius_get, _ifcopenshell_wrapper.cylinder_radius_set, doc=r"""radius : double""")

    def clone_(self):
        r"""clone_(cylinder self) -> cylinder"""
        return _ifcopenshell_wrapper.cylinder_clone_(self)

    def kind(self):
        r"""kind(cylinder self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.cylinder_kind(self)

    def calc_hash(self):
        r"""calc_hash(cylinder self) -> size_t"""
        return _ifcopenshell_wrapper.cylinder_calc_hash(self)

    def matrix_(self):
        r"""matrix_(cylinder self) -> ifcopenshell::geometry::taxonomy::matrix4::ptr const &"""
        return _ifcopenshell_wrapper.cylinder_matrix_(self)

    matrix = property(matrix_)


    __repr__ = taxonomy_item_repr


    def __init__(self):
        r"""__init__(cylinder self) -> cylinder"""
        _ifcopenshell_wrapper.cylinder_swiginit(self, _ifcopenshell_wrapper.new_cylinder())
    __swig_destroy__ = _ifcopenshell_wrapper.delete_cylinder

# Register cylinder in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.cylinder_swigregister(cylinder)

class sphere(surface):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::sphere class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    radius = property(_ifcopenshell_wrapper.sphere_radius_get, _ifcopenshell_wrapper.sphere_radius_set, doc=r"""radius : double""")

    def clone_(self):
        r"""clone_(sphere self) -> sphere"""
        return _ifcopenshell_wrapper.sphere_clone_(self)

    def kind(self):
        r"""kind(sphere self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.sphere_kind(self)

    def calc_hash(self):
        r"""calc_hash(sphere self) -> size_t"""
        return _ifcopenshell_wrapper.sphere_calc_hash(self)

    def matrix_(self):
        r"""matrix_(sphere self) -> ifcopenshell::geometry::taxonomy::matrix4::ptr const &"""
        return _ifcopenshell_wrapper.sphere_matrix_(self)

    matrix = property(matrix_)


    __repr__ = taxonomy_item_repr


    def __init__(self):
        r"""__init__(sphere self) -> sphere"""
        _ifcopenshell_wrapper.sphere_swiginit(self, _ifcopenshell_wrapper.new_sphere())
    __swig_destroy__ = _ifcopenshell_wrapper.delete_sphere

# Register sphere in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.sphere_swigregister(sphere)

class torus(surface):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::torus class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    radius1 = property(_ifcopenshell_wrapper.torus_radius1_get, _ifcopenshell_wrapper.torus_radius1_set, doc=r"""radius1 : double""")
    radius2 = property(_ifcopenshell_wrapper.torus_radius2_get, _ifcopenshell_wrapper.torus_radius2_set, doc=r"""radius2 : double""")

    def clone_(self):
        r"""clone_(torus self) -> torus"""
        return _ifcopenshell_wrapper.torus_clone_(self)

    def kind(self):
        r"""kind(torus self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.torus_kind(self)

    def calc_hash(self):
        r"""calc_hash(torus self) -> size_t"""
        return _ifcopenshell_wrapper.torus_calc_hash(self)

    def matrix_(self):
        r"""matrix_(torus self) -> ifcopenshell::geometry::taxonomy::matrix4::ptr const &"""
        return _ifcopenshell_wrapper.torus_matrix_(self)

    matrix = property(matrix_)


    __repr__ = taxonomy_item_repr


    def __init__(self):
        r"""__init__(torus self) -> torus"""
        _ifcopenshell_wrapper.torus_swiginit(self, _ifcopenshell_wrapper.new_torus())
    __swig_destroy__ = _ifcopenshell_wrapper.delete_torus

# Register torus in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.torus_swigregister(torus)

class bspline_surface(surface):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::bspline_surface class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def clone_(self):
        r"""clone_(bspline_surface self) -> bspline_surface"""
        return _ifcopenshell_wrapper.bspline_surface_clone_(self)

    def kind(self):
        r"""kind(bspline_surface self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.bspline_surface_kind(self)

    def calc_hash(self):
        r"""calc_hash(bspline_surface self) -> size_t"""
        return _ifcopenshell_wrapper.bspline_surface_calc_hash(self)
    control_points = property(_ifcopenshell_wrapper.bspline_surface_control_points_get, _ifcopenshell_wrapper.bspline_surface_control_points_set, doc=r"""control_points : std::vector<(std::vector<(ifcopenshell::geometry::taxonomy::point3::ptr,std::allocator<(ifcopenshell::geometry::taxonomy::point3::ptr)>)>,std::allocator<(std::vector<(ifcopenshell::geometry::taxonomy::point3::ptr,std::allocator<(ifcopenshell::geometry::taxonomy::point3::ptr)>)>)>)>""")
    multiplicities = property(_ifcopenshell_wrapper.bspline_surface_multiplicities_get, _ifcopenshell_wrapper.bspline_surface_multiplicities_set, doc=r"""multiplicities : std::array<(std::vector<(int,std::allocator<(int)>)>,2)>""")
    knots = property(_ifcopenshell_wrapper.bspline_surface_knots_get, _ifcopenshell_wrapper.bspline_surface_knots_set, doc=r"""knots : std::array<(std::vector<(double,std::allocator<(double)>)>,2)>""")
    weights = property(_ifcopenshell_wrapper.bspline_surface_weights_get, _ifcopenshell_wrapper.bspline_surface_weights_set, doc=r"""weights : boost::optional<(std::vector<(std::vector<(double,std::allocator<(double)>)>,std::allocator<(std::vector<(double,std::allocator<(double)>)>)>)>)>""")
    degree = property(_ifcopenshell_wrapper.bspline_surface_degree_get, _ifcopenshell_wrapper.bspline_surface_degree_set, doc=r"""degree : std::array<(int,2)>""")

    __repr__ = taxonomy_item_repr


    def __init__(self):
        r"""__init__(bspline_surface self) -> bspline_surface"""
        _ifcopenshell_wrapper.bspline_surface_swiginit(self, _ifcopenshell_wrapper.new_bspline_surface())
    __swig_destroy__ = _ifcopenshell_wrapper.delete_bspline_surface

# Register bspline_surface in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.bspline_surface_swigregister(bspline_surface)

class sweep(geom_item):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::sweep class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    basis = property(_ifcopenshell_wrapper.sweep_basis_get, _ifcopenshell_wrapper.sweep_basis_set, doc=r"""basis : ifcopenshell::geometry::taxonomy::item::ptr""")
    __swig_destroy__ = _ifcopenshell_wrapper.delete_sweep

# Register sweep in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.sweep_swigregister(sweep)

class extrusion(sweep):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::extrusion class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    direction = property(_ifcopenshell_wrapper.extrusion_direction_get, _ifcopenshell_wrapper.extrusion_direction_set, doc=r"""direction : ifcopenshell::geometry::taxonomy::direction3::ptr""")
    depth = property(_ifcopenshell_wrapper.extrusion_depth_get, _ifcopenshell_wrapper.extrusion_depth_set, doc=r"""depth : double""")

    def clone_(self):
        r"""clone_(extrusion self) -> extrusion"""
        return _ifcopenshell_wrapper.extrusion_clone_(self)

    def kind(self):
        r"""kind(extrusion self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.extrusion_kind(self)

    def __init__(self, m, basis, dir, d):
        r"""__init__(extrusion self, ifcopenshell::geometry::taxonomy::matrix4::ptr m, ifcopenshell::geometry::taxonomy::item::ptr basis, ifcopenshell::geometry::taxonomy::direction3::ptr dir, double d) -> extrusion"""
        _ifcopenshell_wrapper.extrusion_swiginit(self, _ifcopenshell_wrapper.new_extrusion(m, basis, dir, d))

    def calc_hash(self):
        r"""calc_hash(extrusion self) -> size_t"""
        return _ifcopenshell_wrapper.extrusion_calc_hash(self)

    def matrix_(self):
        r"""matrix_(extrusion self) -> ifcopenshell::geometry::taxonomy::matrix4::ptr const &"""
        return _ifcopenshell_wrapper.extrusion_matrix_(self)

    matrix = property(matrix_)


    __repr__ = taxonomy_item_repr

    __swig_destroy__ = _ifcopenshell_wrapper.delete_extrusion

# Register extrusion in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.extrusion_swigregister(extrusion)

class revolve(sweep):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::revolve class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    axis_origin = property(_ifcopenshell_wrapper.revolve_axis_origin_get, _ifcopenshell_wrapper.revolve_axis_origin_set, doc=r"""axis_origin : ifcopenshell::geometry::taxonomy::point3::ptr""")
    direction = property(_ifcopenshell_wrapper.revolve_direction_get, _ifcopenshell_wrapper.revolve_direction_set, doc=r"""direction : ifcopenshell::geometry::taxonomy::direction3::ptr""")
    angle = property(_ifcopenshell_wrapper.revolve_angle_get, _ifcopenshell_wrapper.revolve_angle_set, doc=r"""angle : boost::optional<(double)>""")

    def clone_(self):
        r"""clone_(revolve self) -> revolve"""
        return _ifcopenshell_wrapper.revolve_clone_(self)

    def kind(self):
        r"""kind(revolve self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.revolve_kind(self)

    def __init__(self, m, basis, pnt, dir, a):
        r"""__init__(revolve self, ifcopenshell::geometry::taxonomy::matrix4::ptr m, ifcopenshell::geometry::taxonomy::item::ptr basis, ifcopenshell::geometry::taxonomy::point3::ptr pnt, ifcopenshell::geometry::taxonomy::direction3::ptr dir, boost::optional< double > const & a) -> revolve"""
        _ifcopenshell_wrapper.revolve_swiginit(self, _ifcopenshell_wrapper.new_revolve(m, basis, pnt, dir, a))

    def calc_hash(self):
        r"""calc_hash(revolve self) -> size_t"""
        return _ifcopenshell_wrapper.revolve_calc_hash(self)

    def matrix_(self):
        r"""matrix_(revolve self) -> ifcopenshell::geometry::taxonomy::matrix4::ptr const &"""
        return _ifcopenshell_wrapper.revolve_matrix_(self)

    matrix = property(matrix_)


    __repr__ = taxonomy_item_repr

    __swig_destroy__ = _ifcopenshell_wrapper.delete_revolve

# Register revolve in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.revolve_swigregister(revolve)

class sweep_along_curve(sweep):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::sweep_along_curve class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    surface = property(_ifcopenshell_wrapper.sweep_along_curve_surface_get, _ifcopenshell_wrapper.sweep_along_curve_surface_set, doc=r"""surface : ifcopenshell::geometry::taxonomy::item::ptr""")
    curve = property(_ifcopenshell_wrapper.sweep_along_curve_curve_get, _ifcopenshell_wrapper.sweep_along_curve_curve_set, doc=r"""curve : ifcopenshell::geometry::taxonomy::item::ptr""")

    def clone_(self):
        r"""clone_(sweep_along_curve self) -> sweep_along_curve"""
        return _ifcopenshell_wrapper.sweep_along_curve_clone_(self)

    def kind(self):
        r"""kind(sweep_along_curve self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.sweep_along_curve_kind(self)

    def __init__(self, m, basis, surf, crv):
        r"""__init__(sweep_along_curve self, ifcopenshell::geometry::taxonomy::matrix4::ptr m, ifcopenshell::geometry::taxonomy::face::ptr basis, ifcopenshell::geometry::taxonomy::item::ptr surf, ifcopenshell::geometry::taxonomy::item::ptr crv) -> sweep_along_curve"""
        _ifcopenshell_wrapper.sweep_along_curve_swiginit(self, _ifcopenshell_wrapper.new_sweep_along_curve(m, basis, surf, crv))

    def calc_hash(self):
        r"""calc_hash(sweep_along_curve self) -> size_t"""
        return _ifcopenshell_wrapper.sweep_along_curve_calc_hash(self)

    __repr__ = taxonomy_item_repr

    __swig_destroy__ = _ifcopenshell_wrapper.delete_sweep_along_curve

# Register sweep_along_curve in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.sweep_along_curve_swigregister(sweep_along_curve)

class node(item):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::node class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def clone_(self):
        r"""clone_(node self) -> node"""
        return _ifcopenshell_wrapper.node_clone_(self)

    def kind(self):
        r"""kind(node self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.node_kind(self)

    def calc_hash(self):
        r"""calc_hash(node self) -> size_t"""
        return _ifcopenshell_wrapper.node_calc_hash(self)

    __repr__ = taxonomy_item_repr


    def __init__(self):
        r"""__init__(node self) -> node"""
        _ifcopenshell_wrapper.node_swiginit(self, _ifcopenshell_wrapper.new_node())
    __swig_destroy__ = _ifcopenshell_wrapper.delete_node

# Register node in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.node_swigregister(node)

class boolean_result(object):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::boolean_result class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    UNION = _ifcopenshell_wrapper.boolean_result_UNION
    
    SUBTRACTION = _ifcopenshell_wrapper.boolean_result_SUBTRACTION
    
    INTERSECTION = _ifcopenshell_wrapper.boolean_result_INTERSECTION
    

    def clone_(self):
        r"""clone_(boolean_result self) -> boolean_result"""
        return _ifcopenshell_wrapper.boolean_result_clone_(self)

    def kind(self):
        r"""kind(boolean_result self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.boolean_result_kind(self)
    operation = property(_ifcopenshell_wrapper.boolean_result_operation_get, _ifcopenshell_wrapper.boolean_result_operation_set, doc=r"""operation : ifcopenshell::geometry::taxonomy::boolean_result::operation_t""")

    @staticmethod
    def operation_str(op):
        r"""operation_str(ifcopenshell::geometry::taxonomy::boolean_result::operation_t op) -> std::string const &"""
        return _ifcopenshell_wrapper.boolean_result_operation_str(op)

    def calc_hash(self):
        r"""calc_hash(boolean_result self) -> size_t"""
        return _ifcopenshell_wrapper.boolean_result_calc_hash(self)

    def children_(self):
        r"""children_(boolean_result self) -> std::vector< ifcopenshell::geometry::taxonomy::geom_item::ptr,std::allocator< ifcopenshell::geometry::taxonomy::geom_item::ptr > > const &"""
        return _ifcopenshell_wrapper.boolean_result_children_(self)

    def __getitem__(self, index):
        r"""__getitem__(boolean_result self, int index) -> ifcopenshell::geometry::taxonomy::geom_item::ptr const &"""
        return _ifcopenshell_wrapper.boolean_result___getitem__(self, index)

    children = property(children_)
    def __iter__(self):
    	return iter(self.children)


    __repr__ = taxonomy_item_repr


    def __init__(self):
        r"""__init__(boolean_result self) -> boolean_result"""
        _ifcopenshell_wrapper.boolean_result_swiginit(self, _ifcopenshell_wrapper.new_boolean_result())
    __swig_destroy__ = _ifcopenshell_wrapper.delete_boolean_result

# Register boolean_result in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.boolean_result_swigregister(boolean_result)

def boolean_result_operation_str(op):
    r"""boolean_result_operation_str(ifcopenshell::geometry::taxonomy::boolean_result::operation_t op) -> std::string const &"""
    return _ifcopenshell_wrapper.boolean_result_operation_str(op)

class type_by_kind(object):
    r"""Proxy of C++ ifcopenshell::geometry::taxonomy::type_by_kind class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    max = _ifcopenshell_wrapper.type_by_kind_max
    

    def __init__(self):
        r"""__init__(type_by_kind self) -> type_by_kind"""
        _ifcopenshell_wrapper.type_by_kind_swiginit(self, _ifcopenshell_wrapper.new_type_by_kind())
    __swig_destroy__ = _ifcopenshell_wrapper.delete_type_by_kind

# Register type_by_kind in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.type_by_kind_swigregister(type_by_kind)


def flatten(deep):
    r"""flatten(ifcopenshell::geometry::taxonomy::collection::ptr const & deep) -> ifcopenshell::geometry::taxonomy::collection::ptr"""
    return _ifcopenshell_wrapper.flatten(deep)

def create_box(*args):
    r"""
    create_box(double dx, double dy, double dz) -> ifcopenshell::geometry::taxonomy::solid::ptr
    create_box(double x, double y, double z, double dx, double dy, double dz) -> ifcopenshell::geometry::taxonomy::solid::ptr
    """
    return _ifcopenshell_wrapper.create_box(*args)
ATPATH = _ifcopenshell_wrapper.ATPATH

ATSTART = _ifcopenshell_wrapper.ATSTART

ATEND = _ifcopenshell_wrapper.ATEND

NOTDEFINED = _ifcopenshell_wrapper.NOTDEFINED


def helmert_curve_point(A0, A1, A2, s):
    r"""helmert_curve_point(double A0, double A1, double A2, double s) -> std::vector< double,std::allocator< double > >"""
    return _ifcopenshell_wrapper.helmert_curve_point(A0, A1, A2, s)

def convert_loop_to_function_item(loop):
    r"""convert_loop_to_function_item(ifcopenshell::geometry::taxonomy::loop::ptr loop) -> ifcopenshell::geometry::taxonomy::function_item::ptr"""
    return _ifcopenshell_wrapper.convert_loop_to_function_item(loop)
class fn_evaluator(object):
    r"""Proxy of C++ ifcopenshell::geometry::fn_evaluator class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _ifcopenshell_wrapper.delete_fn_evaluator

    def clone(self):
        r"""clone(fn_evaluator self) -> fn_evaluator"""
        return _ifcopenshell_wrapper.fn_evaluator_clone(self)

    def evaluate(self, u):
        r"""evaluate(fn_evaluator self, double u) -> Eigen::Matrix4d"""
        return _ifcopenshell_wrapper.fn_evaluator_evaluate(self, u)

    def start(self):
        r"""start(fn_evaluator self) -> double"""
        return _ifcopenshell_wrapper.fn_evaluator_start(self)

    def end(self):
        r"""end(fn_evaluator self) -> double"""
        return _ifcopenshell_wrapper.fn_evaluator_end(self)

    def length(self):
        r"""length(fn_evaluator self) -> double"""
        return _ifcopenshell_wrapper.fn_evaluator_length(self)
    settings_ = property(_ifcopenshell_wrapper.fn_evaluator_settings__get, _ifcopenshell_wrapper.fn_evaluator_settings__set, doc=r"""settings_ : ifcopenshell::geometry::Settings""")

# Register fn_evaluator in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.fn_evaluator_swigregister(fn_evaluator)

class function_item_evaluator(object):
    r"""Proxy of C++ ifcopenshell::geometry::function_item_evaluator class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(function_item_evaluator self, Settings settings, ifcopenshell::geometry::taxonomy::function_item::const_ptr fn) -> function_item_evaluator
        __init__(function_item_evaluator self, function_item_evaluator other) -> function_item_evaluator
        """
        _ifcopenshell_wrapper.function_item_evaluator_swiginit(self, _ifcopenshell_wrapper.new_function_item_evaluator(*args))
    __swig_destroy__ = _ifcopenshell_wrapper.delete_function_item_evaluator

    def evaluation_points(self, *args):
        r"""
        evaluation_points(function_item_evaluator self) -> std::vector< double,std::allocator< double > >
        evaluation_points(function_item_evaluator self, double ustart, double uend, unsigned int nsteps) -> std::vector< double,std::allocator< double > >
        """
        return _ifcopenshell_wrapper.function_item_evaluator_evaluation_points(self, *args)

    def evaluate(self, *args):
        r"""
        evaluate(function_item_evaluator self) -> ifcopenshell::geometry::taxonomy::item::ptr
        evaluate(function_item_evaluator self, double ustart, double uend, unsigned int nsteps) -> ifcopenshell::geometry::taxonomy::item::ptr
        evaluate(function_item_evaluator self, double u) -> Eigen::Matrix4d
        """
        return _ifcopenshell_wrapper.function_item_evaluator_evaluate(self, *args)

# Register function_item_evaluator in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.function_item_evaluator_swigregister(function_item_evaluator)

class horizontal_plan_at_element(object):
    r"""Proxy of C++ horizontal_plan_at_element class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(horizontal_plan_at_element self) -> horizontal_plan_at_element"""
        _ifcopenshell_wrapper.horizontal_plan_at_element_swiginit(self, _ifcopenshell_wrapper.new_horizontal_plan_at_element())
    __swig_destroy__ = _ifcopenshell_wrapper.delete_horizontal_plan_at_element

# Register horizontal_plan_at_element in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.horizontal_plan_at_element_swigregister(horizontal_plan_at_element)

class drawing_meta(object):
    r"""Proxy of C++ drawing_meta class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    pln_3d = property(_ifcopenshell_wrapper.drawing_meta_pln_3d_get, _ifcopenshell_wrapper.drawing_meta_pln_3d_set, doc=r"""pln_3d : gp_Pln""")
    matrix_3 = property(_ifcopenshell_wrapper.drawing_meta_matrix_3_get, _ifcopenshell_wrapper.drawing_meta_matrix_3_set, doc=r"""matrix_3 : std::array<(std::array<(double,3)>,3)>""")

    def __init__(self):
        r"""__init__(drawing_meta self) -> drawing_meta"""
        _ifcopenshell_wrapper.drawing_meta_swiginit(self, _ifcopenshell_wrapper.new_drawing_meta())
    __swig_destroy__ = _ifcopenshell_wrapper.delete_drawing_meta

# Register drawing_meta in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.drawing_meta_swigregister(drawing_meta)

ON_SLABS_AT_FLOORPLANS = _ifcopenshell_wrapper.ON_SLABS_AT_FLOORPLANS

ON_SLABS_AND_WALLS = _ifcopenshell_wrapper.ON_SLABS_AND_WALLS

ALWAYS = _ifcopenshell_wrapper.ALWAYS

class SvgSerializer(WriteOnlyGeometrySerializer):
    r"""Proxy of C++ SvgSerializer class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    SH_NONE = _ifcopenshell_wrapper.SvgSerializer_SH_NONE
    
    SH_FULL = _ifcopenshell_wrapper.SvgSerializer_SH_FULL
    
    SH_LEFT = _ifcopenshell_wrapper.SvgSerializer_SH_LEFT
    

    def __init__(self, out_filename, geometry_settings, settings):
        r"""__init__(SvgSerializer self, buffer out_filename, Settings geometry_settings, SerializerSettings settings) -> SvgSerializer"""
        _ifcopenshell_wrapper.SvgSerializer_swiginit(self, _ifcopenshell_wrapper.new_SvgSerializer(out_filename, geometry_settings, settings))

    def addXCoordinate(self, fi):
        r"""addXCoordinate(SvgSerializer self, boost::shared_ptr< util::string_buffer::float_item > const & fi)"""
        return _ifcopenshell_wrapper.SvgSerializer_addXCoordinate(self, fi)

    def addYCoordinate(self, fi):
        r"""addYCoordinate(SvgSerializer self, boost::shared_ptr< util::string_buffer::float_item > const & fi)"""
        return _ifcopenshell_wrapper.SvgSerializer_addYCoordinate(self, fi)

    def addSizeComponent(self, fi):
        r"""addSizeComponent(SvgSerializer self, boost::shared_ptr< util::string_buffer::float_item > const & fi)"""
        return _ifcopenshell_wrapper.SvgSerializer_addSizeComponent(self, fi)

    def growBoundingBox(self, x, y):
        r"""growBoundingBox(SvgSerializer self, double x, double y)"""
        return _ifcopenshell_wrapper.SvgSerializer_growBoundingBox(self, x, y)

    def writeHeader(self):
        r"""writeHeader(SvgSerializer self)"""
        return _ifcopenshell_wrapper.SvgSerializer_writeHeader(self)

    def doWriteHeader(self):
        r"""doWriteHeader(SvgSerializer self)"""
        return _ifcopenshell_wrapper.SvgSerializer_doWriteHeader(self)

    def ready(self):
        r"""ready(SvgSerializer self) -> bool"""
        return _ifcopenshell_wrapper.SvgSerializer_ready(self)

    def write(self, *args):
        r"""
        write(SvgSerializer self, TriangulationElement arg2)
        write(SvgSerializer self, BRepElement o)
        write(SvgSerializer self, SvgSerializer::path_object & p, TopoDS_Shape const & wire, boost::optional< std::vector< double,std::allocator< double > > > dash_array=boost::none)
        write(SvgSerializer self, geometry_data const & data)
        """
        return _ifcopenshell_wrapper.SvgSerializer_write(self, *args)

    def start_path(self, *args):
        r"""
        start_path(SvgSerializer self, gp_Pln const & p, IfcBaseEntity storey, std::string const & id) -> SvgSerializer::path_object
        start_path(SvgSerializer self, gp_Pln const & p, std::string const & drawing_name, std::string const & id) -> SvgSerializer::path_object &
        """
        return _ifcopenshell_wrapper.SvgSerializer_start_path(self, *args)

    def isTesselated(self):
        r"""isTesselated(SvgSerializer self) -> bool"""
        return _ifcopenshell_wrapper.SvgSerializer_isTesselated(self)

    def finalize(self):
        r"""finalize(SvgSerializer self)"""
        return _ifcopenshell_wrapper.SvgSerializer_finalize(self)

    def setUnitNameAndMagnitude(self, arg2, arg3):
        r"""setUnitNameAndMagnitude(SvgSerializer self, std::string const & arg2, float arg3)"""
        return _ifcopenshell_wrapper.SvgSerializer_setUnitNameAndMagnitude(self, arg2, arg3)

    def setFile(self, f):
        r"""setFile(SvgSerializer self, file f)"""
        return _ifcopenshell_wrapper.SvgSerializer_setFile(self, f)

    def setBoundingRectangle(self, width, height):
        r"""setBoundingRectangle(SvgSerializer self, double width, double height)"""
        return _ifcopenshell_wrapper.SvgSerializer_setBoundingRectangle(self, width, height)

    def setSectionHeight(self, h, storey=None):
        r"""setSectionHeight(SvgSerializer self, double h, IfcBaseEntity storey=None)"""
        return _ifcopenshell_wrapper.SvgSerializer_setSectionHeight(self, h, storey)

    def setSectionHeightsFromStoreys(self, offset=1.2):
        r"""setSectionHeightsFromStoreys(SvgSerializer self, double offset=1.2)"""
        return _ifcopenshell_wrapper.SvgSerializer_setSectionHeightsFromStoreys(self, offset)

    def setPrintSpaceNames(self, b):
        r"""setPrintSpaceNames(SvgSerializer self, bool b)"""
        return _ifcopenshell_wrapper.SvgSerializer_setPrintSpaceNames(self, b)

    def setPrintSpaceAreas(self, b):
        r"""setPrintSpaceAreas(SvgSerializer self, bool b)"""
        return _ifcopenshell_wrapper.SvgSerializer_setPrintSpaceAreas(self, b)

    def setDrawStoreyHeights(self, sh):
        r"""setDrawStoreyHeights(SvgSerializer self, SvgSerializer::storey_height_display_types sh)"""
        return _ifcopenshell_wrapper.SvgSerializer_setDrawStoreyHeights(self, sh)

    def setDrawDoorArcs(self, b):
        r"""setDrawDoorArcs(SvgSerializer self, bool b)"""
        return _ifcopenshell_wrapper.SvgSerializer_setDrawDoorArcs(self, b)

    def setStoreyHeightLineLength(self, d):
        r"""setStoreyHeightLineLength(SvgSerializer self, double d)"""
        return _ifcopenshell_wrapper.SvgSerializer_setStoreyHeightLineLength(self, d)

    def setSpaceNameTransform(self, v):
        r"""setSpaceNameTransform(SvgSerializer self, std::string const & v)"""
        return _ifcopenshell_wrapper.SvgSerializer_setSpaceNameTransform(self, v)

    def addTextAnnotations(self, k):
        r"""addTextAnnotations(SvgSerializer self, drawing_key const & k)"""
        return _ifcopenshell_wrapper.SvgSerializer_addTextAnnotations(self, k)

    def resize(self):
        r"""resize(SvgSerializer self) -> std::array< std::array< double,3 >,3 >"""
        return _ifcopenshell_wrapper.SvgSerializer_resize(self)

    def resetScale(self):
        r"""resetScale(SvgSerializer self)"""
        return _ifcopenshell_wrapper.SvgSerializer_resetScale(self)

    def setSectionRef(self, s):
        r"""setSectionRef(SvgSerializer self, boost::optional< std::string > const & s)"""
        return _ifcopenshell_wrapper.SvgSerializer_setSectionRef(self, s)

    def setElevationRef(self, s):
        r"""setElevationRef(SvgSerializer self, boost::optional< std::string > const & s)"""
        return _ifcopenshell_wrapper.SvgSerializer_setElevationRef(self, s)

    def setElevationRefGuid(self, s):
        r"""setElevationRefGuid(SvgSerializer self, boost::optional< std::string > const & s)"""
        return _ifcopenshell_wrapper.SvgSerializer_setElevationRefGuid(self, s)

    def setAutoSection(self, b):
        r"""setAutoSection(SvgSerializer self, bool b)"""
        return _ifcopenshell_wrapper.SvgSerializer_setAutoSection(self, b)

    def setAutoElevation(self, b):
        r"""setAutoElevation(SvgSerializer self, bool b)"""
        return _ifcopenshell_wrapper.SvgSerializer_setAutoElevation(self, b)

    def setUseNamespace(self, b):
        r"""setUseNamespace(SvgSerializer self, bool b)"""
        return _ifcopenshell_wrapper.SvgSerializer_setUseNamespace(self, b)

    def setUseHlrPoly(self, b):
        r"""setUseHlrPoly(SvgSerializer self, bool b)"""
        return _ifcopenshell_wrapper.SvgSerializer_setUseHlrPoly(self, b)

    def setUsePrefiltering(self, b):
        r"""setUsePrefiltering(SvgSerializer self, bool b)"""
        return _ifcopenshell_wrapper.SvgSerializer_setUsePrefiltering(self, b)

    def getUsePrefiltering(self):
        r"""getUsePrefiltering(SvgSerializer self) -> bool"""
        return _ifcopenshell_wrapper.SvgSerializer_getUsePrefiltering(self)

    def setSegmentProjection(self, b):
        r"""setSegmentProjection(SvgSerializer self, bool b)"""
        return _ifcopenshell_wrapper.SvgSerializer_setSegmentProjection(self, b)

    def getSegmentProjection(self):
        r"""getSegmentProjection(SvgSerializer self) -> bool"""
        return _ifcopenshell_wrapper.SvgSerializer_getSegmentProjection(self)

    def setPolygonal(self, b):
        r"""setPolygonal(SvgSerializer self, bool b)"""
        return _ifcopenshell_wrapper.SvgSerializer_setPolygonal(self, b)

    def setAlwaysProject(self, b):
        r"""setAlwaysProject(SvgSerializer self, bool b)"""
        return _ifcopenshell_wrapper.SvgSerializer_setAlwaysProject(self, b)

    def setWithoutStoreys(self, b):
        r"""setWithoutStoreys(SvgSerializer self, bool b)"""
        return _ifcopenshell_wrapper.SvgSerializer_setWithoutStoreys(self, b)

    def setNoCSS(self, b):
        r"""setNoCSS(SvgSerializer self, bool b)"""
        return _ifcopenshell_wrapper.SvgSerializer_setNoCSS(self, b)

    def setUnifyInputs(self, b):
        r"""setUnifyInputs(SvgSerializer self, bool b)"""
        return _ifcopenshell_wrapper.SvgSerializer_setUnifyInputs(self, b)

    def getUnifyInputs(self):
        r"""getUnifyInputs(SvgSerializer self) -> bool"""
        return _ifcopenshell_wrapper.SvgSerializer_getUnifyInputs(self)

    def setOnlyValid(self, b):
        r"""setOnlyValid(SvgSerializer self, bool b)"""
        return _ifcopenshell_wrapper.SvgSerializer_setOnlyValid(self, b)

    def getOnlyValid(self, b):
        r"""getOnlyValid(SvgSerializer self, bool b) -> bool"""
        return _ifcopenshell_wrapper.SvgSerializer_getOnlyValid(self, b)

    def setScale(self, s):
        r"""setScale(SvgSerializer self, double s)"""
        return _ifcopenshell_wrapper.SvgSerializer_setScale(self, s)

    def setDrawingCenter(self, x, y):
        r"""setDrawingCenter(SvgSerializer self, double x, double y)"""
        return _ifcopenshell_wrapper.SvgSerializer_setDrawingCenter(self, x, y)

    def nameElement(self, *args):
        r"""
        nameElement(SvgSerializer self, IfcBaseEntity storey, Element elem) -> std::string
        nameElement(SvgSerializer self, IfcBaseEntity elem) -> std::string
        """
        return _ifcopenshell_wrapper.SvgSerializer_nameElement(self, *args)

    def idElement(self, elem):
        r"""idElement(SvgSerializer self, IfcBaseEntity elem) -> std::string"""
        return _ifcopenshell_wrapper.SvgSerializer_idElement(self, elem)

    def object_id(self, storey, o):
        r"""object_id(SvgSerializer self, IfcBaseEntity storey, Element o) -> std::string"""
        return _ifcopenshell_wrapper.SvgSerializer_object_id(self, storey, o)

    def addDrawing(self, pos, dir, ref, name, include_projection):
        r"""addDrawing(SvgSerializer self, gp_Pnt const & pos, gp_Dir const & dir, gp_Dir const & ref, std::string const & name, bool include_projection)"""
        return _ifcopenshell_wrapper.SvgSerializer_addDrawing(self, pos, dir, ref, name, include_projection)

    def setSubtractionSettings(self, sbp):
        r"""setSubtractionSettings(SvgSerializer self, subtract_before_project sbp)"""
        return _ifcopenshell_wrapper.SvgSerializer_setSubtractionSettings(self, sbp)

    def getSubtractionSettings(self):
        r"""getSubtractionSettings(SvgSerializer self) -> subtract_before_project"""
        return _ifcopenshell_wrapper.SvgSerializer_getSubtractionSettings(self)

    def setProfileThreshold(self, i):
        r"""setProfileThreshold(SvgSerializer self, int i)"""
        return _ifcopenshell_wrapper.SvgSerializer_setProfileThreshold(self, i)

    def getProfileThreshold(self):
        r"""getProfileThreshold(SvgSerializer self) -> int"""
        return _ifcopenshell_wrapper.SvgSerializer_getProfileThreshold(self)

    def setMirrorY(self, b):
        r"""setMirrorY(SvgSerializer self, bool b)"""
        return _ifcopenshell_wrapper.SvgSerializer_setMirrorY(self, b)

    def getMirrorY(self):
        r"""getMirrorY(SvgSerializer self) -> bool"""
        return _ifcopenshell_wrapper.SvgSerializer_getMirrorY(self)

    def setMirrorX(self, b):
        r"""setMirrorX(SvgSerializer self, bool b)"""
        return _ifcopenshell_wrapper.SvgSerializer_setMirrorX(self, b)

    def getMirrorX(self):
        r"""getMirrorX(SvgSerializer self) -> bool"""
        return _ifcopenshell_wrapper.SvgSerializer_getMirrorX(self)
    __swig_destroy__ = _ifcopenshell_wrapper.delete_SvgSerializer

# Register SvgSerializer in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.SvgSerializer_swigregister(SvgSerializer)

class HdfSerializer(GeometrySerializer):
    r"""Proxy of C++ HdfSerializer class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, hdf_filename, geometry_settings, settings, read_only=False):
        r"""__init__(HdfSerializer self, std::string const & hdf_filename, Settings geometry_settings, SerializerSettings settings, bool read_only=False) -> HdfSerializer"""
        _ifcopenshell_wrapper.HdfSerializer_swiginit(self, _ifcopenshell_wrapper.new_HdfSerializer(hdf_filename, geometry_settings, settings, read_only))
    __swig_destroy__ = _ifcopenshell_wrapper.delete_HdfSerializer

    def ready(self):
        r"""ready(HdfSerializer self) -> bool"""
        return _ifcopenshell_wrapper.HdfSerializer_ready(self)

    def writeHeader(self):
        r"""writeHeader(HdfSerializer self)"""
        return _ifcopenshell_wrapper.HdfSerializer_writeHeader(self)

    def write(self, *args):
        r"""
        write(HdfSerializer self, Element o) -> H5::Group
        write(HdfSerializer self, BRepElement o)
        write(HdfSerializer self, TriangulationElement o)
        """
        return _ifcopenshell_wrapper.HdfSerializer_write(self, *args)

    def remove(self, guid):
        r"""remove(HdfSerializer self, std::string const & guid)"""
        return _ifcopenshell_wrapper.HdfSerializer_remove(self, guid)

    def read(self, *args):
        r"""read(HdfSerializer self, file f, std::string const & guid, std::string const & arg4, GeometrySerializer::read_type rt=READ_BREP) -> Element"""
        return _ifcopenshell_wrapper.HdfSerializer_read(self, *args)

    def finalize(self):
        r"""finalize(HdfSerializer self)"""
        return _ifcopenshell_wrapper.HdfSerializer_finalize(self)

    def isTesselated(self):
        r"""isTesselated(HdfSerializer self) -> bool"""
        return _ifcopenshell_wrapper.HdfSerializer_isTesselated(self)

    def setUnitNameAndMagnitude(self, arg2, arg3):
        r"""setUnitNameAndMagnitude(HdfSerializer self, std::string const & arg2, float arg3)"""
        return _ifcopenshell_wrapper.HdfSerializer_setUnitNameAndMagnitude(self, arg2, arg3)

    def setFile(self, arg2):
        r"""setFile(HdfSerializer self, file arg2)"""
        return _ifcopenshell_wrapper.HdfSerializer_setFile(self, arg2)

# Register HdfSerializer in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.HdfSerializer_swigregister(HdfSerializer)

class WaveFrontOBJSerializer(WriteOnlyGeometrySerializer):
    r"""Proxy of C++ WaveFrontOBJSerializer class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, obj_filename, mtl_filename, geometry_settings, settings):
        r"""__init__(WaveFrontOBJSerializer self, buffer obj_filename, buffer mtl_filename, Settings geometry_settings, SerializerSettings settings) -> WaveFrontOBJSerializer"""
        _ifcopenshell_wrapper.WaveFrontOBJSerializer_swiginit(self, _ifcopenshell_wrapper.new_WaveFrontOBJSerializer(obj_filename, mtl_filename, geometry_settings, settings))
    __swig_destroy__ = _ifcopenshell_wrapper.delete_WaveFrontOBJSerializer

    def ready(self):
        r"""ready(WaveFrontOBJSerializer self) -> bool"""
        return _ifcopenshell_wrapper.WaveFrontOBJSerializer_ready(self)

    def writeHeader(self):
        r"""writeHeader(WaveFrontOBJSerializer self)"""
        return _ifcopenshell_wrapper.WaveFrontOBJSerializer_writeHeader(self)

    def writeMaterial(self, style):
        r"""writeMaterial(WaveFrontOBJSerializer self, ifcopenshell::geometry::taxonomy::style::ptr const style)"""
        return _ifcopenshell_wrapper.WaveFrontOBJSerializer_writeMaterial(self, style)

    def write(self, *args):
        r"""
        write(WaveFrontOBJSerializer self, TriangulationElement o)
        write(WaveFrontOBJSerializer self, BRepElement arg2)
        """
        return _ifcopenshell_wrapper.WaveFrontOBJSerializer_write(self, *args)

    def finalize(self):
        r"""finalize(WaveFrontOBJSerializer self)"""
        return _ifcopenshell_wrapper.WaveFrontOBJSerializer_finalize(self)

    def isTesselated(self):
        r"""isTesselated(WaveFrontOBJSerializer self) -> bool"""
        return _ifcopenshell_wrapper.WaveFrontOBJSerializer_isTesselated(self)

    def setUnitNameAndMagnitude(self, arg2, arg3):
        r"""setUnitNameAndMagnitude(WaveFrontOBJSerializer self, std::string const & arg2, float arg3)"""
        return _ifcopenshell_wrapper.WaveFrontOBJSerializer_setUnitNameAndMagnitude(self, arg2, arg3)

    def setFile(self, arg2):
        r"""setFile(WaveFrontOBJSerializer self, file arg2)"""
        return _ifcopenshell_wrapper.WaveFrontOBJSerializer_setFile(self, arg2)

# Register WaveFrontOBJSerializer in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.WaveFrontOBJSerializer_swigregister(WaveFrontOBJSerializer)

class ColladaSerializer(WriteOnlyGeometrySerializer):
    r"""Proxy of C++ ColladaSerializer class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, dae_filename, geometry_settings, settings):
        r"""__init__(ColladaSerializer self, std::string const & dae_filename, Settings geometry_settings, SerializerSettings settings) -> ColladaSerializer"""
        _ifcopenshell_wrapper.ColladaSerializer_swiginit(self, _ifcopenshell_wrapper.new_ColladaSerializer(dae_filename, geometry_settings, settings))

    def ready(self):
        r"""ready(ColladaSerializer self) -> bool"""
        return _ifcopenshell_wrapper.ColladaSerializer_ready(self)

    def writeHeader(self):
        r"""writeHeader(ColladaSerializer self)"""
        return _ifcopenshell_wrapper.ColladaSerializer_writeHeader(self)

    def write(self, *args):
        r"""
        write(ColladaSerializer self, TriangulationElement o)
        write(ColladaSerializer self, BRepElement arg2)
        """
        return _ifcopenshell_wrapper.ColladaSerializer_write(self, *args)

    def finalize(self):
        r"""finalize(ColladaSerializer self)"""
        return _ifcopenshell_wrapper.ColladaSerializer_finalize(self)

    def isTesselated(self):
        r"""isTesselated(ColladaSerializer self) -> bool"""
        return _ifcopenshell_wrapper.ColladaSerializer_isTesselated(self)

    def setUnitNameAndMagnitude(self, name, magnitude):
        r"""setUnitNameAndMagnitude(ColladaSerializer self, std::string const & name, float magnitude)"""
        return _ifcopenshell_wrapper.ColladaSerializer_setUnitNameAndMagnitude(self, name, magnitude)

    def setFile(self, arg2):
        r"""setFile(ColladaSerializer self, file arg2)"""
        return _ifcopenshell_wrapper.ColladaSerializer_setFile(self, arg2)

    def object_id(self, o):
        r"""object_id(ColladaSerializer self, Element o) -> std::string"""
        return _ifcopenshell_wrapper.ColladaSerializer_object_id(self, o)
    __swig_destroy__ = _ifcopenshell_wrapper.delete_ColladaSerializer

# Register ColladaSerializer in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.ColladaSerializer_swigregister(ColladaSerializer)

class XmlSerializer(object):
    r"""Proxy of C++ XmlSerializer class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, file, xml_filename):
        r"""__init__(XmlSerializer self, file file, std::string const & xml_filename) -> XmlSerializer"""
        _ifcopenshell_wrapper.XmlSerializer_swiginit(self, _ifcopenshell_wrapper.new_XmlSerializer(file, xml_filename))
    __swig_destroy__ = _ifcopenshell_wrapper.delete_XmlSerializer

    def ready(self):
        r"""ready(XmlSerializer self) -> bool"""
        return _ifcopenshell_wrapper.XmlSerializer_ready(self)

    def writeHeader(self):
        r"""writeHeader(XmlSerializer self)"""
        return _ifcopenshell_wrapper.XmlSerializer_writeHeader(self)

    def finalize(self):
        r"""finalize(XmlSerializer self)"""
        return _ifcopenshell_wrapper.XmlSerializer_finalize(self)

    def setFile(self, arg2):
        r"""setFile(XmlSerializer self, file arg2)"""
        return _ifcopenshell_wrapper.XmlSerializer_setFile(self, arg2)

# Register XmlSerializer in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.XmlSerializer_swigregister(XmlSerializer)

class XmlSerializerFactory(object):
    r"""Proxy of C++ XmlSerializerFactory class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def implementations():
        r"""implementations() -> XmlSerializerFactory::Factory &"""
        return _ifcopenshell_wrapper.XmlSerializerFactory_implementations()

    def __init__(self):
        r"""__init__(XmlSerializerFactory self) -> XmlSerializerFactory"""
        _ifcopenshell_wrapper.XmlSerializerFactory_swiginit(self, _ifcopenshell_wrapper.new_XmlSerializerFactory())
    __swig_destroy__ = _ifcopenshell_wrapper.delete_XmlSerializerFactory

# Register XmlSerializerFactory in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.XmlSerializerFactory_swigregister(XmlSerializerFactory)

def XmlSerializerFactory_implementations():
    r"""XmlSerializerFactory_implementations() -> XmlSerializerFactory::Factory &"""
    return _ifcopenshell_wrapper.XmlSerializerFactory_implementations()

class GltfSerializer(WriteOnlyGeometrySerializer):
    r"""Proxy of C++ GltfSerializer class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, filename, geometry_settings, settings):
        r"""__init__(GltfSerializer self, std::string const & filename, Settings geometry_settings, SerializerSettings settings) -> GltfSerializer"""
        _ifcopenshell_wrapper.GltfSerializer_swiginit(self, _ifcopenshell_wrapper.new_GltfSerializer(filename, geometry_settings, settings))
    __swig_destroy__ = _ifcopenshell_wrapper.delete_GltfSerializer

    def ready(self):
        r"""ready(GltfSerializer self) -> bool"""
        return _ifcopenshell_wrapper.GltfSerializer_ready(self)

    def writeHeader(self):
        r"""writeHeader(GltfSerializer self)"""
        return _ifcopenshell_wrapper.GltfSerializer_writeHeader(self)

    def write(self, *args):
        r"""
        write(GltfSerializer self, TriangulationElement o)
        write(GltfSerializer self, BRepElement arg2)
        """
        return _ifcopenshell_wrapper.GltfSerializer_write(self, *args)

    def finalize(self):
        r"""finalize(GltfSerializer self)"""
        return _ifcopenshell_wrapper.GltfSerializer_finalize(self)

    def isTesselated(self):
        r"""isTesselated(GltfSerializer self) -> bool"""
        return _ifcopenshell_wrapper.GltfSerializer_isTesselated(self)

    def setUnitNameAndMagnitude(self, arg2, arg3):
        r"""setUnitNameAndMagnitude(GltfSerializer self, std::string const & arg2, float arg3)"""
        return _ifcopenshell_wrapper.GltfSerializer_setUnitNameAndMagnitude(self, arg2, arg3)

    def setFile(self, arg2):
        r"""setFile(GltfSerializer self, file arg2)"""
        return _ifcopenshell_wrapper.GltfSerializer_setFile(self, arg2)

# Register GltfSerializer in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.GltfSerializer_swigregister(GltfSerializer)

class TtlWktSerializer(WriteOnlyGeometrySerializer):
    r"""Proxy of C++ TtlWktSerializer class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, filename, geometry_settings, settings):
        r"""__init__(TtlWktSerializer self, buffer filename, Settings geometry_settings, SerializerSettings settings) -> TtlWktSerializer"""
        _ifcopenshell_wrapper.TtlWktSerializer_swiginit(self, _ifcopenshell_wrapper.new_TtlWktSerializer(filename, geometry_settings, settings))
    __swig_destroy__ = _ifcopenshell_wrapper.delete_TtlWktSerializer

    def ready(self):
        r"""ready(TtlWktSerializer self) -> bool"""
        return _ifcopenshell_wrapper.TtlWktSerializer_ready(self)

    def writeHeader(self):
        r"""writeHeader(TtlWktSerializer self)"""
        return _ifcopenshell_wrapper.TtlWktSerializer_writeHeader(self)

    def write(self, *args):
        r"""
        write(TtlWktSerializer self, TriangulationElement o)
        write(TtlWktSerializer self, BRepElement arg2)
        """
        return _ifcopenshell_wrapper.TtlWktSerializer_write(self, *args)

    def finalize(self):
        r"""finalize(TtlWktSerializer self)"""
        return _ifcopenshell_wrapper.TtlWktSerializer_finalize(self)

    def isTesselated(self):
        r"""isTesselated(TtlWktSerializer self) -> bool"""
        return _ifcopenshell_wrapper.TtlWktSerializer_isTesselated(self)

    def setUnitNameAndMagnitude(self, arg2, arg3):
        r"""setUnitNameAndMagnitude(TtlWktSerializer self, std::string const & arg2, float arg3)"""
        return _ifcopenshell_wrapper.TtlWktSerializer_setUnitNameAndMagnitude(self, arg2, arg3)

    def setFile(self, arg2):
        r"""setFile(TtlWktSerializer self, file arg2)"""
        return _ifcopenshell_wrapper.TtlWktSerializer_setFile(self, arg2)

    def ttl_object_id(self, o, postfix=None):
        r"""ttl_object_id(TtlWktSerializer self, Element o, char const *const postfix=None) -> std::string"""
        return _ifcopenshell_wrapper.TtlWktSerializer_ttl_object_id(self, o, postfix)

# Register TtlWktSerializer in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.TtlWktSerializer_swigregister(TtlWktSerializer)

class ray_intersection_results(object):
    r"""Proxy of C++ std::vector< IfcGeom::ray_intersection_result > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        r"""iterator(ray_intersection_results self) -> SwigPyIterator"""
        return _ifcopenshell_wrapper.ray_intersection_results_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(ray_intersection_results self) -> bool"""
        return _ifcopenshell_wrapper.ray_intersection_results___nonzero__(self)

    def __bool__(self):
        r"""__bool__(ray_intersection_results self) -> bool"""
        return _ifcopenshell_wrapper.ray_intersection_results___bool__(self)

    def __len__(self):
        r"""__len__(ray_intersection_results self) -> std::vector< IfcGeom::ray_intersection_result >::size_type"""
        return _ifcopenshell_wrapper.ray_intersection_results___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::difference_type i, std::vector< IfcGeom::ray_intersection_result >::difference_type j) -> ray_intersection_results"""
        return _ifcopenshell_wrapper.ray_intersection_results___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::difference_type i, std::vector< IfcGeom::ray_intersection_result >::difference_type j)
        __setslice__(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::difference_type i, std::vector< IfcGeom::ray_intersection_result >::difference_type j, ray_intersection_results v)
        """
        return _ifcopenshell_wrapper.ray_intersection_results___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::difference_type i, std::vector< IfcGeom::ray_intersection_result >::difference_type j)"""
        return _ifcopenshell_wrapper.ray_intersection_results___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::difference_type i)
        __delitem__(ray_intersection_results self, PySliceObject * slice)
        """
        return _ifcopenshell_wrapper.ray_intersection_results___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(ray_intersection_results self, PySliceObject * slice) -> ray_intersection_results
        __getitem__(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::difference_type i) -> ray_intersection_result
        """
        return _ifcopenshell_wrapper.ray_intersection_results___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(ray_intersection_results self, PySliceObject * slice, ray_intersection_results v)
        __setitem__(ray_intersection_results self, PySliceObject * slice)
        __setitem__(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::difference_type i, ray_intersection_result x)
        """
        return _ifcopenshell_wrapper.ray_intersection_results___setitem__(self, *args)

    def pop(self):
        r"""pop(ray_intersection_results self) -> ray_intersection_result"""
        return _ifcopenshell_wrapper.ray_intersection_results_pop(self)

    def append(self, x):
        r"""append(ray_intersection_results self, ray_intersection_result x)"""
        return _ifcopenshell_wrapper.ray_intersection_results_append(self, x)

    def empty(self):
        r"""empty(ray_intersection_results self) -> bool"""
        return _ifcopenshell_wrapper.ray_intersection_results_empty(self)

    def size(self):
        r"""size(ray_intersection_results self) -> std::vector< IfcGeom::ray_intersection_result >::size_type"""
        return _ifcopenshell_wrapper.ray_intersection_results_size(self)

    def swap(self, v):
        r"""swap(ray_intersection_results self, ray_intersection_results v)"""
        return _ifcopenshell_wrapper.ray_intersection_results_swap(self, v)

    def begin(self):
        r"""begin(ray_intersection_results self) -> std::vector< IfcGeom::ray_intersection_result >::iterator"""
        return _ifcopenshell_wrapper.ray_intersection_results_begin(self)

    def end(self):
        r"""end(ray_intersection_results self) -> std::vector< IfcGeom::ray_intersection_result >::iterator"""
        return _ifcopenshell_wrapper.ray_intersection_results_end(self)

    def rbegin(self):
        r"""rbegin(ray_intersection_results self) -> std::vector< IfcGeom::ray_intersection_result >::reverse_iterator"""
        return _ifcopenshell_wrapper.ray_intersection_results_rbegin(self)

    def rend(self):
        r"""rend(ray_intersection_results self) -> std::vector< IfcGeom::ray_intersection_result >::reverse_iterator"""
        return _ifcopenshell_wrapper.ray_intersection_results_rend(self)

    def clear(self):
        r"""clear(ray_intersection_results self)"""
        return _ifcopenshell_wrapper.ray_intersection_results_clear(self)

    def get_allocator(self):
        r"""get_allocator(ray_intersection_results self) -> std::vector< IfcGeom::ray_intersection_result >::allocator_type"""
        return _ifcopenshell_wrapper.ray_intersection_results_get_allocator(self)

    def pop_back(self):
        r"""pop_back(ray_intersection_results self)"""
        return _ifcopenshell_wrapper.ray_intersection_results_pop_back(self)

    def erase(self, *args):
        r"""
        erase(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::iterator pos) -> std::vector< IfcGeom::ray_intersection_result >::iterator
        erase(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::iterator first, std::vector< IfcGeom::ray_intersection_result >::iterator last) -> std::vector< IfcGeom::ray_intersection_result >::iterator
        """
        return _ifcopenshell_wrapper.ray_intersection_results_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(ray_intersection_results self) -> ray_intersection_results
        __init__(ray_intersection_results self, ray_intersection_results other) -> ray_intersection_results
        __init__(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::size_type size) -> ray_intersection_results
        __init__(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::size_type size, ray_intersection_result value) -> ray_intersection_results
        """
        _ifcopenshell_wrapper.ray_intersection_results_swiginit(self, _ifcopenshell_wrapper.new_ray_intersection_results(*args))

    def push_back(self, x):
        r"""push_back(ray_intersection_results self, ray_intersection_result x)"""
        return _ifcopenshell_wrapper.ray_intersection_results_push_back(self, x)

    def front(self):
        r"""front(ray_intersection_results self) -> ray_intersection_result"""
        return _ifcopenshell_wrapper.ray_intersection_results_front(self)

    def back(self):
        r"""back(ray_intersection_results self) -> ray_intersection_result"""
        return _ifcopenshell_wrapper.ray_intersection_results_back(self)

    def assign(self, n, x):
        r"""assign(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::size_type n, ray_intersection_result x)"""
        return _ifcopenshell_wrapper.ray_intersection_results_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::size_type new_size)
        resize(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::size_type new_size, ray_intersection_result x)
        """
        return _ifcopenshell_wrapper.ray_intersection_results_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::iterator pos, ray_intersection_result x) -> std::vector< IfcGeom::ray_intersection_result >::iterator
        insert(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::iterator pos, std::vector< IfcGeom::ray_intersection_result >::size_type n, ray_intersection_result x)
        """
        return _ifcopenshell_wrapper.ray_intersection_results_insert(self, *args)

    def reserve(self, n):
        r"""reserve(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::size_type n)"""
        return _ifcopenshell_wrapper.ray_intersection_results_reserve(self, n)

    def capacity(self):
        r"""capacity(ray_intersection_results self) -> std::vector< IfcGeom::ray_intersection_result >::size_type"""
        return _ifcopenshell_wrapper.ray_intersection_results_capacity(self)
    __swig_destroy__ = _ifcopenshell_wrapper.delete_ray_intersection_results

# Register ray_intersection_results in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.ray_intersection_results_swigregister(ray_intersection_results)

class clashes(object):
    r"""Proxy of C++ std::vector< IfcGeom::clash > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        r"""iterator(clashes self) -> SwigPyIterator"""
        return _ifcopenshell_wrapper.clashes_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(clashes self) -> bool"""
        return _ifcopenshell_wrapper.clashes___nonzero__(self)

    def __bool__(self):
        r"""__bool__(clashes self) -> bool"""
        return _ifcopenshell_wrapper.clashes___bool__(self)

    def __len__(self):
        r"""__len__(clashes self) -> std::vector< IfcGeom::clash >::size_type"""
        return _ifcopenshell_wrapper.clashes___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(clashes self, std::vector< IfcGeom::clash >::difference_type i, std::vector< IfcGeom::clash >::difference_type j) -> clashes"""
        return _ifcopenshell_wrapper.clashes___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(clashes self, std::vector< IfcGeom::clash >::difference_type i, std::vector< IfcGeom::clash >::difference_type j)
        __setslice__(clashes self, std::vector< IfcGeom::clash >::difference_type i, std::vector< IfcGeom::clash >::difference_type j, clashes v)
        """
        return _ifcopenshell_wrapper.clashes___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(clashes self, std::vector< IfcGeom::clash >::difference_type i, std::vector< IfcGeom::clash >::difference_type j)"""
        return _ifcopenshell_wrapper.clashes___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(clashes self, std::vector< IfcGeom::clash >::difference_type i)
        __delitem__(clashes self, PySliceObject * slice)
        """
        return _ifcopenshell_wrapper.clashes___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(clashes self, PySliceObject * slice) -> clashes
        __getitem__(clashes self, std::vector< IfcGeom::clash >::difference_type i) -> clash
        """
        return _ifcopenshell_wrapper.clashes___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(clashes self, PySliceObject * slice, clashes v)
        __setitem__(clashes self, PySliceObject * slice)
        __setitem__(clashes self, std::vector< IfcGeom::clash >::difference_type i, clash x)
        """
        return _ifcopenshell_wrapper.clashes___setitem__(self, *args)

    def pop(self):
        r"""pop(clashes self) -> clash"""
        return _ifcopenshell_wrapper.clashes_pop(self)

    def append(self, x):
        r"""append(clashes self, clash x)"""
        return _ifcopenshell_wrapper.clashes_append(self, x)

    def empty(self):
        r"""empty(clashes self) -> bool"""
        return _ifcopenshell_wrapper.clashes_empty(self)

    def size(self):
        r"""size(clashes self) -> std::vector< IfcGeom::clash >::size_type"""
        return _ifcopenshell_wrapper.clashes_size(self)

    def swap(self, v):
        r"""swap(clashes self, clashes v)"""
        return _ifcopenshell_wrapper.clashes_swap(self, v)

    def begin(self):
        r"""begin(clashes self) -> std::vector< IfcGeom::clash >::iterator"""
        return _ifcopenshell_wrapper.clashes_begin(self)

    def end(self):
        r"""end(clashes self) -> std::vector< IfcGeom::clash >::iterator"""
        return _ifcopenshell_wrapper.clashes_end(self)

    def rbegin(self):
        r"""rbegin(clashes self) -> std::vector< IfcGeom::clash >::reverse_iterator"""
        return _ifcopenshell_wrapper.clashes_rbegin(self)

    def rend(self):
        r"""rend(clashes self) -> std::vector< IfcGeom::clash >::reverse_iterator"""
        return _ifcopenshell_wrapper.clashes_rend(self)

    def clear(self):
        r"""clear(clashes self)"""
        return _ifcopenshell_wrapper.clashes_clear(self)

    def get_allocator(self):
        r"""get_allocator(clashes self) -> std::vector< IfcGeom::clash >::allocator_type"""
        return _ifcopenshell_wrapper.clashes_get_allocator(self)

    def pop_back(self):
        r"""pop_back(clashes self)"""
        return _ifcopenshell_wrapper.clashes_pop_back(self)

    def erase(self, *args):
        r"""
        erase(clashes self, std::vector< IfcGeom::clash >::iterator pos) -> std::vector< IfcGeom::clash >::iterator
        erase(clashes self, std::vector< IfcGeom::clash >::iterator first, std::vector< IfcGeom::clash >::iterator last) -> std::vector< IfcGeom::clash >::iterator
        """
        return _ifcopenshell_wrapper.clashes_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(clashes self) -> clashes
        __init__(clashes self, clashes other) -> clashes
        __init__(clashes self, std::vector< IfcGeom::clash >::size_type size) -> clashes
        __init__(clashes self, std::vector< IfcGeom::clash >::size_type size, clash value) -> clashes
        """
        _ifcopenshell_wrapper.clashes_swiginit(self, _ifcopenshell_wrapper.new_clashes(*args))

    def push_back(self, x):
        r"""push_back(clashes self, clash x)"""
        return _ifcopenshell_wrapper.clashes_push_back(self, x)

    def front(self):
        r"""front(clashes self) -> clash"""
        return _ifcopenshell_wrapper.clashes_front(self)

    def back(self):
        r"""back(clashes self) -> clash"""
        return _ifcopenshell_wrapper.clashes_back(self)

    def assign(self, n, x):
        r"""assign(clashes self, std::vector< IfcGeom::clash >::size_type n, clash x)"""
        return _ifcopenshell_wrapper.clashes_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(clashes self, std::vector< IfcGeom::clash >::size_type new_size)
        resize(clashes self, std::vector< IfcGeom::clash >::size_type new_size, clash x)
        """
        return _ifcopenshell_wrapper.clashes_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(clashes self, std::vector< IfcGeom::clash >::iterator pos, clash x) -> std::vector< IfcGeom::clash >::iterator
        insert(clashes self, std::vector< IfcGeom::clash >::iterator pos, std::vector< IfcGeom::clash >::size_type n, clash x)
        """
        return _ifcopenshell_wrapper.clashes_insert(self, *args)

    def reserve(self, n):
        r"""reserve(clashes self, std::vector< IfcGeom::clash >::size_type n)"""
        return _ifcopenshell_wrapper.clashes_reserve(self, n)

    def capacity(self):
        r"""capacity(clashes self) -> std::vector< IfcGeom::clash >::size_type"""
        return _ifcopenshell_wrapper.clashes_capacity(self)
    __swig_destroy__ = _ifcopenshell_wrapper.delete_clashes

# Register clashes in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.clashes_swigregister(clashes)

class ray_intersection_result(object):
    r"""Proxy of C++ IfcGeom::ray_intersection_result class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    distance = property(_ifcopenshell_wrapper.ray_intersection_result_distance_get, _ifcopenshell_wrapper.ray_intersection_result_distance_set, doc=r"""distance : double""")
    style_index = property(_ifcopenshell_wrapper.ray_intersection_result_style_index_get, _ifcopenshell_wrapper.ray_intersection_result_style_index_set, doc=r"""style_index : int""")
    instance = property(_ifcopenshell_wrapper.ray_intersection_result_instance_get, _ifcopenshell_wrapper.ray_intersection_result_instance_set, doc=r"""instance : p.q(const).IfcUtil::IfcBaseEntity""")
    position = property(_ifcopenshell_wrapper.ray_intersection_result_position_get, _ifcopenshell_wrapper.ray_intersection_result_position_set, doc=r"""position : std::array<(double,3)>""")
    normal = property(_ifcopenshell_wrapper.ray_intersection_result_normal_get, _ifcopenshell_wrapper.ray_intersection_result_normal_set, doc=r"""normal : std::array<(double,3)>""")
    ray_distance = property(_ifcopenshell_wrapper.ray_intersection_result_ray_distance_get, _ifcopenshell_wrapper.ray_intersection_result_ray_distance_set, doc=r"""ray_distance : double""")
    dot_product = property(_ifcopenshell_wrapper.ray_intersection_result_dot_product_get, _ifcopenshell_wrapper.ray_intersection_result_dot_product_set, doc=r"""dot_product : double""")

    def __init__(self):
        r"""__init__(ray_intersection_result self) -> ray_intersection_result"""
        _ifcopenshell_wrapper.ray_intersection_result_swiginit(self, _ifcopenshell_wrapper.new_ray_intersection_result())
    __swig_destroy__ = _ifcopenshell_wrapper.delete_ray_intersection_result

# Register ray_intersection_result in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.ray_intersection_result_swigregister(ray_intersection_result)

class clash(object):
    r"""Proxy of C++ IfcGeom::clash class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    clash_type = property(_ifcopenshell_wrapper.clash_clash_type_get, _ifcopenshell_wrapper.clash_clash_type_set, doc=r"""clash_type : int""")
    a = property(_ifcopenshell_wrapper.clash_a_get, _ifcopenshell_wrapper.clash_a_set, doc=r"""a : p.q(const).IfcUtil::IfcBaseClass""")
    b = property(_ifcopenshell_wrapper.clash_b_get, _ifcopenshell_wrapper.clash_b_set, doc=r"""b : p.q(const).IfcUtil::IfcBaseClass""")
    distance = property(_ifcopenshell_wrapper.clash_distance_get, _ifcopenshell_wrapper.clash_distance_set, doc=r"""distance : double""")
    p1 = property(_ifcopenshell_wrapper.clash_p1_get, _ifcopenshell_wrapper.clash_p1_set, doc=r"""p1 : std::array<(double,3)>""")
    p2 = property(_ifcopenshell_wrapper.clash_p2_get, _ifcopenshell_wrapper.clash_p2_set, doc=r"""p2 : std::array<(double,3)>""")

    def __init__(self):
        r"""__init__(clash self) -> clash"""
        _ifcopenshell_wrapper.clash_swiginit(self, _ifcopenshell_wrapper.new_clash())
    __swig_destroy__ = _ifcopenshell_wrapper.delete_clash

# Register clash in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.clash_swigregister(clash)

class tree(object):
    r"""Proxy of C++ IfcGeom::tree class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(tree self) -> tree
        __init__(tree self, file f) -> tree
        __init__(tree self, file f, Settings settings) -> tree
        __init__(tree self, Iterator it) -> tree
        """
        _ifcopenshell_wrapper.tree_swiginit(self, _ifcopenshell_wrapper.new_tree(*args))

    def add_file(self, *args):
        r"""
        add_file(tree self, file f, Settings settings)
        add_file(tree self, Iterator it)
        """
        return _ifcopenshell_wrapper.tree_add_file(self, *args)

    def write_h5(self):
        r"""write_h5(tree self)"""
        return _ifcopenshell_wrapper.tree_write_h5(self)

    def uint8_to_b64(self, uuids_array):
        r"""uint8_to_b64(tree self, std::vector< uint8_t,std::allocator< uint8_t > > const & uuids_array) -> std::string"""
        return _ifcopenshell_wrapper.tree_uint8_to_b64(self, uuids_array)

    @staticmethod
    def is_manifold(fs):
        r"""is_manifold(std::vector< int,std::allocator< int > > const & fs) -> bool"""
        return _ifcopenshell_wrapper.tree_is_manifold(fs)

    def add_element(self, *args):
        r"""
        add_element(tree self, TriangulationElement elem)
        add_element(tree self, BRepElement elem)
        """
        return _ifcopenshell_wrapper.tree_add_element(self, *args)

    def distances(self):
        r"""distances(tree self) -> std::vector< double,std::allocator< double > > const &"""
        return _ifcopenshell_wrapper.tree_distances(self)

    def protrusion_distances(self):
        r"""protrusion_distances(tree self) -> std::vector< double,std::allocator< double > > const &"""
        return _ifcopenshell_wrapper.tree_protrusion_distances(self)

    def select_ray(self, p0, d, length=1000.):
        r"""select_ray(tree self, gp_Pnt const & p0, gp_Dir const & d, double length=1000.) -> ray_intersection_results"""
        return _ifcopenshell_wrapper.tree_select_ray(self, p0, d, length)

    def enable_face_styles(self, *args):
        r"""
        enable_face_styles(tree self) -> bool
        enable_face_styles(tree self, bool b)
        """
        return _ifcopenshell_wrapper.tree_enable_face_styles(self, *args)

    def styles(self):
        r"""styles(tree self) -> std::vector< ifcopenshell::geometry::taxonomy::style::ptr,std::allocator< ifcopenshell::geometry::taxonomy::style::ptr > > const &"""
        return _ifcopenshell_wrapper.tree_styles(self)

    @staticmethod
    def vector_to_list(ps):
        r"""vector_to_list(std::vector< IfcUtil::IfcBaseEntity const *,std::allocator< IfcUtil::IfcBaseEntity const * > > const & ps) -> aggregate_of_instance::ptr"""
        return _ifcopenshell_wrapper.tree_vector_to_list(ps)

    def select_box(self, *args):
        r"""
        select_box(tree self, entity_instance e, bool completely_within=False, double extend=-1.e-5) -> aggregate_of_instance::ptr
        select_box(tree self, gp_Pnt const & p) -> aggregate_of_instance::ptr
        select_box(tree self, Bnd_Box const & b, bool completely_within=False) -> aggregate_of_instance::ptr
        """
        return _ifcopenshell_wrapper.tree_select_box(self, *args)

    def select(self, *args):
        r"""
        select(tree self, entity_instance e, bool completely_within=False, double extend=0.0) -> aggregate_of_instance::ptr
        select(tree self, gp_Pnt const & p, double extend=0.0) -> aggregate_of_instance::ptr
        select(tree self, std::string const & shape_serialization, bool completely_within=False, double extend=-1.e-5) -> aggregate_of_instance::ptr
        select(tree self, BRepElement elem, bool completely_within=False, double extend=-1.e-5) -> aggregate_of_instance::ptr
        """
        return _ifcopenshell_wrapper.tree_select(self, *args)

    def clash_intersection_many(self, set_a, set_b, tolerance, check_all):
        r"""clash_intersection_many(tree self, std::vector< IfcUtil::IfcBaseClass *,std::allocator< IfcUtil::IfcBaseClass * > > const & set_a, std::vector< IfcUtil::IfcBaseClass *,std::allocator< IfcUtil::IfcBaseClass * > > const & set_b, double tolerance, bool check_all) -> clashes"""
        return _ifcopenshell_wrapper.tree_clash_intersection_many(self, set_a, set_b, tolerance, check_all)

    def clash_collision_many(self, set_a, set_b, allow_touching):
        r"""clash_collision_many(tree self, std::vector< IfcUtil::IfcBaseClass *,std::allocator< IfcUtil::IfcBaseClass * > > const & set_a, std::vector< IfcUtil::IfcBaseClass *,std::allocator< IfcUtil::IfcBaseClass * > > const & set_b, bool allow_touching) -> clashes"""
        return _ifcopenshell_wrapper.tree_clash_collision_many(self, set_a, set_b, allow_touching)

    def clash_clearance_many(self, set_a, set_b, clearance, check_all):
        r"""clash_clearance_many(tree self, std::vector< IfcUtil::IfcBaseClass *,std::allocator< IfcUtil::IfcBaseClass * > > const & set_a, std::vector< IfcUtil::IfcBaseClass *,std::allocator< IfcUtil::IfcBaseClass * > > const & set_b, double clearance, bool check_all) -> clashes"""
        return _ifcopenshell_wrapper.tree_clash_clearance_many(self, set_a, set_b, clearance, check_all)
    __swig_destroy__ = _ifcopenshell_wrapper.delete_tree

# Register tree in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.tree_swigregister(tree)

def tree_is_manifold(fs):
    r"""tree_is_manifold(std::vector< int,std::allocator< int > > const & fs) -> bool"""
    return _ifcopenshell_wrapper.tree_is_manifold(fs)

def tree_vector_to_list(ps):
    r"""tree_vector_to_list(std::vector< IfcUtil::IfcBaseEntity const *,std::allocator< IfcUtil::IfcBaseEntity const * > > const & ps) -> aggregate_of_instance::ptr"""
    return _ifcopenshell_wrapper.tree_vector_to_list(ps)


def construct_iterator_with_include_exclude(geometry_library, settings, file, elems, include, num_threads):
    r"""construct_iterator_with_include_exclude(std::string const & geometry_library, Settings settings, file file, std::vector< std::string,std::allocator< std::string > > elems, bool include, int num_threads) -> Iterator"""
    return _ifcopenshell_wrapper.construct_iterator_with_include_exclude(geometry_library, settings, file, elems, include, num_threads)

def construct_iterator_with_include_exclude_globalid(geometry_library, settings, file, elems, include, num_threads):
    r"""construct_iterator_with_include_exclude_globalid(std::string const & geometry_library, Settings settings, file file, std::vector< std::string,std::allocator< std::string > > elems, bool include, int num_threads) -> Iterator"""
    return _ifcopenshell_wrapper.construct_iterator_with_include_exclude_globalid(geometry_library, settings, file, elems, include, num_threads)

def construct_iterator_with_include_exclude_id(geometry_library, settings, file, elems, include, num_threads):
    r"""construct_iterator_with_include_exclude_id(std::string const & geometry_library, Settings settings, file file, std::vector< int,std::allocator< int > > elems, bool include, int num_threads) -> Iterator"""
    return _ifcopenshell_wrapper.construct_iterator_with_include_exclude_id(geometry_library, settings, file, elems, include, num_threads)

def map_shape(settings, instance):
    r"""map_shape(Settings settings, entity_instance instance) -> ifcopenshell::geometry::taxonomy::item::ptr"""
    return _ifcopenshell_wrapper.map_shape(settings, instance)

def create_shape(*args):
    r"""create_shape(Settings settings, entity_instance instance, entity_instance representation=None, char const *const geometry_library="opencascade") -> boost::variant< IfcGeom::Element *,IfcGeom::Representation::Representation *,IfcGeom::Transformation * >"""
    return _ifcopenshell_wrapper.create_shape(*args)

def serialise(schema_name, shape_str, advanced=True):
    r"""serialise(std::string const & schema_name, std::string const & shape_str, bool advanced=True) -> entity_instance"""
    return _ifcopenshell_wrapper.serialise(schema_name, shape_str, advanced)

def tesselate(schema_name, shape_str, d):
    r"""tesselate(std::string const & schema_name, std::string const & shape_str, double d) -> entity_instance"""
    return _ifcopenshell_wrapper.tesselate(schema_name, shape_str, d)
class svg_line_segments(object):
    r"""Proxy of C++ std::vector< std::array< svgfill::point_2,2 > > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        r"""iterator(svg_line_segments self) -> SwigPyIterator"""
        return _ifcopenshell_wrapper.svg_line_segments_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(svg_line_segments self) -> bool"""
        return _ifcopenshell_wrapper.svg_line_segments___nonzero__(self)

    def __bool__(self):
        r"""__bool__(svg_line_segments self) -> bool"""
        return _ifcopenshell_wrapper.svg_line_segments___bool__(self)

    def __len__(self):
        r"""__len__(svg_line_segments self) -> std::vector< std::array< svgfill::point_2,2 > >::size_type"""
        return _ifcopenshell_wrapper.svg_line_segments___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::difference_type i, std::vector< std::array< svgfill::point_2,2 > >::difference_type j) -> svg_line_segments"""
        return _ifcopenshell_wrapper.svg_line_segments___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::difference_type i, std::vector< std::array< svgfill::point_2,2 > >::difference_type j)
        __setslice__(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::difference_type i, std::vector< std::array< svgfill::point_2,2 > >::difference_type j, svg_line_segments v)
        """
        return _ifcopenshell_wrapper.svg_line_segments___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::difference_type i, std::vector< std::array< svgfill::point_2,2 > >::difference_type j)"""
        return _ifcopenshell_wrapper.svg_line_segments___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::difference_type i)
        __delitem__(svg_line_segments self, PySliceObject * slice)
        """
        return _ifcopenshell_wrapper.svg_line_segments___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(svg_line_segments self, PySliceObject * slice) -> svg_line_segments
        __getitem__(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::difference_type i) -> line_segment
        """
        return _ifcopenshell_wrapper.svg_line_segments___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(svg_line_segments self, PySliceObject * slice, svg_line_segments v)
        __setitem__(svg_line_segments self, PySliceObject * slice)
        __setitem__(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::difference_type i, line_segment x)
        """
        return _ifcopenshell_wrapper.svg_line_segments___setitem__(self, *args)

    def pop(self):
        r"""pop(svg_line_segments self) -> line_segment"""
        return _ifcopenshell_wrapper.svg_line_segments_pop(self)

    def append(self, x):
        r"""append(svg_line_segments self, line_segment x)"""
        return _ifcopenshell_wrapper.svg_line_segments_append(self, x)

    def empty(self):
        r"""empty(svg_line_segments self) -> bool"""
        return _ifcopenshell_wrapper.svg_line_segments_empty(self)

    def size(self):
        r"""size(svg_line_segments self) -> std::vector< std::array< svgfill::point_2,2 > >::size_type"""
        return _ifcopenshell_wrapper.svg_line_segments_size(self)

    def swap(self, v):
        r"""swap(svg_line_segments self, svg_line_segments v)"""
        return _ifcopenshell_wrapper.svg_line_segments_swap(self, v)

    def begin(self):
        r"""begin(svg_line_segments self) -> std::vector< std::array< svgfill::point_2,2 > >::iterator"""
        return _ifcopenshell_wrapper.svg_line_segments_begin(self)

    def end(self):
        r"""end(svg_line_segments self) -> std::vector< std::array< svgfill::point_2,2 > >::iterator"""
        return _ifcopenshell_wrapper.svg_line_segments_end(self)

    def rbegin(self):
        r"""rbegin(svg_line_segments self) -> std::vector< std::array< svgfill::point_2,2 > >::reverse_iterator"""
        return _ifcopenshell_wrapper.svg_line_segments_rbegin(self)

    def rend(self):
        r"""rend(svg_line_segments self) -> std::vector< std::array< svgfill::point_2,2 > >::reverse_iterator"""
        return _ifcopenshell_wrapper.svg_line_segments_rend(self)

    def clear(self):
        r"""clear(svg_line_segments self)"""
        return _ifcopenshell_wrapper.svg_line_segments_clear(self)

    def get_allocator(self):
        r"""get_allocator(svg_line_segments self) -> std::vector< std::array< svgfill::point_2,2 > >::allocator_type"""
        return _ifcopenshell_wrapper.svg_line_segments_get_allocator(self)

    def pop_back(self):
        r"""pop_back(svg_line_segments self)"""
        return _ifcopenshell_wrapper.svg_line_segments_pop_back(self)

    def erase(self, *args):
        r"""
        erase(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::iterator pos) -> std::vector< std::array< svgfill::point_2,2 > >::iterator
        erase(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::iterator first, std::vector< std::array< svgfill::point_2,2 > >::iterator last) -> std::vector< std::array< svgfill::point_2,2 > >::iterator
        """
        return _ifcopenshell_wrapper.svg_line_segments_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(svg_line_segments self) -> svg_line_segments
        __init__(svg_line_segments self, svg_line_segments other) -> svg_line_segments
        __init__(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::size_type size) -> svg_line_segments
        __init__(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::size_type size, line_segment value) -> svg_line_segments
        """
        _ifcopenshell_wrapper.svg_line_segments_swiginit(self, _ifcopenshell_wrapper.new_svg_line_segments(*args))

    def push_back(self, x):
        r"""push_back(svg_line_segments self, line_segment x)"""
        return _ifcopenshell_wrapper.svg_line_segments_push_back(self, x)

    def front(self):
        r"""front(svg_line_segments self) -> line_segment"""
        return _ifcopenshell_wrapper.svg_line_segments_front(self)

    def back(self):
        r"""back(svg_line_segments self) -> line_segment"""
        return _ifcopenshell_wrapper.svg_line_segments_back(self)

    def assign(self, n, x):
        r"""assign(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::size_type n, line_segment x)"""
        return _ifcopenshell_wrapper.svg_line_segments_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::size_type new_size)
        resize(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::size_type new_size, line_segment x)
        """
        return _ifcopenshell_wrapper.svg_line_segments_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::iterator pos, line_segment x) -> std::vector< std::array< svgfill::point_2,2 > >::iterator
        insert(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::iterator pos, std::vector< std::array< svgfill::point_2,2 > >::size_type n, line_segment x)
        """
        return _ifcopenshell_wrapper.svg_line_segments_insert(self, *args)

    def reserve(self, n):
        r"""reserve(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::size_type n)"""
        return _ifcopenshell_wrapper.svg_line_segments_reserve(self, n)

    def capacity(self):
        r"""capacity(svg_line_segments self) -> std::vector< std::array< svgfill::point_2,2 > >::size_type"""
        return _ifcopenshell_wrapper.svg_line_segments_capacity(self)
    __swig_destroy__ = _ifcopenshell_wrapper.delete_svg_line_segments

# Register svg_line_segments in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.svg_line_segments_swigregister(svg_line_segments)

class svg_groups_of_line_segments(object):
    r"""Proxy of C++ std::vector< std::vector< std::array< svgfill::point_2,2 > > > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        r"""iterator(svg_groups_of_line_segments self) -> SwigPyIterator"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(svg_groups_of_line_segments self) -> bool"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments___nonzero__(self)

    def __bool__(self):
        r"""__bool__(svg_groups_of_line_segments self) -> bool"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments___bool__(self)

    def __len__(self):
        r"""__len__(svg_groups_of_line_segments self) -> std::vector< std::vector< std::array< svgfill::point_2,2 > > >::size_type"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::difference_type i, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::difference_type j) -> svg_groups_of_line_segments"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::difference_type i, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::difference_type j)
        __setslice__(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::difference_type i, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::difference_type j, svg_groups_of_line_segments v)
        """
        return _ifcopenshell_wrapper.svg_groups_of_line_segments___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::difference_type i, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::difference_type j)"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::difference_type i)
        __delitem__(svg_groups_of_line_segments self, PySliceObject * slice)
        """
        return _ifcopenshell_wrapper.svg_groups_of_line_segments___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(svg_groups_of_line_segments self, PySliceObject * slice) -> svg_groups_of_line_segments
        __getitem__(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::difference_type i) -> svg_line_segments
        """
        return _ifcopenshell_wrapper.svg_groups_of_line_segments___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(svg_groups_of_line_segments self, PySliceObject * slice, svg_groups_of_line_segments v)
        __setitem__(svg_groups_of_line_segments self, PySliceObject * slice)
        __setitem__(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::difference_type i, svg_line_segments x)
        """
        return _ifcopenshell_wrapper.svg_groups_of_line_segments___setitem__(self, *args)

    def pop(self):
        r"""pop(svg_groups_of_line_segments self) -> svg_line_segments"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments_pop(self)

    def append(self, x):
        r"""append(svg_groups_of_line_segments self, svg_line_segments x)"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments_append(self, x)

    def empty(self):
        r"""empty(svg_groups_of_line_segments self) -> bool"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments_empty(self)

    def size(self):
        r"""size(svg_groups_of_line_segments self) -> std::vector< std::vector< std::array< svgfill::point_2,2 > > >::size_type"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments_size(self)

    def swap(self, v):
        r"""swap(svg_groups_of_line_segments self, svg_groups_of_line_segments v)"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments_swap(self, v)

    def begin(self):
        r"""begin(svg_groups_of_line_segments self) -> std::vector< std::vector< std::array< svgfill::point_2,2 > > >::iterator"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments_begin(self)

    def end(self):
        r"""end(svg_groups_of_line_segments self) -> std::vector< std::vector< std::array< svgfill::point_2,2 > > >::iterator"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments_end(self)

    def rbegin(self):
        r"""rbegin(svg_groups_of_line_segments self) -> std::vector< std::vector< std::array< svgfill::point_2,2 > > >::reverse_iterator"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments_rbegin(self)

    def rend(self):
        r"""rend(svg_groups_of_line_segments self) -> std::vector< std::vector< std::array< svgfill::point_2,2 > > >::reverse_iterator"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments_rend(self)

    def clear(self):
        r"""clear(svg_groups_of_line_segments self)"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments_clear(self)

    def get_allocator(self):
        r"""get_allocator(svg_groups_of_line_segments self) -> std::vector< std::vector< std::array< svgfill::point_2,2 > > >::allocator_type"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments_get_allocator(self)

    def pop_back(self):
        r"""pop_back(svg_groups_of_line_segments self)"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments_pop_back(self)

    def erase(self, *args):
        r"""
        erase(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::iterator pos) -> std::vector< std::vector< std::array< svgfill::point_2,2 > > >::iterator
        erase(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::iterator first, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::iterator last) -> std::vector< std::vector< std::array< svgfill::point_2,2 > > >::iterator
        """
        return _ifcopenshell_wrapper.svg_groups_of_line_segments_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(svg_groups_of_line_segments self) -> svg_groups_of_line_segments
        __init__(svg_groups_of_line_segments self, svg_groups_of_line_segments other) -> svg_groups_of_line_segments
        __init__(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::size_type size) -> svg_groups_of_line_segments
        __init__(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::size_type size, svg_line_segments value) -> svg_groups_of_line_segments
        """
        _ifcopenshell_wrapper.svg_groups_of_line_segments_swiginit(self, _ifcopenshell_wrapper.new_svg_groups_of_line_segments(*args))

    def push_back(self, x):
        r"""push_back(svg_groups_of_line_segments self, svg_line_segments x)"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments_push_back(self, x)

    def front(self):
        r"""front(svg_groups_of_line_segments self) -> svg_line_segments"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments_front(self)

    def back(self):
        r"""back(svg_groups_of_line_segments self) -> svg_line_segments"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments_back(self)

    def assign(self, n, x):
        r"""assign(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::size_type n, svg_line_segments x)"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::size_type new_size)
        resize(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::size_type new_size, svg_line_segments x)
        """
        return _ifcopenshell_wrapper.svg_groups_of_line_segments_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::iterator pos, svg_line_segments x) -> std::vector< std::vector< std::array< svgfill::point_2,2 > > >::iterator
        insert(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::iterator pos, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::size_type n, svg_line_segments x)
        """
        return _ifcopenshell_wrapper.svg_groups_of_line_segments_insert(self, *args)

    def reserve(self, n):
        r"""reserve(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::size_type n)"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments_reserve(self, n)

    def capacity(self):
        r"""capacity(svg_groups_of_line_segments self) -> std::vector< std::vector< std::array< svgfill::point_2,2 > > >::size_type"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments_capacity(self)
    __swig_destroy__ = _ifcopenshell_wrapper.delete_svg_groups_of_line_segments

# Register svg_groups_of_line_segments in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.svg_groups_of_line_segments_swigregister(svg_groups_of_line_segments)

class svg_point(object):
    r"""Proxy of C++ std::array< double,2 > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        r"""iterator(svg_point self) -> SwigPyIterator"""
        return _ifcopenshell_wrapper.svg_point_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(svg_point self) -> bool"""
        return _ifcopenshell_wrapper.svg_point___nonzero__(self)

    def __bool__(self):
        r"""__bool__(svg_point self) -> bool"""
        return _ifcopenshell_wrapper.svg_point___bool__(self)

    def __len__(self):
        r"""__len__(svg_point self) -> std::array< double,2 >::size_type"""
        return _ifcopenshell_wrapper.svg_point___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(svg_point self, std::array< double,2 >::difference_type i, std::array< double,2 >::difference_type j) -> svg_point"""
        return _ifcopenshell_wrapper.svg_point___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(svg_point self, std::array< double,2 >::difference_type i, std::array< double,2 >::difference_type j)
        __setslice__(svg_point self, std::array< double,2 >::difference_type i, std::array< double,2 >::difference_type j, svg_point v)
        """
        return _ifcopenshell_wrapper.svg_point___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(svg_point self, std::array< double,2 >::difference_type i, std::array< double,2 >::difference_type j)"""
        return _ifcopenshell_wrapper.svg_point___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(svg_point self, std::array< double,2 >::difference_type i)
        __delitem__(svg_point self, PySliceObject * slice)
        """
        return _ifcopenshell_wrapper.svg_point___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(svg_point self, PySliceObject * slice) -> svg_point
        __getitem__(svg_point self, std::array< double,2 >::difference_type i) -> std::array< double,2 >::value_type const &
        """
        return _ifcopenshell_wrapper.svg_point___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(svg_point self, PySliceObject * slice, svg_point v)
        __setitem__(svg_point self, PySliceObject * slice)
        __setitem__(svg_point self, std::array< double,2 >::difference_type i, std::array< double,2 >::value_type const & x)
        """
        return _ifcopenshell_wrapper.svg_point___setitem__(self, *args)

    def __init__(self, *args):
        r"""
        __init__(svg_point self) -> svg_point
        __init__(svg_point self, svg_point other) -> svg_point
        """
        _ifcopenshell_wrapper.svg_point_swiginit(self, _ifcopenshell_wrapper.new_svg_point(*args))

    def empty(self):
        r"""empty(svg_point self) -> bool"""
        return _ifcopenshell_wrapper.svg_point_empty(self)

    def size(self):
        r"""size(svg_point self) -> std::array< double,2 >::size_type"""
        return _ifcopenshell_wrapper.svg_point_size(self)

    def swap(self, v):
        r"""swap(svg_point self, svg_point v)"""
        return _ifcopenshell_wrapper.svg_point_swap(self, v)

    def begin(self):
        r"""begin(svg_point self) -> std::array< double,2 >::iterator"""
        return _ifcopenshell_wrapper.svg_point_begin(self)

    def end(self):
        r"""end(svg_point self) -> std::array< double,2 >::iterator"""
        return _ifcopenshell_wrapper.svg_point_end(self)

    def rbegin(self):
        r"""rbegin(svg_point self) -> std::array< double,2 >::reverse_iterator"""
        return _ifcopenshell_wrapper.svg_point_rbegin(self)

    def rend(self):
        r"""rend(svg_point self) -> std::array< double,2 >::reverse_iterator"""
        return _ifcopenshell_wrapper.svg_point_rend(self)

    def front(self):
        r"""front(svg_point self) -> std::array< double,2 >::value_type const &"""
        return _ifcopenshell_wrapper.svg_point_front(self)

    def back(self):
        r"""back(svg_point self) -> std::array< double,2 >::value_type const &"""
        return _ifcopenshell_wrapper.svg_point_back(self)

    def fill(self, u):
        r"""fill(svg_point self, std::array< double,2 >::value_type const & u)"""
        return _ifcopenshell_wrapper.svg_point_fill(self, u)
    __swig_destroy__ = _ifcopenshell_wrapper.delete_svg_point

# Register svg_point in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.svg_point_swigregister(svg_point)

class line_segment(object):
    r"""Proxy of C++ std::array< svgfill::point_2,2 > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        r"""iterator(line_segment self) -> SwigPyIterator"""
        return _ifcopenshell_wrapper.line_segment_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(line_segment self) -> bool"""
        return _ifcopenshell_wrapper.line_segment___nonzero__(self)

    def __bool__(self):
        r"""__bool__(line_segment self) -> bool"""
        return _ifcopenshell_wrapper.line_segment___bool__(self)

    def __len__(self):
        r"""__len__(line_segment self) -> std::array< svgfill::point_2,2 >::size_type"""
        return _ifcopenshell_wrapper.line_segment___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(line_segment self, std::array< svgfill::point_2,2 >::difference_type i, std::array< svgfill::point_2,2 >::difference_type j) -> line_segment"""
        return _ifcopenshell_wrapper.line_segment___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(line_segment self, std::array< svgfill::point_2,2 >::difference_type i, std::array< svgfill::point_2,2 >::difference_type j)
        __setslice__(line_segment self, std::array< svgfill::point_2,2 >::difference_type i, std::array< svgfill::point_2,2 >::difference_type j, line_segment v)
        """
        return _ifcopenshell_wrapper.line_segment___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(line_segment self, std::array< svgfill::point_2,2 >::difference_type i, std::array< svgfill::point_2,2 >::difference_type j)"""
        return _ifcopenshell_wrapper.line_segment___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(line_segment self, std::array< svgfill::point_2,2 >::difference_type i)
        __delitem__(line_segment self, PySliceObject * slice)
        """
        return _ifcopenshell_wrapper.line_segment___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(line_segment self, PySliceObject * slice) -> line_segment
        __getitem__(line_segment self, std::array< svgfill::point_2,2 >::difference_type i) -> std::array< svgfill::point_2,2 >::value_type const &
        """
        return _ifcopenshell_wrapper.line_segment___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(line_segment self, PySliceObject * slice, line_segment v)
        __setitem__(line_segment self, PySliceObject * slice)
        __setitem__(line_segment self, std::array< svgfill::point_2,2 >::difference_type i, std::array< svgfill::point_2,2 >::value_type const & x)
        """
        return _ifcopenshell_wrapper.line_segment___setitem__(self, *args)

    def __init__(self, *args):
        r"""
        __init__(line_segment self) -> line_segment
        __init__(line_segment self, line_segment other) -> line_segment
        """
        _ifcopenshell_wrapper.line_segment_swiginit(self, _ifcopenshell_wrapper.new_line_segment(*args))

    def empty(self):
        r"""empty(line_segment self) -> bool"""
        return _ifcopenshell_wrapper.line_segment_empty(self)

    def size(self):
        r"""size(line_segment self) -> std::array< svgfill::point_2,2 >::size_type"""
        return _ifcopenshell_wrapper.line_segment_size(self)

    def swap(self, v):
        r"""swap(line_segment self, line_segment v)"""
        return _ifcopenshell_wrapper.line_segment_swap(self, v)

    def begin(self):
        r"""begin(line_segment self) -> std::array< svgfill::point_2,2 >::iterator"""
        return _ifcopenshell_wrapper.line_segment_begin(self)

    def end(self):
        r"""end(line_segment self) -> std::array< svgfill::point_2,2 >::iterator"""
        return _ifcopenshell_wrapper.line_segment_end(self)

    def rbegin(self):
        r"""rbegin(line_segment self) -> std::array< svgfill::point_2,2 >::reverse_iterator"""
        return _ifcopenshell_wrapper.line_segment_rbegin(self)

    def rend(self):
        r"""rend(line_segment self) -> std::array< svgfill::point_2,2 >::reverse_iterator"""
        return _ifcopenshell_wrapper.line_segment_rend(self)

    def front(self):
        r"""front(line_segment self) -> std::array< svgfill::point_2,2 >::value_type const &"""
        return _ifcopenshell_wrapper.line_segment_front(self)

    def back(self):
        r"""back(line_segment self) -> std::array< svgfill::point_2,2 >::value_type const &"""
        return _ifcopenshell_wrapper.line_segment_back(self)

    def fill(self, u):
        r"""fill(line_segment self, std::array< svgfill::point_2,2 >::value_type const & u)"""
        return _ifcopenshell_wrapper.line_segment_fill(self, u)
    __swig_destroy__ = _ifcopenshell_wrapper.delete_line_segment

# Register line_segment in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.line_segment_swigregister(line_segment)

class svg_polygons(object):
    r"""Proxy of C++ std::vector< svgfill::polygon_2 > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        r"""iterator(svg_polygons self) -> SwigPyIterator"""
        return _ifcopenshell_wrapper.svg_polygons_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(svg_polygons self) -> bool"""
        return _ifcopenshell_wrapper.svg_polygons___nonzero__(self)

    def __bool__(self):
        r"""__bool__(svg_polygons self) -> bool"""
        return _ifcopenshell_wrapper.svg_polygons___bool__(self)

    def __len__(self):
        r"""__len__(svg_polygons self) -> std::vector< svgfill::polygon_2 >::size_type"""
        return _ifcopenshell_wrapper.svg_polygons___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(svg_polygons self, std::vector< svgfill::polygon_2 >::difference_type i, std::vector< svgfill::polygon_2 >::difference_type j) -> svg_polygons"""
        return _ifcopenshell_wrapper.svg_polygons___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(svg_polygons self, std::vector< svgfill::polygon_2 >::difference_type i, std::vector< svgfill::polygon_2 >::difference_type j)
        __setslice__(svg_polygons self, std::vector< svgfill::polygon_2 >::difference_type i, std::vector< svgfill::polygon_2 >::difference_type j, svg_polygons v)
        """
        return _ifcopenshell_wrapper.svg_polygons___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(svg_polygons self, std::vector< svgfill::polygon_2 >::difference_type i, std::vector< svgfill::polygon_2 >::difference_type j)"""
        return _ifcopenshell_wrapper.svg_polygons___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(svg_polygons self, std::vector< svgfill::polygon_2 >::difference_type i)
        __delitem__(svg_polygons self, PySliceObject * slice)
        """
        return _ifcopenshell_wrapper.svg_polygons___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(svg_polygons self, PySliceObject * slice) -> svg_polygons
        __getitem__(svg_polygons self, std::vector< svgfill::polygon_2 >::difference_type i) -> polygon_2
        """
        return _ifcopenshell_wrapper.svg_polygons___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(svg_polygons self, PySliceObject * slice, svg_polygons v)
        __setitem__(svg_polygons self, PySliceObject * slice)
        __setitem__(svg_polygons self, std::vector< svgfill::polygon_2 >::difference_type i, polygon_2 x)
        """
        return _ifcopenshell_wrapper.svg_polygons___setitem__(self, *args)

    def pop(self):
        r"""pop(svg_polygons self) -> polygon_2"""
        return _ifcopenshell_wrapper.svg_polygons_pop(self)

    def append(self, x):
        r"""append(svg_polygons self, polygon_2 x)"""
        return _ifcopenshell_wrapper.svg_polygons_append(self, x)

    def empty(self):
        r"""empty(svg_polygons self) -> bool"""
        return _ifcopenshell_wrapper.svg_polygons_empty(self)

    def size(self):
        r"""size(svg_polygons self) -> std::vector< svgfill::polygon_2 >::size_type"""
        return _ifcopenshell_wrapper.svg_polygons_size(self)

    def swap(self, v):
        r"""swap(svg_polygons self, svg_polygons v)"""
        return _ifcopenshell_wrapper.svg_polygons_swap(self, v)

    def begin(self):
        r"""begin(svg_polygons self) -> std::vector< svgfill::polygon_2 >::iterator"""
        return _ifcopenshell_wrapper.svg_polygons_begin(self)

    def end(self):
        r"""end(svg_polygons self) -> std::vector< svgfill::polygon_2 >::iterator"""
        return _ifcopenshell_wrapper.svg_polygons_end(self)

    def rbegin(self):
        r"""rbegin(svg_polygons self) -> std::vector< svgfill::polygon_2 >::reverse_iterator"""
        return _ifcopenshell_wrapper.svg_polygons_rbegin(self)

    def rend(self):
        r"""rend(svg_polygons self) -> std::vector< svgfill::polygon_2 >::reverse_iterator"""
        return _ifcopenshell_wrapper.svg_polygons_rend(self)

    def clear(self):
        r"""clear(svg_polygons self)"""
        return _ifcopenshell_wrapper.svg_polygons_clear(self)

    def get_allocator(self):
        r"""get_allocator(svg_polygons self) -> std::vector< svgfill::polygon_2 >::allocator_type"""
        return _ifcopenshell_wrapper.svg_polygons_get_allocator(self)

    def pop_back(self):
        r"""pop_back(svg_polygons self)"""
        return _ifcopenshell_wrapper.svg_polygons_pop_back(self)

    def erase(self, *args):
        r"""
        erase(svg_polygons self, std::vector< svgfill::polygon_2 >::iterator pos) -> std::vector< svgfill::polygon_2 >::iterator
        erase(svg_polygons self, std::vector< svgfill::polygon_2 >::iterator first, std::vector< svgfill::polygon_2 >::iterator last) -> std::vector< svgfill::polygon_2 >::iterator
        """
        return _ifcopenshell_wrapper.svg_polygons_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(svg_polygons self) -> svg_polygons
        __init__(svg_polygons self, svg_polygons other) -> svg_polygons
        __init__(svg_polygons self, std::vector< svgfill::polygon_2 >::size_type size) -> svg_polygons
        __init__(svg_polygons self, std::vector< svgfill::polygon_2 >::size_type size, polygon_2 value) -> svg_polygons
        """
        _ifcopenshell_wrapper.svg_polygons_swiginit(self, _ifcopenshell_wrapper.new_svg_polygons(*args))

    def push_back(self, x):
        r"""push_back(svg_polygons self, polygon_2 x)"""
        return _ifcopenshell_wrapper.svg_polygons_push_back(self, x)

    def front(self):
        r"""front(svg_polygons self) -> polygon_2"""
        return _ifcopenshell_wrapper.svg_polygons_front(self)

    def back(self):
        r"""back(svg_polygons self) -> polygon_2"""
        return _ifcopenshell_wrapper.svg_polygons_back(self)

    def assign(self, n, x):
        r"""assign(svg_polygons self, std::vector< svgfill::polygon_2 >::size_type n, polygon_2 x)"""
        return _ifcopenshell_wrapper.svg_polygons_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(svg_polygons self, std::vector< svgfill::polygon_2 >::size_type new_size)
        resize(svg_polygons self, std::vector< svgfill::polygon_2 >::size_type new_size, polygon_2 x)
        """
        return _ifcopenshell_wrapper.svg_polygons_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(svg_polygons self, std::vector< svgfill::polygon_2 >::iterator pos, polygon_2 x) -> std::vector< svgfill::polygon_2 >::iterator
        insert(svg_polygons self, std::vector< svgfill::polygon_2 >::iterator pos, std::vector< svgfill::polygon_2 >::size_type n, polygon_2 x)
        """
        return _ifcopenshell_wrapper.svg_polygons_insert(self, *args)

    def reserve(self, n):
        r"""reserve(svg_polygons self, std::vector< svgfill::polygon_2 >::size_type n)"""
        return _ifcopenshell_wrapper.svg_polygons_reserve(self, n)

    def capacity(self):
        r"""capacity(svg_polygons self) -> std::vector< svgfill::polygon_2 >::size_type"""
        return _ifcopenshell_wrapper.svg_polygons_capacity(self)
    __swig_destroy__ = _ifcopenshell_wrapper.delete_svg_polygons

# Register svg_polygons in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.svg_polygons_swigregister(svg_polygons)

class svg_groups_of_polygons(object):
    r"""Proxy of C++ std::vector< std::vector< svgfill::polygon_2 > > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        r"""iterator(svg_groups_of_polygons self) -> SwigPyIterator"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(svg_groups_of_polygons self) -> bool"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons___nonzero__(self)

    def __bool__(self):
        r"""__bool__(svg_groups_of_polygons self) -> bool"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons___bool__(self)

    def __len__(self):
        r"""__len__(svg_groups_of_polygons self) -> std::vector< std::vector< svgfill::polygon_2 > >::size_type"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::difference_type i, std::vector< std::vector< svgfill::polygon_2 > >::difference_type j) -> svg_groups_of_polygons"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::difference_type i, std::vector< std::vector< svgfill::polygon_2 > >::difference_type j)
        __setslice__(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::difference_type i, std::vector< std::vector< svgfill::polygon_2 > >::difference_type j, svg_groups_of_polygons v)
        """
        return _ifcopenshell_wrapper.svg_groups_of_polygons___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::difference_type i, std::vector< std::vector< svgfill::polygon_2 > >::difference_type j)"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::difference_type i)
        __delitem__(svg_groups_of_polygons self, PySliceObject * slice)
        """
        return _ifcopenshell_wrapper.svg_groups_of_polygons___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(svg_groups_of_polygons self, PySliceObject * slice) -> svg_groups_of_polygons
        __getitem__(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::difference_type i) -> svg_polygons
        """
        return _ifcopenshell_wrapper.svg_groups_of_polygons___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(svg_groups_of_polygons self, PySliceObject * slice, svg_groups_of_polygons v)
        __setitem__(svg_groups_of_polygons self, PySliceObject * slice)
        __setitem__(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::difference_type i, svg_polygons x)
        """
        return _ifcopenshell_wrapper.svg_groups_of_polygons___setitem__(self, *args)

    def pop(self):
        r"""pop(svg_groups_of_polygons self) -> svg_polygons"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons_pop(self)

    def append(self, x):
        r"""append(svg_groups_of_polygons self, svg_polygons x)"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons_append(self, x)

    def empty(self):
        r"""empty(svg_groups_of_polygons self) -> bool"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons_empty(self)

    def size(self):
        r"""size(svg_groups_of_polygons self) -> std::vector< std::vector< svgfill::polygon_2 > >::size_type"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons_size(self)

    def swap(self, v):
        r"""swap(svg_groups_of_polygons self, svg_groups_of_polygons v)"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons_swap(self, v)

    def begin(self):
        r"""begin(svg_groups_of_polygons self) -> std::vector< std::vector< svgfill::polygon_2 > >::iterator"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons_begin(self)

    def end(self):
        r"""end(svg_groups_of_polygons self) -> std::vector< std::vector< svgfill::polygon_2 > >::iterator"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons_end(self)

    def rbegin(self):
        r"""rbegin(svg_groups_of_polygons self) -> std::vector< std::vector< svgfill::polygon_2 > >::reverse_iterator"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons_rbegin(self)

    def rend(self):
        r"""rend(svg_groups_of_polygons self) -> std::vector< std::vector< svgfill::polygon_2 > >::reverse_iterator"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons_rend(self)

    def clear(self):
        r"""clear(svg_groups_of_polygons self)"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons_clear(self)

    def get_allocator(self):
        r"""get_allocator(svg_groups_of_polygons self) -> std::vector< std::vector< svgfill::polygon_2 > >::allocator_type"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons_get_allocator(self)

    def pop_back(self):
        r"""pop_back(svg_groups_of_polygons self)"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons_pop_back(self)

    def erase(self, *args):
        r"""
        erase(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::iterator pos) -> std::vector< std::vector< svgfill::polygon_2 > >::iterator
        erase(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::iterator first, std::vector< std::vector< svgfill::polygon_2 > >::iterator last) -> std::vector< std::vector< svgfill::polygon_2 > >::iterator
        """
        return _ifcopenshell_wrapper.svg_groups_of_polygons_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(svg_groups_of_polygons self) -> svg_groups_of_polygons
        __init__(svg_groups_of_polygons self, svg_groups_of_polygons other) -> svg_groups_of_polygons
        __init__(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::size_type size) -> svg_groups_of_polygons
        __init__(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::size_type size, svg_polygons value) -> svg_groups_of_polygons
        """
        _ifcopenshell_wrapper.svg_groups_of_polygons_swiginit(self, _ifcopenshell_wrapper.new_svg_groups_of_polygons(*args))

    def push_back(self, x):
        r"""push_back(svg_groups_of_polygons self, svg_polygons x)"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons_push_back(self, x)

    def front(self):
        r"""front(svg_groups_of_polygons self) -> svg_polygons"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons_front(self)

    def back(self):
        r"""back(svg_groups_of_polygons self) -> svg_polygons"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons_back(self)

    def assign(self, n, x):
        r"""assign(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::size_type n, svg_polygons x)"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::size_type new_size)
        resize(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::size_type new_size, svg_polygons x)
        """
        return _ifcopenshell_wrapper.svg_groups_of_polygons_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::iterator pos, svg_polygons x) -> std::vector< std::vector< svgfill::polygon_2 > >::iterator
        insert(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::iterator pos, std::vector< std::vector< svgfill::polygon_2 > >::size_type n, svg_polygons x)
        """
        return _ifcopenshell_wrapper.svg_groups_of_polygons_insert(self, *args)

    def reserve(self, n):
        r"""reserve(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::size_type n)"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons_reserve(self, n)

    def capacity(self):
        r"""capacity(svg_groups_of_polygons self) -> std::vector< std::vector< svgfill::polygon_2 > >::size_type"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons_capacity(self)
    __swig_destroy__ = _ifcopenshell_wrapper.delete_svg_groups_of_polygons

# Register svg_groups_of_polygons in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.svg_groups_of_polygons_swigregister(svg_groups_of_polygons)

class svg_loop(object):
    r"""Proxy of C++ std::vector< std::array< double,2 > > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        r"""iterator(svg_loop self) -> SwigPyIterator"""
        return _ifcopenshell_wrapper.svg_loop_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(svg_loop self) -> bool"""
        return _ifcopenshell_wrapper.svg_loop___nonzero__(self)

    def __bool__(self):
        r"""__bool__(svg_loop self) -> bool"""
        return _ifcopenshell_wrapper.svg_loop___bool__(self)

    def __len__(self):
        r"""__len__(svg_loop self) -> std::vector< std::array< double,2 > >::size_type"""
        return _ifcopenshell_wrapper.svg_loop___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(svg_loop self, std::vector< std::array< double,2 > >::difference_type i, std::vector< std::array< double,2 > >::difference_type j) -> svg_loop"""
        return _ifcopenshell_wrapper.svg_loop___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(svg_loop self, std::vector< std::array< double,2 > >::difference_type i, std::vector< std::array< double,2 > >::difference_type j)
        __setslice__(svg_loop self, std::vector< std::array< double,2 > >::difference_type i, std::vector< std::array< double,2 > >::difference_type j, svg_loop v)
        """
        return _ifcopenshell_wrapper.svg_loop___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(svg_loop self, std::vector< std::array< double,2 > >::difference_type i, std::vector< std::array< double,2 > >::difference_type j)"""
        return _ifcopenshell_wrapper.svg_loop___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(svg_loop self, std::vector< std::array< double,2 > >::difference_type i)
        __delitem__(svg_loop self, PySliceObject * slice)
        """
        return _ifcopenshell_wrapper.svg_loop___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(svg_loop self, PySliceObject * slice) -> svg_loop
        __getitem__(svg_loop self, std::vector< std::array< double,2 > >::difference_type i) -> svg_point
        """
        return _ifcopenshell_wrapper.svg_loop___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(svg_loop self, PySliceObject * slice, svg_loop v)
        __setitem__(svg_loop self, PySliceObject * slice)
        __setitem__(svg_loop self, std::vector< std::array< double,2 > >::difference_type i, svg_point x)
        """
        return _ifcopenshell_wrapper.svg_loop___setitem__(self, *args)

    def pop(self):
        r"""pop(svg_loop self) -> svg_point"""
        return _ifcopenshell_wrapper.svg_loop_pop(self)

    def append(self, x):
        r"""append(svg_loop self, svg_point x)"""
        return _ifcopenshell_wrapper.svg_loop_append(self, x)

    def empty(self):
        r"""empty(svg_loop self) -> bool"""
        return _ifcopenshell_wrapper.svg_loop_empty(self)

    def size(self):
        r"""size(svg_loop self) -> std::vector< std::array< double,2 > >::size_type"""
        return _ifcopenshell_wrapper.svg_loop_size(self)

    def swap(self, v):
        r"""swap(svg_loop self, svg_loop v)"""
        return _ifcopenshell_wrapper.svg_loop_swap(self, v)

    def begin(self):
        r"""begin(svg_loop self) -> std::vector< std::array< double,2 > >::iterator"""
        return _ifcopenshell_wrapper.svg_loop_begin(self)

    def end(self):
        r"""end(svg_loop self) -> std::vector< std::array< double,2 > >::iterator"""
        return _ifcopenshell_wrapper.svg_loop_end(self)

    def rbegin(self):
        r"""rbegin(svg_loop self) -> std::vector< std::array< double,2 > >::reverse_iterator"""
        return _ifcopenshell_wrapper.svg_loop_rbegin(self)

    def rend(self):
        r"""rend(svg_loop self) -> std::vector< std::array< double,2 > >::reverse_iterator"""
        return _ifcopenshell_wrapper.svg_loop_rend(self)

    def clear(self):
        r"""clear(svg_loop self)"""
        return _ifcopenshell_wrapper.svg_loop_clear(self)

    def get_allocator(self):
        r"""get_allocator(svg_loop self) -> std::vector< std::array< double,2 > >::allocator_type"""
        return _ifcopenshell_wrapper.svg_loop_get_allocator(self)

    def pop_back(self):
        r"""pop_back(svg_loop self)"""
        return _ifcopenshell_wrapper.svg_loop_pop_back(self)

    def erase(self, *args):
        r"""
        erase(svg_loop self, std::vector< std::array< double,2 > >::iterator pos) -> std::vector< std::array< double,2 > >::iterator
        erase(svg_loop self, std::vector< std::array< double,2 > >::iterator first, std::vector< std::array< double,2 > >::iterator last) -> std::vector< std::array< double,2 > >::iterator
        """
        return _ifcopenshell_wrapper.svg_loop_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(svg_loop self) -> svg_loop
        __init__(svg_loop self, svg_loop other) -> svg_loop
        __init__(svg_loop self, std::vector< std::array< double,2 > >::size_type size) -> svg_loop
        __init__(svg_loop self, std::vector< std::array< double,2 > >::size_type size, svg_point value) -> svg_loop
        """
        _ifcopenshell_wrapper.svg_loop_swiginit(self, _ifcopenshell_wrapper.new_svg_loop(*args))

    def push_back(self, x):
        r"""push_back(svg_loop self, svg_point x)"""
        return _ifcopenshell_wrapper.svg_loop_push_back(self, x)

    def front(self):
        r"""front(svg_loop self) -> svg_point"""
        return _ifcopenshell_wrapper.svg_loop_front(self)

    def back(self):
        r"""back(svg_loop self) -> svg_point"""
        return _ifcopenshell_wrapper.svg_loop_back(self)

    def assign(self, n, x):
        r"""assign(svg_loop self, std::vector< std::array< double,2 > >::size_type n, svg_point x)"""
        return _ifcopenshell_wrapper.svg_loop_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(svg_loop self, std::vector< std::array< double,2 > >::size_type new_size)
        resize(svg_loop self, std::vector< std::array< double,2 > >::size_type new_size, svg_point x)
        """
        return _ifcopenshell_wrapper.svg_loop_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(svg_loop self, std::vector< std::array< double,2 > >::iterator pos, svg_point x) -> std::vector< std::array< double,2 > >::iterator
        insert(svg_loop self, std::vector< std::array< double,2 > >::iterator pos, std::vector< std::array< double,2 > >::size_type n, svg_point x)
        """
        return _ifcopenshell_wrapper.svg_loop_insert(self, *args)

    def reserve(self, n):
        r"""reserve(svg_loop self, std::vector< std::array< double,2 > >::size_type n)"""
        return _ifcopenshell_wrapper.svg_loop_reserve(self, n)

    def capacity(self):
        r"""capacity(svg_loop self) -> std::vector< std::array< double,2 > >::size_type"""
        return _ifcopenshell_wrapper.svg_loop_capacity(self)
    __swig_destroy__ = _ifcopenshell_wrapper.delete_svg_loop

# Register svg_loop in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.svg_loop_swigregister(svg_loop)

class svg_loops(object):
    r"""Proxy of C++ std::vector< std::vector< std::array< double,2 > > > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        r"""iterator(svg_loops self) -> SwigPyIterator"""
        return _ifcopenshell_wrapper.svg_loops_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(svg_loops self) -> bool"""
        return _ifcopenshell_wrapper.svg_loops___nonzero__(self)

    def __bool__(self):
        r"""__bool__(svg_loops self) -> bool"""
        return _ifcopenshell_wrapper.svg_loops___bool__(self)

    def __len__(self):
        r"""__len__(svg_loops self) -> std::vector< std::vector< std::array< double,2 > > >::size_type"""
        return _ifcopenshell_wrapper.svg_loops___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::difference_type i, std::vector< std::vector< std::array< double,2 > > >::difference_type j) -> svg_loops"""
        return _ifcopenshell_wrapper.svg_loops___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::difference_type i, std::vector< std::vector< std::array< double,2 > > >::difference_type j)
        __setslice__(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::difference_type i, std::vector< std::vector< std::array< double,2 > > >::difference_type j, svg_loops v)
        """
        return _ifcopenshell_wrapper.svg_loops___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::difference_type i, std::vector< std::vector< std::array< double,2 > > >::difference_type j)"""
        return _ifcopenshell_wrapper.svg_loops___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::difference_type i)
        __delitem__(svg_loops self, PySliceObject * slice)
        """
        return _ifcopenshell_wrapper.svg_loops___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(svg_loops self, PySliceObject * slice) -> svg_loops
        __getitem__(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::difference_type i) -> svg_loop
        """
        return _ifcopenshell_wrapper.svg_loops___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(svg_loops self, PySliceObject * slice, svg_loops v)
        __setitem__(svg_loops self, PySliceObject * slice)
        __setitem__(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::difference_type i, svg_loop x)
        """
        return _ifcopenshell_wrapper.svg_loops___setitem__(self, *args)

    def pop(self):
        r"""pop(svg_loops self) -> svg_loop"""
        return _ifcopenshell_wrapper.svg_loops_pop(self)

    def append(self, x):
        r"""append(svg_loops self, svg_loop x)"""
        return _ifcopenshell_wrapper.svg_loops_append(self, x)

    def empty(self):
        r"""empty(svg_loops self) -> bool"""
        return _ifcopenshell_wrapper.svg_loops_empty(self)

    def size(self):
        r"""size(svg_loops self) -> std::vector< std::vector< std::array< double,2 > > >::size_type"""
        return _ifcopenshell_wrapper.svg_loops_size(self)

    def swap(self, v):
        r"""swap(svg_loops self, svg_loops v)"""
        return _ifcopenshell_wrapper.svg_loops_swap(self, v)

    def begin(self):
        r"""begin(svg_loops self) -> std::vector< std::vector< std::array< double,2 > > >::iterator"""
        return _ifcopenshell_wrapper.svg_loops_begin(self)

    def end(self):
        r"""end(svg_loops self) -> std::vector< std::vector< std::array< double,2 > > >::iterator"""
        return _ifcopenshell_wrapper.svg_loops_end(self)

    def rbegin(self):
        r"""rbegin(svg_loops self) -> std::vector< std::vector< std::array< double,2 > > >::reverse_iterator"""
        return _ifcopenshell_wrapper.svg_loops_rbegin(self)

    def rend(self):
        r"""rend(svg_loops self) -> std::vector< std::vector< std::array< double,2 > > >::reverse_iterator"""
        return _ifcopenshell_wrapper.svg_loops_rend(self)

    def clear(self):
        r"""clear(svg_loops self)"""
        return _ifcopenshell_wrapper.svg_loops_clear(self)

    def get_allocator(self):
        r"""get_allocator(svg_loops self) -> std::vector< std::vector< std::array< double,2 > > >::allocator_type"""
        return _ifcopenshell_wrapper.svg_loops_get_allocator(self)

    def pop_back(self):
        r"""pop_back(svg_loops self)"""
        return _ifcopenshell_wrapper.svg_loops_pop_back(self)

    def erase(self, *args):
        r"""
        erase(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::iterator pos) -> std::vector< std::vector< std::array< double,2 > > >::iterator
        erase(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::iterator first, std::vector< std::vector< std::array< double,2 > > >::iterator last) -> std::vector< std::vector< std::array< double,2 > > >::iterator
        """
        return _ifcopenshell_wrapper.svg_loops_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(svg_loops self) -> svg_loops
        __init__(svg_loops self, svg_loops other) -> svg_loops
        __init__(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::size_type size) -> svg_loops
        __init__(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::size_type size, svg_loop value) -> svg_loops
        """
        _ifcopenshell_wrapper.svg_loops_swiginit(self, _ifcopenshell_wrapper.new_svg_loops(*args))

    def push_back(self, x):
        r"""push_back(svg_loops self, svg_loop x)"""
        return _ifcopenshell_wrapper.svg_loops_push_back(self, x)

    def front(self):
        r"""front(svg_loops self) -> svg_loop"""
        return _ifcopenshell_wrapper.svg_loops_front(self)

    def back(self):
        r"""back(svg_loops self) -> svg_loop"""
        return _ifcopenshell_wrapper.svg_loops_back(self)

    def assign(self, n, x):
        r"""assign(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::size_type n, svg_loop x)"""
        return _ifcopenshell_wrapper.svg_loops_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::size_type new_size)
        resize(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::size_type new_size, svg_loop x)
        """
        return _ifcopenshell_wrapper.svg_loops_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::iterator pos, svg_loop x) -> std::vector< std::vector< std::array< double,2 > > >::iterator
        insert(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::iterator pos, std::vector< std::vector< std::array< double,2 > > >::size_type n, svg_loop x)
        """
        return _ifcopenshell_wrapper.svg_loops_insert(self, *args)

    def reserve(self, n):
        r"""reserve(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::size_type n)"""
        return _ifcopenshell_wrapper.svg_loops_reserve(self, n)

    def capacity(self):
        r"""capacity(svg_loops self) -> std::vector< std::vector< std::array< double,2 > > >::size_type"""
        return _ifcopenshell_wrapper.svg_loops_capacity(self)
    __swig_destroy__ = _ifcopenshell_wrapper.delete_svg_loops

# Register svg_loops in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.svg_loops_swigregister(svg_loops)

class OpaqueCoordinate_3(object):
    r"""Proxy of C++ IfcGeom::OpaqueCoordinate< 3 > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(OpaqueCoordinate_3 self) -> OpaqueCoordinate_3
        __init__(OpaqueCoordinate_3 self, OpaqueCoordinate_3 other) -> OpaqueCoordinate_3
        """
        _ifcopenshell_wrapper.OpaqueCoordinate_3_swiginit(self, _ifcopenshell_wrapper.new_OpaqueCoordinate_3(*args))
    __swig_destroy__ = _ifcopenshell_wrapper.delete_OpaqueCoordinate_3

    def get(self, i):
        r"""get(OpaqueCoordinate_3 self, size_t i) -> OpaqueNumber"""
        return _ifcopenshell_wrapper.OpaqueCoordinate_3_get(self, i)

    def set(self, i, n):
        r"""set(OpaqueCoordinate_3 self, size_t i, OpaqueNumber n)"""
        return _ifcopenshell_wrapper.OpaqueCoordinate_3_set(self, i, n)

# Register OpaqueCoordinate_3 in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.OpaqueCoordinate_3_swigregister(OpaqueCoordinate_3)

class OpaqueCoordinate_4(object):
    r"""Proxy of C++ IfcGeom::OpaqueCoordinate< 4 > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(OpaqueCoordinate_4 self) -> OpaqueCoordinate_4
        __init__(OpaqueCoordinate_4 self, OpaqueCoordinate_4 other) -> OpaqueCoordinate_4
        """
        _ifcopenshell_wrapper.OpaqueCoordinate_4_swiginit(self, _ifcopenshell_wrapper.new_OpaqueCoordinate_4(*args))
    __swig_destroy__ = _ifcopenshell_wrapper.delete_OpaqueCoordinate_4

    def get(self, i):
        r"""get(OpaqueCoordinate_4 self, size_t i) -> OpaqueNumber"""
        return _ifcopenshell_wrapper.OpaqueCoordinate_4_get(self, i)

    def set(self, i, n):
        r"""set(OpaqueCoordinate_4 self, size_t i, OpaqueNumber n)"""
        return _ifcopenshell_wrapper.OpaqueCoordinate_4_set(self, i, n)

# Register OpaqueCoordinate_4 in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.OpaqueCoordinate_4_swigregister(OpaqueCoordinate_4)


def create_epeck(*args):
    r"""
    create_epeck(int i) -> OpaqueNumber
    create_epeck(double d) -> OpaqueNumber
    create_epeck(std::string const & s) -> OpaqueNumber
    """
    return _ifcopenshell_wrapper.create_epeck(*args)

def nary_union(sequence):
    r"""nary_union(PyObject * sequence) -> ConversionResultShape"""
    return _ifcopenshell_wrapper.nary_union(sequence)
class polygon_2(object):
    r"""Proxy of C++ svgfill::polygon_2 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    boundary = property(_ifcopenshell_wrapper.polygon_2_boundary_get, _ifcopenshell_wrapper.polygon_2_boundary_set, doc=r"""boundary : svgfill::loop_2""")
    inner_boundaries = property(_ifcopenshell_wrapper.polygon_2_inner_boundaries_get, _ifcopenshell_wrapper.polygon_2_inner_boundaries_set, doc=r"""inner_boundaries : std::vector<(svgfill::loop_2,std::allocator<(svgfill::loop_2)>)>""")
    point_inside = property(_ifcopenshell_wrapper.polygon_2_point_inside_get, _ifcopenshell_wrapper.polygon_2_point_inside_set, doc=r"""point_inside : svgfill::point_2""")

    def __init__(self):
        r"""__init__(polygon_2 self) -> polygon_2"""
        _ifcopenshell_wrapper.polygon_2_swiginit(self, _ifcopenshell_wrapper.new_polygon_2())
    __swig_destroy__ = _ifcopenshell_wrapper.delete_polygon_2

# Register polygon_2 in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.polygon_2_swigregister(polygon_2)

CARTESIAN_DOUBLE = _ifcopenshell_wrapper.CARTESIAN_DOUBLE

CARTESIAN_QUOTIENT = _ifcopenshell_wrapper.CARTESIAN_QUOTIENT

FILTERED_CARTESIAN_QUOTIENT = _ifcopenshell_wrapper.FILTERED_CARTESIAN_QUOTIENT

EXACT_PREDICATES = _ifcopenshell_wrapper.EXACT_PREDICATES

EXACT_CONSTRUCTIONS = _ifcopenshell_wrapper.EXACT_CONSTRUCTIONS

class abstract_arrangement(object):
    r"""Proxy of C++ svgfill::abstract_arrangement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _ifcopenshell_wrapper.delete_abstract_arrangement

    def __call__(self, eps, segments, progress):
        r"""__call__(abstract_arrangement self, double eps, svg_line_segments segments, std::function< void (float) > & progress) -> bool"""
        return _ifcopenshell_wrapper.abstract_arrangement___call__(self, eps, segments, progress)

    def write(self, polygons, progress):
        r"""write(abstract_arrangement self, svg_polygons polygons, std::function< void (float) > & progress) -> bool"""
        return _ifcopenshell_wrapper.abstract_arrangement_write(self, polygons, progress)

    def merge(self, edge_indices):
        r"""merge(abstract_arrangement self, std::vector< int,std::allocator< int > > const & edge_indices)"""
        return _ifcopenshell_wrapper.abstract_arrangement_merge(self, edge_indices)

    def get_face_pairs(self):
        r"""get_face_pairs(abstract_arrangement self) -> std::vector< int,std::allocator< int > >"""
        return _ifcopenshell_wrapper.abstract_arrangement_get_face_pairs(self)

    def num_edges(self):
        r"""num_edges(abstract_arrangement self) -> size_t"""
        return _ifcopenshell_wrapper.abstract_arrangement_num_edges(self)

    def num_faces(self):
        r"""num_faces(abstract_arrangement self) -> size_t"""
        return _ifcopenshell_wrapper.abstract_arrangement_num_faces(self)

# Register abstract_arrangement in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.abstract_arrangement_swigregister(abstract_arrangement)

class context(object):
    r"""Proxy of C++ svgfill::context class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(context self, svgfill::solver s, double eps) -> context
        __init__(context self, svgfill::solver s, double eps, std::function< void (float) > & progress) -> context
        """
        _ifcopenshell_wrapper.context_swiginit(self, _ifcopenshell_wrapper.new_context(*args))

    def add(self, segments):
        r"""add(context self, svg_line_segments segments)"""
        return _ifcopenshell_wrapper.context_add(self, segments)

    def build(self):
        r"""build(context self) -> bool"""
        return _ifcopenshell_wrapper.context_build(self)

    def get_face_pairs(self):
        r"""get_face_pairs(context self) -> std::vector< int,std::allocator< int > >"""
        return _ifcopenshell_wrapper.context_get_face_pairs(self)

    def merge(self, edge_indices):
        r"""merge(context self, std::vector< int,std::allocator< int > > const & edge_indices)"""
        return _ifcopenshell_wrapper.context_merge(self, edge_indices)

    def write(self, arg2):
        r"""write(context self, svg_groups_of_polygons arg2)"""
        return _ifcopenshell_wrapper.context_write(self, arg2)

    def num_edges(self):
        r"""num_edges(context self) -> size_t"""
        return _ifcopenshell_wrapper.context_num_edges(self)

    def num_faces(self):
        r"""num_faces(context self) -> size_t"""
        return _ifcopenshell_wrapper.context_num_faces(self)
    __swig_destroy__ = _ifcopenshell_wrapper.delete_context

# Register context in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.context_swigregister(context)


def polygons_to_svg(*args):
    r"""
    polygons_to_svg(svg_groups_of_polygons polygons, bool random_color=False) -> std::string
    polygons_to_svg(svg_polygons polygons, bool random_color=False) -> std::string
    """
    return _ifcopenshell_wrapper.polygons_to_svg(*args)

def svg_to_line_segments(data, class_name):
    r"""svg_to_line_segments(std::string const & data, boost::optional< std::string > const & class_name) -> svg_groups_of_line_segments"""
    return _ifcopenshell_wrapper.svg_to_line_segments(data, class_name)

def line_segments_to_polygons(s, eps, segments):
    r"""line_segments_to_polygons(svgfill::solver s, double eps, svg_groups_of_line_segments segments) -> svg_groups_of_polygons"""
    return _ifcopenshell_wrapper.line_segments_to_polygons(s, eps, segments)

def svg_to_polygons(data, class_name):
    r"""svg_to_polygons(std::string const & data, boost::optional< std::string > const & class_name) -> svg_polygons"""
    return _ifcopenshell_wrapper.svg_to_polygons(data, class_name)

def arrange_polygons(polygons):
    r"""arrange_polygons(svg_polygons polygons) -> svg_polygons"""
    return _ifcopenshell_wrapper.arrange_polygons(polygons)
class IfcEntityInstanceData(object):
    r"""Proxy of C++ IfcEntityInstanceData class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _ifcopenshell_wrapper.delete_IfcEntityInstanceData

# Register IfcEntityInstanceData in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.IfcEntityInstanceData_swigregister(IfcEntityInstanceData)

class attribute_value_derived(object):
    r"""Proxy of C++ attribute_value_derived class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __bool__(self): return False
    def __repr__(self): return '*'


    def __init__(self):
        r"""__init__(attribute_value_derived self) -> attribute_value_derived"""
        _ifcopenshell_wrapper.attribute_value_derived_swiginit(self, _ifcopenshell_wrapper.new_attribute_value_derived())
    __swig_destroy__ = _ifcopenshell_wrapper.delete_attribute_value_derived

# Register attribute_value_derived in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.attribute_value_derived_swigregister(attribute_value_derived)


def set_feature(x, v):
    r"""set_feature(std::string const & x, PyObject * v)"""
    return _ifcopenshell_wrapper.set_feature(x, v)

def get_feature(x):
    r"""get_feature(std::string const & x) -> PyObject *"""
    return _ifcopenshell_wrapper.get_feature(x)
class IfcSpfHeader(object):
    r"""Proxy of C++ IfcParse::IfcSpfHeader class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(IfcSpfHeader self, file file=None) -> IfcSpfHeader
        __init__(IfcSpfHeader self, IfcParse::IfcSpfLexer * lexer) -> IfcSpfHeader
        """
        _ifcopenshell_wrapper.IfcSpfHeader_swiginit(self, _ifcopenshell_wrapper.new_IfcSpfHeader(*args))
    __swig_destroy__ = _ifcopenshell_wrapper.delete_IfcSpfHeader

    def file(self, *args):
        r"""
        file(IfcSpfHeader self) -> file
        file(IfcSpfHeader self, file file)
        """
        return _ifcopenshell_wrapper.IfcSpfHeader_file(self, *args)

    def read(self):
        r"""read(IfcSpfHeader self)"""
        return _ifcopenshell_wrapper.IfcSpfHeader_read(self)

    def tryRead(self):
        r"""tryRead(IfcSpfHeader self) -> bool"""
        return _ifcopenshell_wrapper.IfcSpfHeader_tryRead(self)

    def write(self, out):
        r"""write(IfcSpfHeader self, std::ostream & out)"""
        return _ifcopenshell_wrapper.IfcSpfHeader_write(self, out)

    def file_description_py(self):
        r"""file_description_py(IfcSpfHeader self) -> entity_instance"""
        return _ifcopenshell_wrapper.IfcSpfHeader_file_description_py(self)

    def file_name_py(self):
        r"""file_name_py(IfcSpfHeader self) -> entity_instance"""
        return _ifcopenshell_wrapper.IfcSpfHeader_file_name_py(self)

    def file_schema_py(self):
        r"""file_schema_py(IfcSpfHeader self) -> entity_instance"""
        return _ifcopenshell_wrapper.IfcSpfHeader_file_schema_py(self)

            # Hide the getters with read-only property implementations
    		# self.file_ref is set in ifcopenshell.file.header()
    file_description = property(lambda self: self.file_ref(self.file_description_py()))
    file_name = property(lambda self: self.file_ref(self.file_name_py()))
    file_schema = property(lambda self: self.file_ref(self.file_schema_py()))


# Register IfcSpfHeader in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.IfcSpfHeader_swigregister(IfcSpfHeader)
cvar = _ifcopenshell_wrapper.cvar

FT_IFCSPF = _ifcopenshell_wrapper.FT_IFCSPF

FT_IFCXML = _ifcopenshell_wrapper.FT_IFCXML

FT_IFCZIP = _ifcopenshell_wrapper.FT_IFCZIP

FT_ROCKSDB = _ifcopenshell_wrapper.FT_ROCKSDB

FT_UNKNOWN = _ifcopenshell_wrapper.FT_UNKNOWN

FT_AUTODETECT = _ifcopenshell_wrapper.FT_AUTODETECT


def guess_file_type(fn):
    r"""guess_file_type(std::string const & fn) -> IfcParse::filetype"""
    return _ifcopenshell_wrapper.guess_file_type(fn)
class InstanceStreamer(object):
    r"""Proxy of C++ IfcParse::InstanceStreamer class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    coerce_attribute_count = property(_ifcopenshell_wrapper.InstanceStreamer_coerce_attribute_count_get, _ifcopenshell_wrapper.InstanceStreamer_coerce_attribute_count_set, doc=r"""coerce_attribute_count : bool""")

    def __nonzero__(self):
        return _ifcopenshell_wrapper.InstanceStreamer___nonzero__(self)
    __bool__ = __nonzero__



    def status(self):
        r"""status(InstanceStreamer self) -> file_open_status"""
        return _ifcopenshell_wrapper.InstanceStreamer_status(self)

    def references(self, *args):
        r"""
        references(InstanceStreamer self) -> IfcParse::unresolved_references const
        references(InstanceStreamer self) -> IfcParse::unresolved_references &
        """
        return _ifcopenshell_wrapper.InstanceStreamer_references(self, *args)

    def inverses(self, *args):
        r"""
        inverses(InstanceStreamer self) -> IfcParse::impl::in_memory_file_storage::entities_by_ref_t const
        inverses(InstanceStreamer self) -> IfcParse::impl::in_memory_file_storage::entities_by_ref_t &
        """
        return _ifcopenshell_wrapper.InstanceStreamer_inverses(self, *args)

    def __init__(self, fn):
        r"""__init__(InstanceStreamer self, std::string const & fn) -> InstanceStreamer"""
        _ifcopenshell_wrapper.InstanceStreamer_swiginit(self, _ifcopenshell_wrapper.new_InstanceStreamer(fn))
    __swig_destroy__ = _ifcopenshell_wrapper.delete_InstanceStreamer

    def read_instance_py(self):
        r"""read_instance_py(InstanceStreamer self) -> PyObject *"""
        return _ifcopenshell_wrapper.InstanceStreamer_read_instance_py(self)

# Register InstanceStreamer in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.InstanceStreamer_swigregister(InstanceStreamer)

class file(object):
    r"""Proxy of C++ IfcParse::IfcFile class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    byguid_ = property(_ifcopenshell_wrapper.file_byguid__get, _ifcopenshell_wrapper.file_byguid__set, doc=r"""byguid_ : IfcParse::IfcFile::entity_instance_by_guid_t""")
    byid_ = property(_ifcopenshell_wrapper.file_byid__get, _ifcopenshell_wrapper.file_byid__set, doc=r"""byid_ : IfcParse::IfcFile::entity_by_id_t""")
    byref_excl_ = property(_ifcopenshell_wrapper.file_byref_excl__get, _ifcopenshell_wrapper.file_byref_excl__set, doc=r"""byref_excl_ : IfcParse::IfcFile::entities_by_ref_t""")
    check_existance_before_adding = property(_ifcopenshell_wrapper.file_check_existance_before_adding_get, _ifcopenshell_wrapper.file_check_existance_before_adding_set, doc=r"""check_existance_before_adding : bool""")
    calculate_unit_factors = property(_ifcopenshell_wrapper.file_calculate_unit_factors_get, _ifcopenshell_wrapper.file_calculate_unit_factors_set, doc=r"""calculate_unit_factors : bool""")
    instantiate_typed_instances = property(_ifcopenshell_wrapper.file_instantiate_typed_instances_get, _ifcopenshell_wrapper.file_instantiate_typed_instances_set, doc=r"""instantiate_typed_instances : bool""")

    def __init__(self, *args):
        r"""
        __init__(file self, std::string const & path, IfcParse::filetype ty=FT_AUTODETECT) -> file
        __init__(file self, std::istream & stream, int length) -> file
        __init__(file self, void * data, int length) -> file
        __init__(file self, IfcParse::IfcSpfStream * stream) -> file
        __init__(file self, schema_definition schema=IfcParse::schema_by_name("IFC4"), IfcParse::filetype ty=FT_AUTODETECT, std::string const & path="") -> file
        """
        _ifcopenshell_wrapper.file_swiginit(self, _ifcopenshell_wrapper.new_file(*args))
    __swig_destroy__ = _ifcopenshell_wrapper.delete_file

    def good(self):
        r"""good(file self) -> file_open_status"""
        return _ifcopenshell_wrapper.file_good(self)

    def by_type(self, *args):
        r"""
        by_type(file self, declaration arg2) -> aggregate_of_instance::ptr
        by_type(file self, std::string const & type) -> aggregate_of_instance::ptr
        """
        return _ifcopenshell_wrapper.file_by_type(self, *args)

    def by_type_excl_subtypes(self, *args):
        r"""
        by_type_excl_subtypes(file self, declaration arg2) -> aggregate_of_instance::ptr
        by_type_excl_subtypes(file self, std::string const & type) -> aggregate_of_instance::ptr
        """
        return _ifcopenshell_wrapper.file_by_type_excl_subtypes(self, *args)

    def by_id(self, id):
        r"""by_id(file self, int id) -> entity_instance"""
        return _ifcopenshell_wrapper.file_by_id(self, id)

    def by_guid(self, guid):
        r"""by_guid(file self, std::string const & guid) -> entity_instance"""
        return _ifcopenshell_wrapper.file_by_guid(self, guid)

    @staticmethod
    def traverse(instance, max_level=-1):
        r"""traverse(entity_instance instance, int max_level=-1) -> aggregate_of_instance::ptr"""
        return _ifcopenshell_wrapper.file_traverse(instance, max_level)

    @staticmethod
    def traverse_breadth_first(instance, max_level=-1):
        r"""traverse_breadth_first(entity_instance instance, int max_level=-1) -> aggregate_of_instance::ptr"""
        return _ifcopenshell_wrapper.file_traverse_breadth_first(instance, max_level)

    def get_inverses_by_declaration(self, instance_id, type, attribute_index):
        r"""get_inverses_by_declaration(file self, int instance_id, declaration type, int attribute_index) -> aggregate_of_instance::ptr"""
        return _ifcopenshell_wrapper.file_get_inverses_by_declaration(self, instance_id, type, attribute_index)

    def get_total_inverses_by_id(self, instance_id):
        r"""get_total_inverses_by_id(file self, int instance_id) -> size_t"""
        return _ifcopenshell_wrapper.file_get_total_inverses_by_id(self, instance_id)

    def FreshId(self):
        r"""FreshId(file self) -> unsigned int"""
        return _ifcopenshell_wrapper.file_FreshId(self)

    def getMaxId(self):
        r"""getMaxId(file self) -> unsigned int"""
        return _ifcopenshell_wrapper.file_getMaxId(self)

    def ifcroot_type(self):
        r"""ifcroot_type(file self) -> declaration"""
        return _ifcopenshell_wrapper.file_ifcroot_type(self)

    def recalculate_id_counter(self):
        r"""recalculate_id_counter(file self)"""
        return _ifcopenshell_wrapper.file_recalculate_id_counter(self)

    def add(self, entity, id=-1):
        r"""add(file self, entity_instance entity, int id=-1) -> entity_instance"""
        return _ifcopenshell_wrapper.file_add(self, entity, id)

    def addEntities(self, entities):
        r"""addEntities(file self, aggregate_of_instance::ptr entities)"""
        return _ifcopenshell_wrapper.file_addEntities(self, entities)

    def remove(self, entity):
        r"""remove(file self, entity_instance entity)"""
        return _ifcopenshell_wrapper.file_remove(self, entity)

    def header(self, *args):
        r"""
        header(file self) -> IfcSpfHeader
        header(file self) -> IfcSpfHeader
        """
        return _ifcopenshell_wrapper.file_header(self, *args)

    @staticmethod
    def createTimestamp():
        r"""createTimestamp() -> std::string"""
        return _ifcopenshell_wrapper.file_createTimestamp()

    def getUnit(self, unit_type):
        r"""getUnit(file self, std::string const & unit_type) -> std::pair< IfcUtil::IfcBaseClass *,double >"""
        return _ifcopenshell_wrapper.file_getUnit(self, unit_type)

    def build_inverses(self):
        r"""build_inverses(file self)"""
        return _ifcopenshell_wrapper.file_build_inverses(self)

    def add_type_ref(self, new_entity):
        r"""add_type_ref(file self, entity_instance new_entity)"""
        return _ifcopenshell_wrapper.file_add_type_ref(self, new_entity)

    def remove_type_ref(self, new_entity):
        r"""remove_type_ref(file self, entity_instance new_entity)"""
        return _ifcopenshell_wrapper.file_remove_type_ref(self, new_entity)

    def process_deletion_inverse(self, inst):
        r"""process_deletion_inverse(file self, entity_instance inst)"""
        return _ifcopenshell_wrapper.file_process_deletion_inverse(self, inst)

    def build_inverses_(self, arg2):
        r"""build_inverses_(file self, entity_instance arg2)"""
        return _ifcopenshell_wrapper.file_build_inverses_(self, arg2)

    def create(self, decl):
        r"""create(file self, declaration decl) -> entity_instance"""
        return _ifcopenshell_wrapper.file_create(self, decl)

    def file_pointer(self):
        r"""file_pointer(file self) -> size_t"""
        return _ifcopenshell_wrapper.file_file_pointer(self)

    def get_inverse(self, e):
        r"""get_inverse(file self, entity_instance e) -> aggregate_of_instance::ptr"""
        return _ifcopenshell_wrapper.file_get_inverse(self, e)

    def get_inverse_indices(self, *args):
        r"""
        get_inverse_indices(file self, int instance_id) -> std::vector< int,std::allocator< int > >
        get_inverse_indices(file self, entity_instance e) -> std::vector< int,std::allocator< int > >
        """
        return _ifcopenshell_wrapper.file_get_inverse_indices(self, *args)

    def get_total_inverses(self, e):
        r"""get_total_inverses(file self, entity_instance e) -> int"""
        return _ifcopenshell_wrapper.file_get_total_inverses(self, e)

    def write(self, fn):
        r"""write(file self, std::string const & fn)"""
        return _ifcopenshell_wrapper.file_write(self, fn)

    def to_string(self):
        r"""to_string(file self) -> std::string"""
        return _ifcopenshell_wrapper.file_to_string(self)

    def entity_names(self):
        r"""entity_names(file self) -> std::vector< unsigned int,std::allocator< unsigned int > >"""
        return _ifcopenshell_wrapper.file_entity_names(self)

    def types(self):
        r"""types(file self) -> std::vector< std::string,std::allocator< std::string > >"""
        return _ifcopenshell_wrapper.file_types(self)

    def schema_name(self):
        r"""schema_name(file self) -> std::string"""
        return _ifcopenshell_wrapper.file_schema_name(self)

    def key_value_store_query(self, key):
        r"""key_value_store_query(file self, std::string const & key) -> PyObject *"""
        return _ifcopenshell_wrapper.file_key_value_store_query(self, key)

    schema = property(schema_name)


# Register file in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.file_swigregister(file)

def file_traverse(instance, max_level=-1):
    r"""file_traverse(entity_instance instance, int max_level=-1) -> aggregate_of_instance::ptr"""
    return _ifcopenshell_wrapper.file_traverse(instance, max_level)

def file_traverse_breadth_first(instance, max_level=-1):
    r"""file_traverse_breadth_first(entity_instance instance, int max_level=-1) -> aggregate_of_instance::ptr"""
    return _ifcopenshell_wrapper.file_traverse_breadth_first(instance, max_level)

def file_createTimestamp():
    r"""file_createTimestamp() -> std::string"""
    return _ifcopenshell_wrapper.file_createTimestamp()


def parse_ifcxml(filename):
    r"""parse_ifcxml(std::string const & filename) -> file"""
    return _ifcopenshell_wrapper.parse_ifcxml(filename)
class file_open_status(object):
    r"""Proxy of C++ IfcParse::file_open_status class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    SUCCESS = _ifcopenshell_wrapper.file_open_status_SUCCESS
    
    READ_ERROR = _ifcopenshell_wrapper.file_open_status_READ_ERROR
    
    NO_HEADER = _ifcopenshell_wrapper.file_open_status_NO_HEADER
    
    UNSUPPORTED_SCHEMA = _ifcopenshell_wrapper.file_open_status_UNSUPPORTED_SCHEMA
    
    INVALID_SYNTAX = _ifcopenshell_wrapper.file_open_status_INVALID_SYNTAX
    
    UNKNOWN = _ifcopenshell_wrapper.file_open_status_UNKNOWN
    

    def __init__(self, *args):
        r"""__init__(file_open_status self, IfcParse::file_open_status::file_open_enum error=UNKNOWN) -> file_open_status"""
        _ifcopenshell_wrapper.file_open_status_swiginit(self, _ifcopenshell_wrapper.new_file_open_status(*args))

    def value(self):
        r"""value(file_open_status self) -> IfcParse::file_open_status::file_open_enum"""
        return _ifcopenshell_wrapper.file_open_status_value(self)

    def __nonzero__(self):
        return _ifcopenshell_wrapper.file_open_status___nonzero__(self)
    __bool__ = __nonzero__


    __swig_destroy__ = _ifcopenshell_wrapper.delete_file_open_status

# Register file_open_status in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.file_open_status_swigregister(file_open_status)

class entity_instance(object):
    r"""Proxy of C++ IfcUtil::IfcBaseClass class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    id_ = property(_ifcopenshell_wrapper.entity_instance_id__get, _ifcopenshell_wrapper.entity_instance_id__set, doc=r"""id_ : uint32_t""")
    file_ = property(_ifcopenshell_wrapper.entity_instance_file__get, _ifcopenshell_wrapper.entity_instance_file__set, doc=r"""file_ : p.IfcParse::IfcFile""")

    def data(self, *args):
        r"""
        data(entity_instance self) -> IfcEntityInstanceData
        data(entity_instance self) -> IfcEntityInstanceData
        """
        return _ifcopenshell_wrapper.entity_instance_data(self, *args)

    def declaration(self):
        r"""declaration(entity_instance self) -> declaration"""
        return _ifcopenshell_wrapper.entity_instance_declaration(self)

    def set_attribute_value(self, *args):
        r"""
        set_attribute_value(entity_instance self, size_t i, entity_instance p)
        set_attribute_value(entity_instance self, std::string const & name, entity_instance p)
        """
        return _ifcopenshell_wrapper.entity_instance_set_attribute_value(self, *args)

    def unset_attribute_value(self, i):
        r"""unset_attribute_value(entity_instance self, size_t i)"""
        return _ifcopenshell_wrapper.entity_instance_unset_attribute_value(self, i)

    def get_attribute_value(self, index):
        r"""get_attribute_value(entity_instance self, size_t index) -> AttributeValue"""
        return _ifcopenshell_wrapper.entity_instance_get_attribute_value(self, index)

    def identity(self):
        r"""identity(entity_instance self) -> uint32_t"""
        return _ifcopenshell_wrapper.entity_instance_identity(self)

    def toString(self, arg2, upper=False):
        r"""toString(entity_instance self, std::ostream & arg2, bool upper=False)"""
        return _ifcopenshell_wrapper.entity_instance_toString(self, arg2, upper)

    		# Will be assigned when `ifcopenshell.entity_instance` is created.
    file = None


    def get_attribute_category(self, name):
        r"""get_attribute_category(entity_instance self, std::string const & name) -> int"""
        return _ifcopenshell_wrapper.entity_instance_get_attribute_category(self, name)

    def id(self):
        r"""id(entity_instance self) -> int"""
        return _ifcopenshell_wrapper.entity_instance_id(self)

    def __len__(self):
        r"""__len__(entity_instance self) -> int"""
        return _ifcopenshell_wrapper.entity_instance___len__(self)

    def get_attribute_names(self):
        r"""get_attribute_names(entity_instance self) -> std::vector< std::string,std::allocator< std::string > >"""
        return _ifcopenshell_wrapper.entity_instance_get_attribute_names(self)

    def get_inverse_attribute_names(self):
        r"""get_inverse_attribute_names(entity_instance self) -> std::vector< std::string,std::allocator< std::string > >"""
        return _ifcopenshell_wrapper.entity_instance_get_inverse_attribute_names(self)

    def is_a(self, *args):
        r"""
        is_a(entity_instance self, std::string const & s) -> bool
        is_a(entity_instance self, bool with_schema=False) -> std::string
        """
        return _ifcopenshell_wrapper.entity_instance_is_a(self, *args)

    def get_argument(self, *args):
        r"""
        get_argument(entity_instance self, unsigned int i) -> AttributeValue
        get_argument(entity_instance self, std::string const & a) -> AttributeValue
        """
        return _ifcopenshell_wrapper.entity_instance_get_argument(self, *args)

    def __eq__(self, other):
        r"""__eq__(entity_instance self, entity_instance other) -> bool"""
        return _ifcopenshell_wrapper.entity_instance___eq__(self, other)

    def __repr__(self):
        r"""__repr__(entity_instance self) -> std::string"""
        return _ifcopenshell_wrapper.entity_instance___repr__(self)

    def to_string(self, valid_spf=True):
        r"""to_string(entity_instance self, bool valid_spf=True) -> std::string"""
        return _ifcopenshell_wrapper.entity_instance_to_string(self, valid_spf)

    def file_pointer(self):
        r"""file_pointer(entity_instance self) -> size_t"""
        return _ifcopenshell_wrapper.entity_instance_file_pointer(self)

    def get_argument_index(self, a):
        r"""get_argument_index(entity_instance self, std::string const & a) -> unsigned int"""
        return _ifcopenshell_wrapper.entity_instance_get_argument_index(self, a)

    def get_inverse(self, a):
        r"""get_inverse(entity_instance self, std::string const & a) -> aggregate_of_instance::ptr"""
        return _ifcopenshell_wrapper.entity_instance_get_inverse(self, a)

    def get_argument_type(self, i):
        r"""get_argument_type(entity_instance self, unsigned int i) -> char const *const"""
        return _ifcopenshell_wrapper.entity_instance_get_argument_type(self, i)

    def get_argument_name(self, i):
        r"""get_argument_name(entity_instance self, unsigned int i) -> std::string const &"""
        return _ifcopenshell_wrapper.entity_instance_get_argument_name(self, i)

    def setArgumentAsNull(self, i):
        r"""setArgumentAsNull(entity_instance self, unsigned int i)"""
        return _ifcopenshell_wrapper.entity_instance_setArgumentAsNull(self, i)

    def setArgumentAsInt(self, i, v):
        r"""setArgumentAsInt(entity_instance self, unsigned int i, int v)"""
        return _ifcopenshell_wrapper.entity_instance_setArgumentAsInt(self, i, v)

    def setArgumentAsBool(self, i, v):
        r"""setArgumentAsBool(entity_instance self, unsigned int i, bool v)"""
        return _ifcopenshell_wrapper.entity_instance_setArgumentAsBool(self, i, v)

    def setArgumentAsLogical(self, i, v):
        r"""setArgumentAsLogical(entity_instance self, unsigned int i, boost::logic::tribool v)"""
        return _ifcopenshell_wrapper.entity_instance_setArgumentAsLogical(self, i, v)

    def setArgumentAsDouble(self, i, v):
        r"""setArgumentAsDouble(entity_instance self, unsigned int i, double v)"""
        return _ifcopenshell_wrapper.entity_instance_setArgumentAsDouble(self, i, v)

    def setArgumentAsString(self, i, a):
        r"""setArgumentAsString(entity_instance self, unsigned int i, std::string const & a)"""
        return _ifcopenshell_wrapper.entity_instance_setArgumentAsString(self, i, a)

    def setArgumentAsAggregateOfInt(self, i, v):
        r"""setArgumentAsAggregateOfInt(entity_instance self, unsigned int i, std::vector< int,std::allocator< int > > const & v)"""
        return _ifcopenshell_wrapper.entity_instance_setArgumentAsAggregateOfInt(self, i, v)

    def setArgumentAsAggregateOfDouble(self, i, v):
        r"""setArgumentAsAggregateOfDouble(entity_instance self, unsigned int i, std::vector< double,std::allocator< double > > const & v)"""
        return _ifcopenshell_wrapper.entity_instance_setArgumentAsAggregateOfDouble(self, i, v)

    def setArgumentAsAggregateOfString(self, i, v):
        r"""setArgumentAsAggregateOfString(entity_instance self, unsigned int i, std::vector< std::string,std::allocator< std::string > > const & v)"""
        return _ifcopenshell_wrapper.entity_instance_setArgumentAsAggregateOfString(self, i, v)

    def setArgumentAsEntityInstance(self, i, v):
        r"""setArgumentAsEntityInstance(entity_instance self, unsigned int i, entity_instance v)"""
        return _ifcopenshell_wrapper.entity_instance_setArgumentAsEntityInstance(self, i, v)

    def setArgumentAsAggregateOfEntityInstance(self, i, v):
        r"""setArgumentAsAggregateOfEntityInstance(entity_instance self, unsigned int i, aggregate_of_instance::ptr v)"""
        return _ifcopenshell_wrapper.entity_instance_setArgumentAsAggregateOfEntityInstance(self, i, v)

    def setArgumentAsAggregateOfAggregateOfInt(self, i, v):
        r"""setArgumentAsAggregateOfAggregateOfInt(entity_instance self, unsigned int i, std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const & v)"""
        return _ifcopenshell_wrapper.entity_instance_setArgumentAsAggregateOfAggregateOfInt(self, i, v)

    def setArgumentAsAggregateOfAggregateOfDouble(self, i, v):
        r"""setArgumentAsAggregateOfAggregateOfDouble(entity_instance self, unsigned int i, std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const & v)"""
        return _ifcopenshell_wrapper.entity_instance_setArgumentAsAggregateOfAggregateOfDouble(self, i, v)

    def setArgumentAsAggregateOfAggregateOfEntityInstance(self, i, v):
        r"""setArgumentAsAggregateOfAggregateOfEntityInstance(entity_instance self, unsigned int i, aggregate_of_aggregate_of_instance::ptr v)"""
        return _ifcopenshell_wrapper.entity_instance_setArgumentAsAggregateOfAggregateOfEntityInstance(self, i, v)
    __swig_destroy__ = _ifcopenshell_wrapper.delete_entity_instance

# Register entity_instance in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.entity_instance_swigregister(entity_instance)

class IfcBaseEntity(entity_instance):
    r"""Proxy of C++ IfcUtil::IfcBaseEntity class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def declaration(self):
        r"""declaration(IfcBaseEntity self) -> declaration"""
        return _ifcopenshell_wrapper.IfcBaseEntity_declaration(self)

    def get(self, name):
        r"""get(IfcBaseEntity self, std::string const & name) -> AttributeValue"""
        return _ifcopenshell_wrapper.IfcBaseEntity_get(self, name)

    def get_inverse(self, name):
        r"""get_inverse(IfcBaseEntity self, std::string const & name) -> boost::shared_ptr< aggregate_of_instance >"""
        return _ifcopenshell_wrapper.IfcBaseEntity_get_inverse(self, name)

    def set_id(self, i):
        r"""set_id(IfcBaseEntity self, boost::optional< unsigned int > const & i) -> unsigned int"""
        return _ifcopenshell_wrapper.IfcBaseEntity_set_id(self, i)

    def populate_derived(self):
        r"""populate_derived(IfcBaseEntity self)"""
        return _ifcopenshell_wrapper.IfcBaseEntity_populate_derived(self)
    __swig_destroy__ = _ifcopenshell_wrapper.delete_IfcBaseEntity

# Register IfcBaseEntity in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.IfcBaseEntity_swigregister(IfcBaseEntity)

class IfcLateBoundEntity(IfcBaseEntity):
    r"""Proxy of C++ IfcUtil::IfcLateBoundEntity class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, decl, data):
        r"""__init__(IfcLateBoundEntity self, declaration decl, IfcEntityInstanceData data) -> IfcLateBoundEntity"""
        _ifcopenshell_wrapper.IfcLateBoundEntity_swiginit(self, _ifcopenshell_wrapper.new_IfcLateBoundEntity(decl, data))

    def declaration(self):
        r"""declaration(IfcLateBoundEntity self) -> declaration"""
        return _ifcopenshell_wrapper.IfcLateBoundEntity_declaration(self)
    __swig_destroy__ = _ifcopenshell_wrapper.delete_IfcLateBoundEntity

# Register IfcLateBoundEntity in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.IfcLateBoundEntity_swigregister(IfcLateBoundEntity)

class IfcBaseType(entity_instance):
    r"""Proxy of C++ IfcUtil::IfcBaseType class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def declaration(self):
        r"""declaration(IfcBaseType self) -> declaration"""
        return _ifcopenshell_wrapper.IfcBaseType_declaration(self)
    __swig_destroy__ = _ifcopenshell_wrapper.delete_IfcBaseType

# Register IfcBaseType in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.IfcBaseType_swigregister(IfcBaseType)

class parameter_type(object):
    r"""Proxy of C++ IfcParse::parameter_type class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _ifcopenshell_wrapper.delete_parameter_type

    def as_named_type(self):
        r"""as_named_type(parameter_type self) -> named_type"""
        return _ifcopenshell_wrapper.parameter_type_as_named_type(self)

    def as_simple_type(self):
        r"""as_simple_type(parameter_type self) -> simple_type"""
        return _ifcopenshell_wrapper.parameter_type_as_simple_type(self)

    def as_aggregation_type(self):
        r"""as_aggregation_type(parameter_type self) -> aggregation_type"""
        return _ifcopenshell_wrapper.parameter_type_as_aggregation_type(self)

    def _is(self, *args):
        r"""
        _is(parameter_type self, std::string const & arg2) -> bool
        _is(parameter_type self, declaration arg2) -> bool
        """
        return _ifcopenshell_wrapper.parameter_type__is(self, *args)

    def __init__(self):
        r"""__init__(parameter_type self) -> parameter_type"""
        _ifcopenshell_wrapper.parameter_type_swiginit(self, _ifcopenshell_wrapper.new_parameter_type())

# Register parameter_type in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.parameter_type_swigregister(parameter_type)

class named_type(parameter_type):
    r"""Proxy of C++ IfcParse::named_type class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, declared_type):
        r"""__init__(named_type self, declaration declared_type) -> named_type"""
        _ifcopenshell_wrapper.named_type_swiginit(self, _ifcopenshell_wrapper.new_named_type(declared_type))

    def declared_type(self):
        r"""declared_type(named_type self) -> declaration"""
        return _ifcopenshell_wrapper.named_type_declared_type(self)

    def as_named_type(self):
        r"""as_named_type(named_type self) -> named_type"""
        return _ifcopenshell_wrapper.named_type_as_named_type(self)

    def _is(self, *args):
        r"""
        _is(named_type self, std::string const & name) -> bool
        _is(named_type self, declaration decl) -> bool
        """
        return _ifcopenshell_wrapper.named_type__is(self, *args)

    def __repr__(self):
    	return repr(self.declared_type())

    __swig_destroy__ = _ifcopenshell_wrapper.delete_named_type

# Register named_type in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.named_type_swigregister(named_type)

class simple_type(parameter_type):
    r"""Proxy of C++ IfcParse::simple_type class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    binary_type = _ifcopenshell_wrapper.simple_type_binary_type
    
    boolean_type = _ifcopenshell_wrapper.simple_type_boolean_type
    
    integer_type = _ifcopenshell_wrapper.simple_type_integer_type
    
    logical_type = _ifcopenshell_wrapper.simple_type_logical_type
    
    number_type = _ifcopenshell_wrapper.simple_type_number_type
    
    real_type = _ifcopenshell_wrapper.simple_type_real_type
    
    string_type = _ifcopenshell_wrapper.simple_type_string_type
    
    datatype_COUNT = _ifcopenshell_wrapper.simple_type_datatype_COUNT
    

    def __init__(self, declared_type):
        r"""__init__(simple_type self, IfcParse::simple_type::data_type declared_type) -> simple_type"""
        _ifcopenshell_wrapper.simple_type_swiginit(self, _ifcopenshell_wrapper.new_simple_type(declared_type))

    def declared_type(self):
        r"""declared_type(simple_type self) -> IfcParse::simple_type::data_type"""
        return _ifcopenshell_wrapper.simple_type_declared_type(self)

    def as_simple_type(self):
        r"""as_simple_type(simple_type self) -> simple_type"""
        return _ifcopenshell_wrapper.simple_type_as_simple_type(self)

    def __repr__(self):
    	return "<%s>" % self.declared_type()

    __swig_destroy__ = _ifcopenshell_wrapper.delete_simple_type

# Register simple_type in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.simple_type_swigregister(simple_type)

class aggregation_type(parameter_type):
    r"""Proxy of C++ IfcParse::aggregation_type class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    array_type = _ifcopenshell_wrapper.aggregation_type_array_type
    
    bag_type = _ifcopenshell_wrapper.aggregation_type_bag_type
    
    list_type = _ifcopenshell_wrapper.aggregation_type_list_type
    
    set_type = _ifcopenshell_wrapper.aggregation_type_set_type
    

    def __init__(self, type_of_aggregation, bound1, bound2, type_of_element):
        r"""__init__(aggregation_type self, IfcParse::aggregation_type::aggregate_type type_of_aggregation, int bound1, int bound2, parameter_type type_of_element) -> aggregation_type"""
        _ifcopenshell_wrapper.aggregation_type_swiginit(self, _ifcopenshell_wrapper.new_aggregation_type(type_of_aggregation, bound1, bound2, type_of_element))
    __swig_destroy__ = _ifcopenshell_wrapper.delete_aggregation_type

    def type_of_aggregation(self):
        r"""type_of_aggregation(aggregation_type self) -> IfcParse::aggregation_type::aggregate_type"""
        return _ifcopenshell_wrapper.aggregation_type_type_of_aggregation(self)

    def bound1(self):
        r"""bound1(aggregation_type self) -> int"""
        return _ifcopenshell_wrapper.aggregation_type_bound1(self)

    def bound2(self):
        r"""bound2(aggregation_type self) -> int"""
        return _ifcopenshell_wrapper.aggregation_type_bound2(self)

    def type_of_element(self):
        r"""type_of_element(aggregation_type self) -> parameter_type"""
        return _ifcopenshell_wrapper.aggregation_type_type_of_element(self)

    def as_aggregation_type(self):
        r"""as_aggregation_type(aggregation_type self) -> aggregation_type"""
        return _ifcopenshell_wrapper.aggregation_type_as_aggregation_type(self)

    def type_of_aggregation_string(self):
        r"""type_of_aggregation_string(aggregation_type self) -> std::string"""
        return _ifcopenshell_wrapper.aggregation_type_type_of_aggregation_string(self)

    def __repr__(self):
    	format_bound = lambda i: "?" if i == -1 else str(i)
    	return "<%s [%s:%s] of %r>" % (
    		self.type_of_aggregation_string(),
    		format_bound(self.bound1()),
    		format_bound(self.bound2()),
    		self.type_of_element()
    	)


# Register aggregation_type in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.aggregation_type_swigregister(aggregation_type)

class declaration(object):
    r"""Proxy of C++ IfcParse::declaration class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, name, index_in_schema):
        r"""__init__(declaration self, std::string const & name, int index_in_schema) -> declaration"""
        _ifcopenshell_wrapper.declaration_swiginit(self, _ifcopenshell_wrapper.new_declaration(name, index_in_schema))
    __swig_destroy__ = _ifcopenshell_wrapper.delete_declaration

    def name(self):
        r"""name(declaration self) -> std::string const &"""
        return _ifcopenshell_wrapper.declaration_name(self)

    def name_uc(self):
        r"""name_uc(declaration self) -> std::string const &"""
        return _ifcopenshell_wrapper.declaration_name_uc(self)

    def as_type_declaration(self):
        r"""as_type_declaration(declaration self) -> type_declaration"""
        return _ifcopenshell_wrapper.declaration_as_type_declaration(self)

    def as_select_type(self):
        r"""as_select_type(declaration self) -> select_type"""
        return _ifcopenshell_wrapper.declaration_as_select_type(self)

    def as_enumeration_type(self):
        r"""as_enumeration_type(declaration self) -> enumeration_type"""
        return _ifcopenshell_wrapper.declaration_as_enumeration_type(self)

    def as_entity(self):
        r"""as_entity(declaration self) -> entity"""
        return _ifcopenshell_wrapper.declaration_as_entity(self)

    def _is(self, *args):
        r"""
        _is(declaration self, std::string const & name) -> bool
        _is(declaration self, declaration decl) -> bool
        """
        return _ifcopenshell_wrapper.declaration__is(self, *args)

    def index_in_schema(self):
        r"""index_in_schema(declaration self) -> int"""
        return _ifcopenshell_wrapper.declaration_index_in_schema(self)

    def type(self):
        r"""type(declaration self) -> int"""
        return _ifcopenshell_wrapper.declaration_type(self)

    def schema(self):
        r"""schema(declaration self) -> schema_definition"""
        return _ifcopenshell_wrapper.declaration_schema(self)

# Register declaration in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.declaration_swigregister(declaration)

class type_declaration(declaration):
    r"""Proxy of C++ IfcParse::type_declaration class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, name, index_in_schema, declared_type):
        r"""__init__(type_declaration self, std::string const & name, int index_in_schema, parameter_type declared_type) -> type_declaration"""
        _ifcopenshell_wrapper.type_declaration_swiginit(self, _ifcopenshell_wrapper.new_type_declaration(name, index_in_schema, declared_type))
    __swig_destroy__ = _ifcopenshell_wrapper.delete_type_declaration

    def declared_type(self):
        r"""declared_type(type_declaration self) -> parameter_type"""
        return _ifcopenshell_wrapper.type_declaration_declared_type(self)

    def as_type_declaration(self):
        r"""as_type_declaration(type_declaration self) -> type_declaration"""
        return _ifcopenshell_wrapper.type_declaration_as_type_declaration(self)

    def __repr__(self):
    	return "<type %s: %r>" % (self.name(), self.declared_type())


    def argument_types(self):
        r"""argument_types(type_declaration self) -> std::vector< std::string,std::allocator< std::string > >"""
        return _ifcopenshell_wrapper.type_declaration_argument_types(self)

# Register type_declaration in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.type_declaration_swigregister(type_declaration)

class select_type(declaration):
    r"""Proxy of C++ IfcParse::select_type class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, name, index_in_schema, select_list):
        r"""__init__(select_type self, std::string const & name, int index_in_schema, std::vector< IfcParse::declaration const *,std::allocator< IfcParse::declaration const * > > const & select_list) -> select_type"""
        _ifcopenshell_wrapper.select_type_swiginit(self, _ifcopenshell_wrapper.new_select_type(name, index_in_schema, select_list))

    def select_list(self):
        r"""select_list(select_type self) -> std::vector< IfcParse::declaration const *,std::allocator< IfcParse::declaration const * > > const &"""
        return _ifcopenshell_wrapper.select_type_select_list(self)

    def as_select_type(self):
        r"""as_select_type(select_type self) -> select_type"""
        return _ifcopenshell_wrapper.select_type_as_select_type(self)

    def __repr__(self):
    	return "<select %s: (%s)>" % (self.name(), " | ".join(map(repr, self.select_list())))

    __swig_destroy__ = _ifcopenshell_wrapper.delete_select_type

# Register select_type in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.select_type_swigregister(select_type)

class enumeration_type(declaration):
    r"""Proxy of C++ IfcParse::enumeration_type class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, name, index_in_schema, enumeration_items):
        r"""__init__(enumeration_type self, std::string const & name, int index_in_schema, std::vector< std::string,std::allocator< std::string > > const & enumeration_items) -> enumeration_type"""
        _ifcopenshell_wrapper.enumeration_type_swiginit(self, _ifcopenshell_wrapper.new_enumeration_type(name, index_in_schema, enumeration_items))

    def enumeration_items(self):
        r"""enumeration_items(enumeration_type self) -> std::vector< std::string,std::allocator< std::string > > const &"""
        return _ifcopenshell_wrapper.enumeration_type_enumeration_items(self)

    def lookup_enum_value(self, i):
        r"""lookup_enum_value(enumeration_type self, size_t i) -> char const *"""
        return _ifcopenshell_wrapper.enumeration_type_lookup_enum_value(self, i)

    def lookup_enum_offset(self, string):
        r"""lookup_enum_offset(enumeration_type self, std::string const & string) -> size_t"""
        return _ifcopenshell_wrapper.enumeration_type_lookup_enum_offset(self, string)

    def as_enumeration_type(self):
        r"""as_enumeration_type(enumeration_type self) -> enumeration_type"""
        return _ifcopenshell_wrapper.enumeration_type_as_enumeration_type(self)

    def __repr__(self):
    	return "<enumeration %s: (%s)>" % (self.name(), ", ".join(self.enumeration_items()))


    def argument_types(self):
        r"""argument_types(enumeration_type self) -> std::vector< std::string,std::allocator< std::string > >"""
        return _ifcopenshell_wrapper.enumeration_type_argument_types(self)
    __swig_destroy__ = _ifcopenshell_wrapper.delete_enumeration_type

# Register enumeration_type in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.enumeration_type_swigregister(enumeration_type)

class attribute(object):
    r"""Proxy of C++ IfcParse::attribute class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, name, type_of_attribute, optional):
        r"""__init__(attribute self, std::string const & name, parameter_type type_of_attribute, bool optional) -> attribute"""
        _ifcopenshell_wrapper.attribute_swiginit(self, _ifcopenshell_wrapper.new_attribute(name, type_of_attribute, optional))
    __swig_destroy__ = _ifcopenshell_wrapper.delete_attribute

    def name(self):
        r"""name(attribute self) -> std::string const &"""
        return _ifcopenshell_wrapper.attribute_name(self)

    def type_of_attribute(self):
        r"""type_of_attribute(attribute self) -> parameter_type"""
        return _ifcopenshell_wrapper.attribute_type_of_attribute(self)

    def optional(self):
        r"""optional(attribute self) -> bool"""
        return _ifcopenshell_wrapper.attribute_optional(self)

    def __repr__(self):
    	return "<attribute %s%s: %s>" % (self.name(), "?" if self.optional() else "", self.type_of_attribute())


# Register attribute in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.attribute_swigregister(attribute)

class inverse_attribute(object):
    r"""Proxy of C++ IfcParse::inverse_attribute class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    bag_type = _ifcopenshell_wrapper.inverse_attribute_bag_type
    
    set_type = _ifcopenshell_wrapper.inverse_attribute_set_type
    
    unspecified_type = _ifcopenshell_wrapper.inverse_attribute_unspecified_type
    

    def __init__(self, name, type_of_aggregation, bound1, bound2, entity_reference, attribute_reference):
        r"""__init__(inverse_attribute self, std::string const & name, IfcParse::inverse_attribute::aggregate_type type_of_aggregation, int bound1, int bound2, entity entity_reference, attribute attribute_reference) -> inverse_attribute"""
        _ifcopenshell_wrapper.inverse_attribute_swiginit(self, _ifcopenshell_wrapper.new_inverse_attribute(name, type_of_aggregation, bound1, bound2, entity_reference, attribute_reference))

    def name(self):
        r"""name(inverse_attribute self) -> std::string const &"""
        return _ifcopenshell_wrapper.inverse_attribute_name(self)

    def type_of_aggregation(self):
        r"""type_of_aggregation(inverse_attribute self) -> IfcParse::inverse_attribute::aggregate_type"""
        return _ifcopenshell_wrapper.inverse_attribute_type_of_aggregation(self)

    def bound1(self):
        r"""bound1(inverse_attribute self) -> int"""
        return _ifcopenshell_wrapper.inverse_attribute_bound1(self)

    def bound2(self):
        r"""bound2(inverse_attribute self) -> int"""
        return _ifcopenshell_wrapper.inverse_attribute_bound2(self)

    def entity_reference(self):
        r"""entity_reference(inverse_attribute self) -> entity"""
        return _ifcopenshell_wrapper.inverse_attribute_entity_reference(self)

    def attribute_reference(self):
        r"""attribute_reference(inverse_attribute self) -> attribute"""
        return _ifcopenshell_wrapper.inverse_attribute_attribute_reference(self)

    def type_of_aggregation_string(self):
        r"""type_of_aggregation_string(inverse_attribute self) -> std::string"""
        return _ifcopenshell_wrapper.inverse_attribute_type_of_aggregation_string(self)

    def __repr__(self):
    	format_bound = lambda i: "?" if i == -1 else str(i)
    	return "<inverse %s: %s [%s:%s] of %r for %r>" % (
    		self.name(),
    		self.type_of_aggregation_string(),
    		format_bound(self.bound1()),
    		format_bound(self.bound2()),
    		self.entity_reference(),
    		self.attribute_reference()
    	)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_inverse_attribute

# Register inverse_attribute in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.inverse_attribute_swigregister(inverse_attribute)

class entity(declaration):
    r"""Proxy of C++ IfcParse::entity class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, name, is_abstract, index_in_schema, supertype):
        r"""__init__(entity self, std::string const & name, bool is_abstract, int index_in_schema, entity supertype) -> entity"""
        _ifcopenshell_wrapper.entity_swiginit(self, _ifcopenshell_wrapper.new_entity(name, is_abstract, index_in_schema, supertype))
    __swig_destroy__ = _ifcopenshell_wrapper.delete_entity

    def is_abstract(self):
        r"""is_abstract(entity self) -> bool"""
        return _ifcopenshell_wrapper.entity_is_abstract(self)

    def set_subtypes(self, subtypes):
        r"""set_subtypes(entity self, std::vector< IfcParse::entity const *,std::allocator< IfcParse::entity const * > > const & subtypes)"""
        return _ifcopenshell_wrapper.entity_set_subtypes(self, subtypes)

    def set_attributes(self, attributes, derived):
        r"""set_attributes(entity self, std::vector< IfcParse::attribute const *,std::allocator< IfcParse::attribute const * > > const & attributes, std::vector< bool,std::allocator< bool > > const & derived)"""
        return _ifcopenshell_wrapper.entity_set_attributes(self, attributes, derived)

    def set_inverse_attributes(self, inverse_attributes):
        r"""set_inverse_attributes(entity self, std::vector< IfcParse::inverse_attribute const *,std::allocator< IfcParse::inverse_attribute const * > > const & inverse_attributes)"""
        return _ifcopenshell_wrapper.entity_set_inverse_attributes(self, inverse_attributes)

    def subtypes(self):
        r"""subtypes(entity self) -> std::vector< IfcParse::entity const *,std::allocator< IfcParse::entity const * > > const &"""
        return _ifcopenshell_wrapper.entity_subtypes(self)

    def attributes(self):
        r"""attributes(entity self) -> std::vector< IfcParse::attribute const *,std::allocator< IfcParse::attribute const * > > const &"""
        return _ifcopenshell_wrapper.entity_attributes(self)

    def derived(self):
        r"""derived(entity self) -> std::vector< bool,std::allocator< bool > > const &"""
        return _ifcopenshell_wrapper.entity_derived(self)

    def all_attributes(self):
        r"""all_attributes(entity self) -> std::vector< IfcParse::attribute const *,std::allocator< IfcParse::attribute const * > > const"""
        return _ifcopenshell_wrapper.entity_all_attributes(self)

    def all_inverse_attributes(self):
        r"""all_inverse_attributes(entity self) -> std::vector< IfcParse::inverse_attribute const *,std::allocator< IfcParse::inverse_attribute const * > > const"""
        return _ifcopenshell_wrapper.entity_all_inverse_attributes(self)

    def attribute_by_index(self, index):
        r"""attribute_by_index(entity self, size_t index) -> attribute"""
        return _ifcopenshell_wrapper.entity_attribute_by_index(self, index)

    def attribute_count(self):
        r"""attribute_count(entity self) -> size_t"""
        return _ifcopenshell_wrapper.entity_attribute_count(self)

    def attribute_index(self, *args):
        r"""
        attribute_index(entity self, attribute attr) -> ptrdiff_t
        attribute_index(entity self, std::string const & attr_name) -> ptrdiff_t
        """
        return _ifcopenshell_wrapper.entity_attribute_index(self, *args)

    def supertype(self):
        r"""supertype(entity self) -> entity"""
        return _ifcopenshell_wrapper.entity_supertype(self)

    def as_entity(self):
        r"""as_entity(entity self) -> entity"""
        return _ifcopenshell_wrapper.entity_as_entity(self)

    def __repr__(self):
    	return "<entity %s>" % (self.name())


    def argument_types(self):
        r"""argument_types(entity self) -> std::vector< std::string,std::allocator< std::string > >"""
        return _ifcopenshell_wrapper.entity_argument_types(self)

# Register entity in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.entity_swigregister(entity)

class schema_definition(object):
    r"""Proxy of C++ IfcParse::schema_definition class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, name, declarations, factory):
        r"""__init__(schema_definition self, std::string const & name, std::vector< IfcParse::declaration const *,std::allocator< IfcParse::declaration const * > > const & declarations, IfcParse::instance_factory * factory) -> schema_definition"""
        _ifcopenshell_wrapper.schema_definition_swiginit(self, _ifcopenshell_wrapper.new_schema_definition(name, declarations, factory))
    __swig_destroy__ = _ifcopenshell_wrapper.delete_schema_definition

    def declaration_by_name(self, *args):
        r"""
        declaration_by_name(schema_definition self, std::string const & name) -> declaration
        declaration_by_name(schema_definition self, size_t name) -> declaration
        """
        return _ifcopenshell_wrapper.schema_definition_declaration_by_name(self, *args)

    def declarations(self):
        r"""declarations(schema_definition self) -> std::vector< IfcParse::declaration const *,std::allocator< IfcParse::declaration const * > > const &"""
        return _ifcopenshell_wrapper.schema_definition_declarations(self)

    def type_declarations(self):
        r"""type_declarations(schema_definition self) -> std::vector< IfcParse::type_declaration const *,std::allocator< IfcParse::type_declaration const * > > const &"""
        return _ifcopenshell_wrapper.schema_definition_type_declarations(self)

    def select_types(self):
        r"""select_types(schema_definition self) -> std::vector< IfcParse::select_type const *,std::allocator< IfcParse::select_type const * > > const &"""
        return _ifcopenshell_wrapper.schema_definition_select_types(self)

    def enumeration_types(self):
        r"""enumeration_types(schema_definition self) -> std::vector< IfcParse::enumeration_type const *,std::allocator< IfcParse::enumeration_type const * > > const &"""
        return _ifcopenshell_wrapper.schema_definition_enumeration_types(self)

    def entities(self):
        r"""entities(schema_definition self) -> std::vector< IfcParse::entity const *,std::allocator< IfcParse::entity const * > > const &"""
        return _ifcopenshell_wrapper.schema_definition_entities(self)

    def name(self):
        r"""name(schema_definition self) -> std::string const &"""
        return _ifcopenshell_wrapper.schema_definition_name(self)

    def instantiate(self, decl, data):
        r"""instantiate(schema_definition self, declaration decl, IfcEntityInstanceData data) -> entity_instance"""
        return _ifcopenshell_wrapper.schema_definition_instantiate(self, decl, data)

    def __repr__(self):
    	return "<schema %s>" % (self.name())


# Register schema_definition in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.schema_definition_swigregister(schema_definition)


def schema_by_name(arg1):
    r"""schema_by_name(std::string const & arg1) -> schema_definition"""
    return _ifcopenshell_wrapper.schema_by_name(arg1)

def schema_names():
    r"""schema_names() -> std::vector< std::string,std::allocator< std::string > >"""
    return _ifcopenshell_wrapper.schema_names()

def register_schema(arg1):
    r"""register_schema(schema_definition arg1)"""
    return _ifcopenshell_wrapper.register_schema(arg1)

def clear_schemas():
    r"""clear_schemas()"""
    return _ifcopenshell_wrapper.clear_schemas()
class RocksDbSerializer(object):
    r"""Proxy of C++ RocksDbSerializer class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(RocksDbSerializer self, file file, std::string const & rocksdb_filename) -> RocksDbSerializer
        __init__(RocksDbSerializer self, std::string const & input_filename, std::string const & rocksdb_filename, bool stream) -> RocksDbSerializer
        """
        _ifcopenshell_wrapper.RocksDbSerializer_swiginit(self, _ifcopenshell_wrapper.new_RocksDbSerializer(*args))
    __swig_destroy__ = _ifcopenshell_wrapper.delete_RocksDbSerializer

    def ready(self):
        r"""ready(RocksDbSerializer self) -> bool"""
        return _ifcopenshell_wrapper.RocksDbSerializer_ready(self)

    def writeHeader(self):
        r"""writeHeader(RocksDbSerializer self)"""
        return _ifcopenshell_wrapper.RocksDbSerializer_writeHeader(self)

    def finalize(self):
        r"""finalize(RocksDbSerializer self)"""
        return _ifcopenshell_wrapper.RocksDbSerializer_finalize(self)

    def setFile(self, arg2):
        r"""setFile(RocksDbSerializer self, file arg2)"""
        return _ifcopenshell_wrapper.RocksDbSerializer_setFile(self, arg2)

# Register RocksDbSerializer in _ifcopenshell_wrapper:
_ifcopenshell_wrapper.RocksDbSerializer_swigregister(RocksDbSerializer)


def open(fn):
    r"""open(std::string const & fn) -> file"""
    return _ifcopenshell_wrapper.open(fn)

def read(data):
    r"""read(std::string const & data) -> file"""
    return _ifcopenshell_wrapper.read(data)

def version():
    r"""version() -> char const *"""
    return _ifcopenshell_wrapper.version()

def new_IfcBaseClass(schema_identifier, name):
    r"""new_IfcBaseClass(std::string const & schema_identifier, std::string const & name) -> entity_instance"""
    return _ifcopenshell_wrapper.new_IfcBaseClass(schema_identifier, name)

def get_log():
    r"""get_log() -> std::string"""
    return _ifcopenshell_wrapper.get_log()

def turn_on_detailed_logging():
    r"""turn_on_detailed_logging()"""
    return _ifcopenshell_wrapper.turn_on_detailed_logging()

def turn_off_detailed_logging():
    r"""turn_off_detailed_logging()"""
    return _ifcopenshell_wrapper.turn_off_detailed_logging()

def set_log_format_json():
    r"""set_log_format_json()"""
    return _ifcopenshell_wrapper.set_log_format_json()

def set_log_format_text():
    r"""set_log_format_text()"""
    return _ifcopenshell_wrapper.set_log_format_text()

def get_info_cpp(v, include_identifier=True):
    r"""get_info_cpp(entity_instance v, bool include_identifier=True) -> PyObject"""
    return _ifcopenshell_wrapper.get_info_cpp(v, include_identifier)


