# 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 False:
    raise RuntimeError("Python 2.7 or later required")

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

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):
    r"""Proxy of C++ swig::SwigPyIterator 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__ = _pcbnew.delete_SwigPyIterator

    def value(self) -> "PyObject *":
        r"""value(SwigPyIterator self) -> PyObject *"""
        return _pcbnew.SwigPyIterator_value(self)

    def incr(self, n: "size_t"=1) -> "swig::SwigPyIterator *":
        r"""incr(SwigPyIterator self, size_t n=1) -> SwigPyIterator"""
        return _pcbnew.SwigPyIterator_incr(self, n)

    def decr(self, n: "size_t"=1) -> "swig::SwigPyIterator *":
        r"""decr(SwigPyIterator self, size_t n=1) -> SwigPyIterator"""
        return _pcbnew.SwigPyIterator_decr(self, n)

    def distance(self, x: "SwigPyIterator") -> "ptrdiff_t":
        r"""distance(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t"""
        return _pcbnew.SwigPyIterator_distance(self, x)

    def equal(self, x: "SwigPyIterator") -> "bool":
        r"""equal(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _pcbnew.SwigPyIterator_equal(self, x)

    def copy(self) -> "swig::SwigPyIterator *":
        r"""copy(SwigPyIterator self) -> SwigPyIterator"""
        return _pcbnew.SwigPyIterator_copy(self)

    def next(self) -> "PyObject *":
        r"""next(SwigPyIterator self) -> PyObject *"""
        return _pcbnew.SwigPyIterator_next(self)

    def __next__(self) -> "PyObject *":
        r"""__next__(SwigPyIterator self) -> PyObject *"""
        return _pcbnew.SwigPyIterator___next__(self)

    def previous(self) -> "PyObject *":
        r"""previous(SwigPyIterator self) -> PyObject *"""
        return _pcbnew.SwigPyIterator_previous(self)

    def advance(self, n: "ptrdiff_t") -> "swig::SwigPyIterator *":
        r"""advance(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _pcbnew.SwigPyIterator_advance(self, n)

    def __eq__(self, x: "SwigPyIterator") -> "bool":
        r"""__eq__(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _pcbnew.SwigPyIterator___eq__(self, x)

    def __ne__(self, x: "SwigPyIterator") -> "bool":
        r"""__ne__(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _pcbnew.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n: "ptrdiff_t") -> "swig::SwigPyIterator &":
        r"""__iadd__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _pcbnew.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n: "ptrdiff_t") -> "swig::SwigPyIterator &":
        r"""__isub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _pcbnew.SwigPyIterator___isub__(self, n)

    def __add__(self, n: "ptrdiff_t") -> "swig::SwigPyIterator *":
        r"""__add__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _pcbnew.SwigPyIterator___add__(self, n)

    def __sub__(self, *args) -> "ptrdiff_t":
        r"""
        __sub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator
        __sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t
        """
        return _pcbnew.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self

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

class string(object):
    r"""Proxy of C++ std::basic_string< char > class."""

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

    def length(self) -> "std::basic_string< char >::size_type":
        r"""length(string self) -> std::basic_string< char >::size_type"""
        return _pcbnew.string_length(self)

    def max_size(self) -> "std::basic_string< char >::size_type":
        r"""max_size(string self) -> std::basic_string< char >::size_type"""
        return _pcbnew.string_max_size(self)

    def capacity(self) -> "std::basic_string< char >::size_type":
        r"""capacity(string self) -> std::basic_string< char >::size_type"""
        return _pcbnew.string_capacity(self)

    def reserve(self, __res_arg: "std::basic_string< char >::size_type"=0) -> "void":
        r"""reserve(string self, std::basic_string< char >::size_type __res_arg=0)"""
        return _pcbnew.string_reserve(self, __res_arg)

    def copy(self, __s: "char *", __n: "std::basic_string< char >::size_type", __pos: "std::basic_string< char >::size_type"=0) -> "std::basic_string< char >::size_type":
        r"""copy(string self, char * __s, std::basic_string< char >::size_type __n, std::basic_string< char >::size_type __pos=0) -> std::basic_string< char >::size_type"""
        return _pcbnew.string_copy(self, __s, __n, __pos)

    def c_str(self) -> "char const *":
        r"""c_str(string self) -> char const *"""
        return _pcbnew.string_c_str(self)

    def find(self, *args) -> "std::basic_string< char >::size_type":
        r"""
        find(string self, char const * __s, std::basic_string< char >::size_type __pos, std::basic_string< char >::size_type __n) -> std::basic_string< char >::size_type
        find(string self, string __str, std::basic_string< char >::size_type __pos=0) -> std::basic_string< char >::size_type
        find(string self, char __c, std::basic_string< char >::size_type __pos=0) -> std::basic_string< char >::size_type
        """
        return _pcbnew.string_find(self, *args)

    def rfind(self, *args) -> "std::basic_string< char >::size_type":
        r"""
        rfind(string self, string __str, std::basic_string< char >::size_type __pos=std::basic_string< char >::npos) -> std::basic_string< char >::size_type
        rfind(string self, char const * __s, std::basic_string< char >::size_type __pos, std::basic_string< char >::size_type __n) -> std::basic_string< char >::size_type
        rfind(string self, char __c, std::basic_string< char >::size_type __pos=std::basic_string< char >::npos) -> std::basic_string< char >::size_type
        """
        return _pcbnew.string_rfind(self, *args)

    def find_first_of(self, *args) -> "std::basic_string< char >::size_type":
        r"""
        find_first_of(string self, string __str, std::basic_string< char >::size_type __pos=0) -> std::basic_string< char >::size_type
        find_first_of(string self, char const * __s, std::basic_string< char >::size_type __pos, std::basic_string< char >::size_type __n) -> std::basic_string< char >::size_type
        find_first_of(string self, char __c, std::basic_string< char >::size_type __pos=0) -> std::basic_string< char >::size_type
        """
        return _pcbnew.string_find_first_of(self, *args)

    def find_last_of(self, *args) -> "std::basic_string< char >::size_type":
        r"""
        find_last_of(string self, string __str, std::basic_string< char >::size_type __pos=std::basic_string< char >::npos) -> std::basic_string< char >::size_type
        find_last_of(string self, char const * __s, std::basic_string< char >::size_type __pos, std::basic_string< char >::size_type __n) -> std::basic_string< char >::size_type
        find_last_of(string self, char __c, std::basic_string< char >::size_type __pos=std::basic_string< char >::npos) -> std::basic_string< char >::size_type
        """
        return _pcbnew.string_find_last_of(self, *args)

    def find_first_not_of(self, *args) -> "std::basic_string< char >::size_type":
        r"""
        find_first_not_of(string self, string __str, std::basic_string< char >::size_type __pos=0) -> std::basic_string< char >::size_type
        find_first_not_of(string self, char const * __s, std::basic_string< char >::size_type __pos, std::basic_string< char >::size_type __n) -> std::basic_string< char >::size_type
        find_first_not_of(string self, char __c, std::basic_string< char >::size_type __pos=0) -> std::basic_string< char >::size_type
        """
        return _pcbnew.string_find_first_not_of(self, *args)

    def find_last_not_of(self, *args) -> "std::basic_string< char >::size_type":
        r"""
        find_last_not_of(string self, string __str, std::basic_string< char >::size_type __pos=std::basic_string< char >::npos) -> std::basic_string< char >::size_type
        find_last_not_of(string self, char const * __s, std::basic_string< char >::size_type __pos, std::basic_string< char >::size_type __n) -> std::basic_string< char >::size_type
        find_last_not_of(string self, char __c, std::basic_string< char >::size_type __pos=std::basic_string< char >::npos) -> std::basic_string< char >::size_type
        """
        return _pcbnew.string_find_last_not_of(self, *args)

    def substr(self, *args) -> "std::basic_string< char >":
        r"""substr(string self, std::basic_string< char >::size_type __pos=0, std::basic_string< char >::size_type __n=std::basic_string< char >::npos) -> string"""
        return _pcbnew.string_substr(self, *args)

    def empty(self) -> "bool":
        r"""empty(string self) -> bool"""
        return _pcbnew.string_empty(self)

    def size(self) -> "std::basic_string< char >::size_type":
        r"""size(string self) -> std::basic_string< char >::size_type"""
        return _pcbnew.string_size(self)

    def swap(self, v: "string") -> "void":
        r"""swap(string self, string v)"""
        return _pcbnew.string_swap(self, v)

    def begin(self) -> "std::basic_string< char >::iterator":
        r"""begin(string self) -> std::basic_string< char >::iterator"""
        return _pcbnew.string_begin(self)

    def end(self) -> "std::basic_string< char >::iterator":
        r"""end(string self) -> std::basic_string< char >::iterator"""
        return _pcbnew.string_end(self)

    def rbegin(self) -> "std::basic_string< char >::reverse_iterator":
        r"""rbegin(string self) -> std::basic_string< char >::reverse_iterator"""
        return _pcbnew.string_rbegin(self)

    def rend(self) -> "std::basic_string< char >::reverse_iterator":
        r"""rend(string self) -> std::basic_string< char >::reverse_iterator"""
        return _pcbnew.string_rend(self)

    def get_allocator(self) -> "std::basic_string< char >::allocator_type":
        r"""get_allocator(string self) -> std::basic_string< char >::allocator_type"""
        return _pcbnew.string_get_allocator(self)

    def erase(self, *args) -> "std::basic_string< char >::iterator":
        r"""
        erase(string self, std::basic_string< char >::size_type __pos=0, std::basic_string< char >::size_type __n=std::basic_string< char >::npos) -> string
        erase(string self, std::basic_string< char >::iterator pos) -> std::basic_string< char >::iterator
        erase(string self, std::basic_string< char >::iterator first, std::basic_string< char >::iterator last) -> std::basic_string< char >::iterator
        """
        return _pcbnew.string_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(string self, char const * __s, std::basic_string< char >::size_type __n) -> string
        __init__(string self) -> string
        __init__(string self, string other) -> string
        __init__(string self, std::basic_string< char >::size_type size, std::basic_string< char >::value_type value) -> string
        """
        _pcbnew.string_swiginit(self, _pcbnew.new_string(*args))

    def assign(self, *args) -> "void":
        r"""
        assign(string self, string __str) -> string
        assign(string self, string __str, std::basic_string< char >::size_type __pos, std::basic_string< char >::size_type __n) -> string
        assign(string self, char const * __s, std::basic_string< char >::size_type __n) -> string
        assign(string self, std::basic_string< char >::size_type n, std::basic_string< char >::value_type x)
        """
        return _pcbnew.string_assign(self, *args)

    def resize(self, *args) -> "void":
        r"""
        resize(string self, std::basic_string< char >::size_type new_size)
        resize(string self, std::basic_string< char >::size_type new_size, std::basic_string< char >::value_type x)
        """
        return _pcbnew.string_resize(self, *args)

    def iterator(self) -> "swig::SwigPyIterator *":
        r"""iterator(string self) -> SwigPyIterator"""
        return _pcbnew.string_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(string self) -> bool"""
        return _pcbnew.string___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(string self) -> bool"""
        return _pcbnew.string___bool__(self)

    def __len__(self) -> "std::basic_string< char >::size_type":
        r"""__len__(string self) -> std::basic_string< char >::size_type"""
        return _pcbnew.string___len__(self)

    def __getslice__(self, i: "std::basic_string< char >::difference_type", j: "std::basic_string< char >::difference_type") -> "std::basic_string< char,std::char_traits< char >,std::allocator< char > > *":
        r"""__getslice__(string self, std::basic_string< char >::difference_type i, std::basic_string< char >::difference_type j) -> string"""
        return _pcbnew.string___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        r"""
        __setslice__(string self, std::basic_string< char >::difference_type i, std::basic_string< char >::difference_type j)
        __setslice__(string self, std::basic_string< char >::difference_type i, std::basic_string< char >::difference_type j, string v)
        """
        return _pcbnew.string___setslice__(self, *args)

    def __delslice__(self, i: "std::basic_string< char >::difference_type", j: "std::basic_string< char >::difference_type") -> "void":
        r"""__delslice__(string self, std::basic_string< char >::difference_type i, std::basic_string< char >::difference_type j)"""
        return _pcbnew.string___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        r"""
        __delitem__(string self, std::basic_string< char >::difference_type i)
        __delitem__(string self, PySliceObject * slice)
        """
        return _pcbnew.string___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::basic_string< char >::value_type":
        r"""
        __getitem__(string self, PySliceObject * slice) -> string
        __getitem__(string self, std::basic_string< char >::difference_type i) -> std::basic_string< char >::value_type
        """
        return _pcbnew.string___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(string self, PySliceObject * slice, string v)
        __setitem__(string self, PySliceObject * slice)
        __setitem__(string self, std::basic_string< char >::difference_type i, std::basic_string< char >::value_type x)
        """
        return _pcbnew.string___setitem__(self, *args)

    def insert(self, *args) -> "void":
        r"""
        insert(string self, std::basic_string< char >::size_type __pos1, string __str) -> string
        insert(string self, std::basic_string< char >::size_type __pos1, string __str, std::basic_string< char >::size_type __pos2, std::basic_string< char >::size_type __n) -> string
        insert(string self, std::basic_string< char >::size_type __pos, char const * __s, std::basic_string< char >::size_type __n) -> string
        insert(string self, std::basic_string< char >::size_type __pos, std::basic_string< char >::size_type __n, char __c) -> string
        insert(string self, std::basic_string< char >::iterator pos, std::basic_string< char >::value_type x) -> std::basic_string< char >::iterator
        insert(string self, std::basic_string< char >::iterator pos, std::basic_string< char >::size_type n, std::basic_string< char >::value_type x)
        insert(string self, std::basic_string< char >::iterator __p, std::basic_string< char >::size_type __n, char __c)
        """
        return _pcbnew.string_insert(self, *args)

    def replace(self, *args) -> "std::basic_string< char > &":
        r"""
        replace(string self, std::basic_string< char >::size_type __pos, std::basic_string< char >::size_type __n, string __str) -> string
        replace(string self, std::basic_string< char >::size_type __pos1, std::basic_string< char >::size_type __n1, string __str, std::basic_string< char >::size_type __pos2, std::basic_string< char >::size_type __n2) -> string
        replace(string self, std::basic_string< char >::size_type __pos, std::basic_string< char >::size_type __n1, char const * __s, std::basic_string< char >::size_type __n2) -> string
        replace(string self, std::basic_string< char >::size_type __pos, std::basic_string< char >::size_type __n1, std::basic_string< char >::size_type __n2, char __c) -> string
        replace(string self, std::basic_string< char >::iterator __i1, std::basic_string< char >::iterator __i2, string __str) -> string
        replace(string self, std::basic_string< char >::iterator __i1, std::basic_string< char >::iterator __i2, char const * __s, std::basic_string< char >::size_type __n) -> string
        replace(string self, std::basic_string< char >::iterator __i1, std::basic_string< char >::iterator __i2, std::basic_string< char >::size_type __n, char __c) -> string
        replace(string self, std::basic_string< char >::iterator __i1, std::basic_string< char >::iterator __i2, char const * __k1, char const * __k2) -> string
        replace(string self, std::basic_string< char >::iterator __i1, std::basic_string< char >::iterator __i2, std::basic_string< char >::const_iterator __k1, std::basic_string< char >::const_iterator __k2) -> string
        """
        return _pcbnew.string_replace(self, *args)

    def __iadd__(self, v: "string") -> "std::basic_string< char > &":
        r"""__iadd__(string self, string v) -> string"""
        return _pcbnew.string___iadd__(self, v)

    def __add__(self, v: "string") -> "std::basic_string< char,std::char_traits< char >,std::allocator< char > > *":
        r"""__add__(string self, string v) -> string"""
        return _pcbnew.string___add__(self, v)

    def __radd__(self, v: "string") -> "std::basic_string< char,std::char_traits< char >,std::allocator< char > > *":
        r"""__radd__(string self, string v) -> string"""
        return _pcbnew.string___radd__(self, v)

    def __str__(self) -> "std::basic_string< char,std::char_traits< char >,std::allocator< char > >":
        r"""__str__(string self) -> string"""
        return _pcbnew.string___str__(self)

    def __rlshift__(self, out: "std::basic_ostream< char,std::char_traits< char > > &") -> "std::basic_ostream< char,std::char_traits< char > > &":
        r"""__rlshift__(string self, std::basic_ostream< char,std::char_traits< char > > & out) -> std::basic_ostream< char,std::char_traits< char > > &"""
        return _pcbnew.string___rlshift__(self, out)

    def __eq__(self, v: "string") -> "bool":
        r"""__eq__(string self, string v) -> bool"""
        return _pcbnew.string___eq__(self, v)

    def __ne__(self, v: "string") -> "bool":
        r"""__ne__(string self, string v) -> bool"""
        return _pcbnew.string___ne__(self, v)

    def __gt__(self, v: "string") -> "bool":
        r"""__gt__(string self, string v) -> bool"""
        return _pcbnew.string___gt__(self, v)

    def __lt__(self, v: "string") -> "bool":
        r"""__lt__(string self, string v) -> bool"""
        return _pcbnew.string___lt__(self, v)

    def __ge__(self, v: "string") -> "bool":
        r"""__ge__(string self, string v) -> bool"""
        return _pcbnew.string___ge__(self, v)

    def __le__(self, v: "string") -> "bool":
        r"""__le__(string self, string v) -> bool"""
        return _pcbnew.string___le__(self, v)
    __swig_destroy__ = _pcbnew.delete_string

# Register string in _pcbnew:
_pcbnew.string_swigregister(string)
cvar = _pcbnew.cvar
string.npos = _pcbnew.cvar.string_npos

SHARED_PTR_DISOWN = _pcbnew.SHARED_PTR_DISOWN

class KI_PARAM_ERROR(object):
    r"""Proxy of C++ KI_PARAM_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__(KI_PARAM_ERROR self, wxString aMessage) -> KI_PARAM_ERROR
        __init__(KI_PARAM_ERROR self) -> KI_PARAM_ERROR
        """
        _pcbnew.KI_PARAM_ERROR_swiginit(self, _pcbnew.new_KI_PARAM_ERROR(*args))

    def What(self) -> "wxString const":
        r"""What(KI_PARAM_ERROR self) -> wxString"""
        return _pcbnew.KI_PARAM_ERROR_What(self)
    __swig_destroy__ = _pcbnew.delete_KI_PARAM_ERROR

# Register KI_PARAM_ERROR in _pcbnew:
_pcbnew.KI_PARAM_ERROR_swigregister(KI_PARAM_ERROR)

class IO_ERROR(object):
    r"""Proxy of C++ IO_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__(IO_ERROR self, wxString aProblem, char const * aThrowersFile, char const * aThrowersFunction, int aThrowersLineNumber) -> IO_ERROR
        __init__(IO_ERROR self) -> IO_ERROR
        """
        _pcbnew.IO_ERROR_swiginit(self, _pcbnew.new_IO_ERROR(*args))

    def init(self, aProblem: "wxString", aThrowersFile: "char const *", aThrowersFunction: "char const *", aThrowersLineNumber: "int") -> "void":
        r"""init(IO_ERROR self, wxString aProblem, char const * aThrowersFile, char const * aThrowersFunction, int aThrowersLineNumber)"""
        return _pcbnew.IO_ERROR_init(self, aProblem, aThrowersFile, aThrowersFunction, aThrowersLineNumber)

    def Problem(self) -> "wxString const":
        r"""Problem(IO_ERROR self) -> wxString"""
        return _pcbnew.IO_ERROR_Problem(self)

    def Where(self) -> "wxString const":
        r"""Where(IO_ERROR self) -> wxString"""
        return _pcbnew.IO_ERROR_Where(self)

    def What(self) -> "wxString const":
        r"""What(IO_ERROR self) -> wxString"""
        return _pcbnew.IO_ERROR_What(self)
    __swig_destroy__ = _pcbnew.delete_IO_ERROR

# Register IO_ERROR in _pcbnew:
_pcbnew.IO_ERROR_swigregister(IO_ERROR)


def wxSetDefaultPyEncoding(encoding: "char const *") -> "void":
    r"""wxSetDefaultPyEncoding(char const * encoding)"""
    return _pcbnew.wxSetDefaultPyEncoding(encoding)

def wxGetDefaultPyEncoding() -> "char const *":
    r"""wxGetDefaultPyEncoding() -> char const *"""
    return _pcbnew.wxGetDefaultPyEncoding()
class wxRect(object):
    r"""Proxy of C++ wxRect 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__(wxRect self) -> wxRect
        __init__(wxRect self, int xx, int yy, int ww, int hh) -> wxRect
        __init__(wxRect self, wxPoint topLeft, wxPoint bottomRight) -> wxRect
        __init__(wxRect self, wxPoint pt, wxSize size) -> wxRect
        __init__(wxRect self, wxSize size) -> wxRect
        """
        _pcbnew.wxRect_swiginit(self, _pcbnew.new_wxRect(*args))

    def GetX(self) -> "int":
        r"""GetX(wxRect self) -> int"""
        return _pcbnew.wxRect_GetX(self)

    def SetX(self, xx: "int") -> "void":
        r"""SetX(wxRect self, int xx)"""
        return _pcbnew.wxRect_SetX(self, xx)

    def GetY(self) -> "int":
        r"""GetY(wxRect self) -> int"""
        return _pcbnew.wxRect_GetY(self)

    def SetY(self, yy: "int") -> "void":
        r"""SetY(wxRect self, int yy)"""
        return _pcbnew.wxRect_SetY(self, yy)

    def GetWidth(self) -> "int":
        r"""GetWidth(wxRect self) -> int"""
        return _pcbnew.wxRect_GetWidth(self)

    def SetWidth(self, w: "int") -> "void":
        r"""SetWidth(wxRect self, int w)"""
        return _pcbnew.wxRect_SetWidth(self, w)

    def GetHeight(self) -> "int":
        r"""GetHeight(wxRect self) -> int"""
        return _pcbnew.wxRect_GetHeight(self)

    def SetHeight(self, h: "int") -> "void":
        r"""SetHeight(wxRect self, int h)"""
        return _pcbnew.wxRect_SetHeight(self, h)

    def GetPosition(self) -> "wxPoint":
        r"""GetPosition(wxRect self) -> wxPoint"""
        return _pcbnew.wxRect_GetPosition(self)

    def SetPosition(self, p: "wxPoint") -> "void":
        r"""SetPosition(wxRect self, wxPoint p)"""
        return _pcbnew.wxRect_SetPosition(self, p)
    x = property(_pcbnew.wxRect_x_get, _pcbnew.wxRect_x_set, doc=r"""x : int""")
    y = property(_pcbnew.wxRect_y_get, _pcbnew.wxRect_y_set, doc=r"""y : int""")
    width = property(_pcbnew.wxRect_width_get, _pcbnew.wxRect_width_set, doc=r"""width : int""")
    height = property(_pcbnew.wxRect_height_get, _pcbnew.wxRect_height_set, doc=r"""height : int""")

    def Get(self) -> "PyObject *":
        r"""Get(wxRect self) -> PyObject *"""
        return _pcbnew.wxRect_Get(self)


    def __eq__(self,other):
        return self.x==other.x and self.y==other.y and self.width==other.width and self.height==other.height
    def __str__(self):                   return str(self.Get())
    def __repr__(self):                  return 'wxRect'+str(self.Get())
    def __len__(self):                   return len(self.Get())
    def __getitem__(self, index):        return self.Get()[index]
    def __setitem__(self, index, val):
        if  index == 0:     self.SetX(val)
        elif    index == 1:     self.SetY(val)
        elif    index == 2:     self.SetWidth(val)
        elif    index == 3:     self.SetHeight(val)
        else:           raise IndexError
    def __nonzero__(self):               return self.Get() != (0,0,0,0)
    __safe_for_unpickling__ = True

    __swig_destroy__ = _pcbnew.delete_wxRect

# Register wxRect in _pcbnew:
_pcbnew.wxRect_swigregister(wxRect)

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    x = property(_pcbnew.wxSize_x_get, _pcbnew.wxSize_x_set, doc=r"""x : int""")
    y = property(_pcbnew.wxSize_y_get, _pcbnew.wxSize_y_set, doc=r"""y : int""")

    def __init__(self, *args):
        r"""
        __init__(wxSize self, int xx, int yy) -> wxSize
        __init__(wxSize self, double xx, double yy) -> wxSize
        """
        _pcbnew.wxSize_swiginit(self, _pcbnew.new_wxSize(*args))

    def Get(self) -> "PyObject *":
        r"""Get(wxSize self) -> PyObject *"""
        return _pcbnew.wxSize_Get(self)
    __swig_destroy__ = _pcbnew.delete_wxSize

    def SetWidth(self, w: "int") -> "void":
        r"""SetWidth(wxSize self, int w)"""
        return _pcbnew.wxSize_SetWidth(self, w)

    def SetHeight(self, h: "int") -> "void":
        r"""SetHeight(wxSize self, int h)"""
        return _pcbnew.wxSize_SetHeight(self, h)

    def GetWidth(self) -> "int":
        r"""GetWidth(wxSize self) -> int"""
        return _pcbnew.wxSize_GetWidth(self)

    def GetHeight(self) -> "int":
        r"""GetHeight(wxSize self) -> int"""
        return _pcbnew.wxSize_GetHeight(self)

    def Scale(self,xscale,yscale):
        return wxSize(self.x*xscale,self.y*yscale)
    def __eq__(self,other):
        return self.GetWidth()==other.GetWidth() and self.GetHeight()==other.GetHeight()
    def __str__(self):                   return str(self.Get())
    def __repr__(self):                  return 'wxSize'+str(self.Get())
    def __len__(self):                   return len(self.Get())
    def __getitem__(self, index):        return self.Get()[index]
    def __setitem__(self, index, val):
        if  index == 0:     self.SetWidth(val)
        elif    index == 1:     self.SetHeight(val)
        else:           raise IndexError
    def __nonzero__(self):               return self.Get() != (0,0)
    __safe_for_unpickling__ = True



# Register wxSize in _pcbnew:
_pcbnew.wxSize_swigregister(wxSize)

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    x = property(_pcbnew.wxPoint_x_get, _pcbnew.wxPoint_x_set, doc=r"""x : int""")
    y = property(_pcbnew.wxPoint_y_get, _pcbnew.wxPoint_y_set, doc=r"""y : int""")

    def __init__(self, *args):
        r"""
        __init__(wxPoint self, int xx, int yy) -> wxPoint
        __init__(wxPoint self, double xx, double yy) -> wxPoint
        """
        _pcbnew.wxPoint_swiginit(self, _pcbnew.new_wxPoint(*args))
    __swig_destroy__ = _pcbnew.delete_wxPoint

    def __add__(self, pt: "wxPoint") -> "wxPoint":
        r"""__add__(wxPoint self, wxPoint pt) -> wxPoint"""
        return _pcbnew.wxPoint___add__(self, pt)

    def __sub__(self, pt: "wxPoint") -> "wxPoint":
        r"""__sub__(wxPoint self, wxPoint pt) -> wxPoint"""
        return _pcbnew.wxPoint___sub__(self, pt)

    def Set(self, x: "long", y: "long") -> "void":
        r"""Set(wxPoint self, long x, long y)"""
        return _pcbnew.wxPoint_Set(self, x, y)

    def Get(self) -> "PyObject *":
        r"""Get(wxPoint self) -> PyObject *"""
        return _pcbnew.wxPoint_Get(self)

    def __eq__(self,other):            return (self.x==other.x and self.y==other.y)
    def __ne__(self,other):            return not (self==other)
    def __str__(self):                 return str(self.Get())
    def __repr__(self):                return 'wxPoint'+str(self.Get())
    def __len__(self):                 return len(self.Get())
    def __getitem__(self, index):      return self.Get()[index]
    def __setitem__(self, index, val):
        if index == 0:
            self.x = val
        elif index == 1:
            self.y = val
        else:
            raise IndexError
    def __nonzero__(self):               return self.Get() != (0,0)



# Register wxPoint in _pcbnew:
_pcbnew.wxPoint_swigregister(wxPoint)

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

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

    def __str__(self) -> "PyObject *":
        r"""__str__(wxString self) -> PyObject *"""
        return _pcbnew.wxString___str__(self)

    def __repr__(self):     return 'wxString(\'' + self.__str__() + '\')'


    def __init__(self):
        r"""__init__(wxString self) -> wxString"""
        _pcbnew.wxString_swiginit(self, _pcbnew.new_wxString())

# Register wxString in _pcbnew:
_pcbnew.wxString_swigregister(wxString)

class wxPoint_Vector(object):
    r"""Proxy of C++ std::vector< wxPoint > 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) -> "swig::SwigPyIterator *":
        r"""iterator(wxPoint_Vector self) -> SwigPyIterator"""
        return _pcbnew.wxPoint_Vector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(wxPoint_Vector self) -> bool"""
        return _pcbnew.wxPoint_Vector___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(wxPoint_Vector self) -> bool"""
        return _pcbnew.wxPoint_Vector___bool__(self)

    def __len__(self) -> "std::vector< wxPoint >::size_type":
        r"""__len__(wxPoint_Vector self) -> std::vector< wxPoint >::size_type"""
        return _pcbnew.wxPoint_Vector___len__(self)

    def __getslice__(self, i: "std::vector< wxPoint >::difference_type", j: "std::vector< wxPoint >::difference_type") -> "std::vector< wxPoint,std::allocator< wxPoint > > *":
        r"""__getslice__(wxPoint_Vector self, std::vector< wxPoint >::difference_type i, std::vector< wxPoint >::difference_type j) -> wxPoint_Vector"""
        return _pcbnew.wxPoint_Vector___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        r"""
        __setslice__(wxPoint_Vector self, std::vector< wxPoint >::difference_type i, std::vector< wxPoint >::difference_type j)
        __setslice__(wxPoint_Vector self, std::vector< wxPoint >::difference_type i, std::vector< wxPoint >::difference_type j, wxPoint_Vector v)
        """
        return _pcbnew.wxPoint_Vector___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< wxPoint >::difference_type", j: "std::vector< wxPoint >::difference_type") -> "void":
        r"""__delslice__(wxPoint_Vector self, std::vector< wxPoint >::difference_type i, std::vector< wxPoint >::difference_type j)"""
        return _pcbnew.wxPoint_Vector___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        r"""
        __delitem__(wxPoint_Vector self, std::vector< wxPoint >::difference_type i)
        __delitem__(wxPoint_Vector self, PySliceObject * slice)
        """
        return _pcbnew.wxPoint_Vector___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< wxPoint >::value_type const &":
        r"""
        __getitem__(wxPoint_Vector self, PySliceObject * slice) -> wxPoint_Vector
        __getitem__(wxPoint_Vector self, std::vector< wxPoint >::difference_type i) -> wxPoint
        """
        return _pcbnew.wxPoint_Vector___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(wxPoint_Vector self, PySliceObject * slice, wxPoint_Vector v)
        __setitem__(wxPoint_Vector self, PySliceObject * slice)
        __setitem__(wxPoint_Vector self, std::vector< wxPoint >::difference_type i, wxPoint x)
        """
        return _pcbnew.wxPoint_Vector___setitem__(self, *args)

    def pop(self) -> "std::vector< wxPoint >::value_type":
        r"""pop(wxPoint_Vector self) -> wxPoint"""
        return _pcbnew.wxPoint_Vector_pop(self)

    def append(self, x: "wxPoint") -> "void":
        r"""append(wxPoint_Vector self, wxPoint x)"""
        return _pcbnew.wxPoint_Vector_append(self, x)

    def empty(self) -> "bool":
        r"""empty(wxPoint_Vector self) -> bool"""
        return _pcbnew.wxPoint_Vector_empty(self)

    def size(self) -> "std::vector< wxPoint >::size_type":
        r"""size(wxPoint_Vector self) -> std::vector< wxPoint >::size_type"""
        return _pcbnew.wxPoint_Vector_size(self)

    def swap(self, v: "wxPoint_Vector") -> "void":
        r"""swap(wxPoint_Vector self, wxPoint_Vector v)"""
        return _pcbnew.wxPoint_Vector_swap(self, v)

    def begin(self) -> "std::vector< wxPoint >::iterator":
        r"""begin(wxPoint_Vector self) -> std::vector< wxPoint >::iterator"""
        return _pcbnew.wxPoint_Vector_begin(self)

    def end(self) -> "std::vector< wxPoint >::iterator":
        r"""end(wxPoint_Vector self) -> std::vector< wxPoint >::iterator"""
        return _pcbnew.wxPoint_Vector_end(self)

    def rbegin(self) -> "std::vector< wxPoint >::reverse_iterator":
        r"""rbegin(wxPoint_Vector self) -> std::vector< wxPoint >::reverse_iterator"""
        return _pcbnew.wxPoint_Vector_rbegin(self)

    def rend(self) -> "std::vector< wxPoint >::reverse_iterator":
        r"""rend(wxPoint_Vector self) -> std::vector< wxPoint >::reverse_iterator"""
        return _pcbnew.wxPoint_Vector_rend(self)

    def clear(self) -> "void":
        r"""clear(wxPoint_Vector self)"""
        return _pcbnew.wxPoint_Vector_clear(self)

    def get_allocator(self) -> "std::vector< wxPoint >::allocator_type":
        r"""get_allocator(wxPoint_Vector self) -> std::vector< wxPoint >::allocator_type"""
        return _pcbnew.wxPoint_Vector_get_allocator(self)

    def pop_back(self) -> "void":
        r"""pop_back(wxPoint_Vector self)"""
        return _pcbnew.wxPoint_Vector_pop_back(self)

    def erase(self, *args) -> "std::vector< wxPoint >::iterator":
        r"""
        erase(wxPoint_Vector self, std::vector< wxPoint >::iterator pos) -> std::vector< wxPoint >::iterator
        erase(wxPoint_Vector self, std::vector< wxPoint >::iterator first, std::vector< wxPoint >::iterator last) -> std::vector< wxPoint >::iterator
        """
        return _pcbnew.wxPoint_Vector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(wxPoint_Vector self) -> wxPoint_Vector
        __init__(wxPoint_Vector self, wxPoint_Vector other) -> wxPoint_Vector
        __init__(wxPoint_Vector self, std::vector< wxPoint >::size_type size) -> wxPoint_Vector
        __init__(wxPoint_Vector self, std::vector< wxPoint >::size_type size, wxPoint value) -> wxPoint_Vector
        """
        _pcbnew.wxPoint_Vector_swiginit(self, _pcbnew.new_wxPoint_Vector(*args))

    def push_back(self, x: "wxPoint") -> "void":
        r"""push_back(wxPoint_Vector self, wxPoint x)"""
        return _pcbnew.wxPoint_Vector_push_back(self, x)

    def front(self) -> "std::vector< wxPoint >::value_type const &":
        r"""front(wxPoint_Vector self) -> wxPoint"""
        return _pcbnew.wxPoint_Vector_front(self)

    def back(self) -> "std::vector< wxPoint >::value_type const &":
        r"""back(wxPoint_Vector self) -> wxPoint"""
        return _pcbnew.wxPoint_Vector_back(self)

    def assign(self, n: "std::vector< wxPoint >::size_type", x: "wxPoint") -> "void":
        r"""assign(wxPoint_Vector self, std::vector< wxPoint >::size_type n, wxPoint x)"""
        return _pcbnew.wxPoint_Vector_assign(self, n, x)

    def resize(self, *args) -> "void":
        r"""
        resize(wxPoint_Vector self, std::vector< wxPoint >::size_type new_size)
        resize(wxPoint_Vector self, std::vector< wxPoint >::size_type new_size, wxPoint x)
        """
        return _pcbnew.wxPoint_Vector_resize(self, *args)

    def insert(self, *args) -> "void":
        r"""
        insert(wxPoint_Vector self, std::vector< wxPoint >::iterator pos, wxPoint x) -> std::vector< wxPoint >::iterator
        insert(wxPoint_Vector self, std::vector< wxPoint >::iterator pos, std::vector< wxPoint >::size_type n, wxPoint x)
        """
        return _pcbnew.wxPoint_Vector_insert(self, *args)

    def reserve(self, n: "std::vector< wxPoint >::size_type") -> "void":
        r"""reserve(wxPoint_Vector self, std::vector< wxPoint >::size_type n)"""
        return _pcbnew.wxPoint_Vector_reserve(self, n)

    def capacity(self) -> "std::vector< wxPoint >::size_type":
        r"""capacity(wxPoint_Vector self) -> std::vector< wxPoint >::size_type"""
        return _pcbnew.wxPoint_Vector_capacity(self)
    __swig_destroy__ = _pcbnew.delete_wxPoint_Vector

# Register wxPoint_Vector in _pcbnew:
_pcbnew.wxPoint_Vector_swigregister(wxPoint_Vector)

SKETCH = _pcbnew.SKETCH

FILLED = _pcbnew.FILLED

class KIID(object):
    r"""Proxy of C++ KIID 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__(KIID self) -> KIID
        __init__(KIID self, int null) -> KIID
        __init__(KIID self, wxString aString) -> KIID
        __init__(KIID self, timestamp_t aTimestamp) -> KIID
        """
        _pcbnew.KIID_swiginit(self, _pcbnew.new_KIID(*args))

    def Clone(self, aUUID: "KIID") -> "void":
        r"""Clone(KIID self, KIID aUUID)"""
        return _pcbnew.KIID_Clone(self, aUUID)

    def Hash(self) -> "size_t":
        r"""Hash(KIID self) -> size_t"""
        return _pcbnew.KIID_Hash(self)

    def IsLegacyTimestamp(self) -> "bool":
        r"""IsLegacyTimestamp(KIID self) -> bool"""
        return _pcbnew.KIID_IsLegacyTimestamp(self)

    def AsLegacyTimestamp(self) -> "timestamp_t":
        r"""AsLegacyTimestamp(KIID self) -> timestamp_t"""
        return _pcbnew.KIID_AsLegacyTimestamp(self)

    def AsString(self) -> "wxString":
        r"""AsString(KIID self) -> wxString"""
        return _pcbnew.KIID_AsString(self)

    def AsLegacyTimestampString(self) -> "wxString":
        r"""AsLegacyTimestampString(KIID self) -> wxString"""
        return _pcbnew.KIID_AsLegacyTimestampString(self)

    @staticmethod
    def SniffTest(aCandidate: "wxString") -> "bool":
        r"""SniffTest(wxString aCandidate) -> bool"""
        return _pcbnew.KIID_SniffTest(aCandidate)

    @staticmethod
    def CreateNilUuids(aNil: "bool"=True) -> "void":
        r"""CreateNilUuids(bool aNil=True)"""
        return _pcbnew.KIID_CreateNilUuids(aNil)

    @staticmethod
    def SeedGenerator(aSeed: "unsigned int") -> "void":
        r"""SeedGenerator(unsigned int aSeed)"""
        return _pcbnew.KIID_SeedGenerator(aSeed)

    def ConvertTimestampToUuid(self) -> "void":
        r"""ConvertTimestampToUuid(KIID self)"""
        return _pcbnew.KIID_ConvertTimestampToUuid(self)

    def Increment(self) -> "void":
        r"""Increment(KIID self)"""
        return _pcbnew.KIID_Increment(self)

    def __eq__(self, rhs: "KIID") -> "bool":
        r"""__eq__(KIID self, KIID rhs) -> bool"""
        return _pcbnew.KIID___eq__(self, rhs)

    def __ne__(self, rhs: "KIID") -> "bool":
        r"""__ne__(KIID self, KIID rhs) -> bool"""
        return _pcbnew.KIID___ne__(self, rhs)

    def __lt__(self, rhs: "KIID") -> "bool":
        r"""__lt__(KIID self, KIID rhs) -> bool"""
        return _pcbnew.KIID___lt__(self, rhs)

    def __gt__(self, rhs: "KIID") -> "bool":
        r"""__gt__(KIID self, KIID rhs) -> bool"""
        return _pcbnew.KIID___gt__(self, rhs)
    __swig_destroy__ = _pcbnew.delete_KIID

# Register KIID in _pcbnew:
_pcbnew.KIID_swigregister(KIID)

def KIID_SniffTest(aCandidate: "wxString") -> "bool":
    r"""KIID_SniffTest(wxString aCandidate) -> bool"""
    return _pcbnew.KIID_SniffTest(aCandidate)

def KIID_CreateNilUuids(aNil: "bool"=True) -> "void":
    r"""KIID_CreateNilUuids(bool aNil=True)"""
    return _pcbnew.KIID_CreateNilUuids(aNil)

def KIID_SeedGenerator(aSeed: "unsigned int") -> "void":
    r"""KIID_SeedGenerator(unsigned int aSeed)"""
    return _pcbnew.KIID_SeedGenerator(aSeed)


def NilUuid() -> "KIID &":
    r"""NilUuid() -> KIID"""
    return _pcbnew.NilUuid()
class KIID_VECT_LIST(object):
    r"""Proxy of C++ std::vector< KIID > 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) -> "swig::SwigPyIterator *":
        r"""iterator(KIID_VECT_LIST self) -> SwigPyIterator"""
        return _pcbnew.KIID_VECT_LIST_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(KIID_VECT_LIST self) -> bool"""
        return _pcbnew.KIID_VECT_LIST___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(KIID_VECT_LIST self) -> bool"""
        return _pcbnew.KIID_VECT_LIST___bool__(self)

    def __len__(self) -> "std::vector< KIID >::size_type":
        r"""__len__(KIID_VECT_LIST self) -> std::vector< KIID >::size_type"""
        return _pcbnew.KIID_VECT_LIST___len__(self)

    def __getslice__(self, i: "std::vector< KIID >::difference_type", j: "std::vector< KIID >::difference_type") -> "std::vector< KIID,std::allocator< KIID > > *":
        r"""__getslice__(KIID_VECT_LIST self, std::vector< KIID >::difference_type i, std::vector< KIID >::difference_type j) -> KIID_VECT_LIST"""
        return _pcbnew.KIID_VECT_LIST___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        r"""
        __setslice__(KIID_VECT_LIST self, std::vector< KIID >::difference_type i, std::vector< KIID >::difference_type j)
        __setslice__(KIID_VECT_LIST self, std::vector< KIID >::difference_type i, std::vector< KIID >::difference_type j, KIID_VECT_LIST v)
        """
        return _pcbnew.KIID_VECT_LIST___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< KIID >::difference_type", j: "std::vector< KIID >::difference_type") -> "void":
        r"""__delslice__(KIID_VECT_LIST self, std::vector< KIID >::difference_type i, std::vector< KIID >::difference_type j)"""
        return _pcbnew.KIID_VECT_LIST___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        r"""
        __delitem__(KIID_VECT_LIST self, std::vector< KIID >::difference_type i)
        __delitem__(KIID_VECT_LIST self, PySliceObject * slice)
        """
        return _pcbnew.KIID_VECT_LIST___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< KIID >::value_type const &":
        r"""
        __getitem__(KIID_VECT_LIST self, PySliceObject * slice) -> KIID_VECT_LIST
        __getitem__(KIID_VECT_LIST self, std::vector< KIID >::difference_type i) -> KIID
        """
        return _pcbnew.KIID_VECT_LIST___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(KIID_VECT_LIST self, PySliceObject * slice, KIID_VECT_LIST v)
        __setitem__(KIID_VECT_LIST self, PySliceObject * slice)
        __setitem__(KIID_VECT_LIST self, std::vector< KIID >::difference_type i, KIID x)
        """
        return _pcbnew.KIID_VECT_LIST___setitem__(self, *args)

    def pop(self) -> "std::vector< KIID >::value_type":
        r"""pop(KIID_VECT_LIST self) -> KIID"""
        return _pcbnew.KIID_VECT_LIST_pop(self)

    def append(self, x: "KIID") -> "void":
        r"""append(KIID_VECT_LIST self, KIID x)"""
        return _pcbnew.KIID_VECT_LIST_append(self, x)

    def empty(self) -> "bool":
        r"""empty(KIID_VECT_LIST self) -> bool"""
        return _pcbnew.KIID_VECT_LIST_empty(self)

    def size(self) -> "std::vector< KIID >::size_type":
        r"""size(KIID_VECT_LIST self) -> std::vector< KIID >::size_type"""
        return _pcbnew.KIID_VECT_LIST_size(self)

    def swap(self, v: "KIID_VECT_LIST") -> "void":
        r"""swap(KIID_VECT_LIST self, KIID_VECT_LIST v)"""
        return _pcbnew.KIID_VECT_LIST_swap(self, v)

    def begin(self) -> "std::vector< KIID >::iterator":
        r"""begin(KIID_VECT_LIST self) -> std::vector< KIID >::iterator"""
        return _pcbnew.KIID_VECT_LIST_begin(self)

    def end(self) -> "std::vector< KIID >::iterator":
        r"""end(KIID_VECT_LIST self) -> std::vector< KIID >::iterator"""
        return _pcbnew.KIID_VECT_LIST_end(self)

    def rbegin(self) -> "std::vector< KIID >::reverse_iterator":
        r"""rbegin(KIID_VECT_LIST self) -> std::vector< KIID >::reverse_iterator"""
        return _pcbnew.KIID_VECT_LIST_rbegin(self)

    def rend(self) -> "std::vector< KIID >::reverse_iterator":
        r"""rend(KIID_VECT_LIST self) -> std::vector< KIID >::reverse_iterator"""
        return _pcbnew.KIID_VECT_LIST_rend(self)

    def clear(self) -> "void":
        r"""clear(KIID_VECT_LIST self)"""
        return _pcbnew.KIID_VECT_LIST_clear(self)

    def get_allocator(self) -> "std::vector< KIID >::allocator_type":
        r"""get_allocator(KIID_VECT_LIST self) -> std::vector< KIID >::allocator_type"""
        return _pcbnew.KIID_VECT_LIST_get_allocator(self)

    def pop_back(self) -> "void":
        r"""pop_back(KIID_VECT_LIST self)"""
        return _pcbnew.KIID_VECT_LIST_pop_back(self)

    def erase(self, *args) -> "std::vector< KIID >::iterator":
        r"""
        erase(KIID_VECT_LIST self, std::vector< KIID >::iterator pos) -> std::vector< KIID >::iterator
        erase(KIID_VECT_LIST self, std::vector< KIID >::iterator first, std::vector< KIID >::iterator last) -> std::vector< KIID >::iterator
        """
        return _pcbnew.KIID_VECT_LIST_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(KIID_VECT_LIST self) -> KIID_VECT_LIST
        __init__(KIID_VECT_LIST self, KIID_VECT_LIST other) -> KIID_VECT_LIST
        __init__(KIID_VECT_LIST self, std::vector< KIID >::size_type size) -> KIID_VECT_LIST
        __init__(KIID_VECT_LIST self, std::vector< KIID >::size_type size, KIID value) -> KIID_VECT_LIST
        """
        _pcbnew.KIID_VECT_LIST_swiginit(self, _pcbnew.new_KIID_VECT_LIST(*args))

    def push_back(self, x: "KIID") -> "void":
        r"""push_back(KIID_VECT_LIST self, KIID x)"""
        return _pcbnew.KIID_VECT_LIST_push_back(self, x)

    def front(self) -> "std::vector< KIID >::value_type const &":
        r"""front(KIID_VECT_LIST self) -> KIID"""
        return _pcbnew.KIID_VECT_LIST_front(self)

    def back(self) -> "std::vector< KIID >::value_type const &":
        r"""back(KIID_VECT_LIST self) -> KIID"""
        return _pcbnew.KIID_VECT_LIST_back(self)

    def assign(self, n: "std::vector< KIID >::size_type", x: "KIID") -> "void":
        r"""assign(KIID_VECT_LIST self, std::vector< KIID >::size_type n, KIID x)"""
        return _pcbnew.KIID_VECT_LIST_assign(self, n, x)

    def resize(self, *args) -> "void":
        r"""
        resize(KIID_VECT_LIST self, std::vector< KIID >::size_type new_size)
        resize(KIID_VECT_LIST self, std::vector< KIID >::size_type new_size, KIID x)
        """
        return _pcbnew.KIID_VECT_LIST_resize(self, *args)

    def insert(self, *args) -> "void":
        r"""
        insert(KIID_VECT_LIST self, std::vector< KIID >::iterator pos, KIID x) -> std::vector< KIID >::iterator
        insert(KIID_VECT_LIST self, std::vector< KIID >::iterator pos, std::vector< KIID >::size_type n, KIID x)
        """
        return _pcbnew.KIID_VECT_LIST_insert(self, *args)

    def reserve(self, n: "std::vector< KIID >::size_type") -> "void":
        r"""reserve(KIID_VECT_LIST self, std::vector< KIID >::size_type n)"""
        return _pcbnew.KIID_VECT_LIST_reserve(self, n)

    def capacity(self) -> "std::vector< KIID >::size_type":
        r"""capacity(KIID_VECT_LIST self) -> std::vector< KIID >::size_type"""
        return _pcbnew.KIID_VECT_LIST_capacity(self)
    __swig_destroy__ = _pcbnew.delete_KIID_VECT_LIST

# Register KIID_VECT_LIST in _pcbnew:
_pcbnew.KIID_VECT_LIST_swigregister(KIID_VECT_LIST)

class KIID_PATH(KIID_VECT_LIST):
    r"""Proxy of C++ KIID_PATH 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__(KIID_PATH self) -> KIID_PATH
        __init__(KIID_PATH self, wxString aString) -> KIID_PATH
        """
        _pcbnew.KIID_PATH_swiginit(self, _pcbnew.new_KIID_PATH(*args))

    def MakeRelativeTo(self, aPath: "KIID_PATH") -> "bool":
        r"""MakeRelativeTo(KIID_PATH self, KIID_PATH aPath) -> bool"""
        return _pcbnew.KIID_PATH_MakeRelativeTo(self, aPath)

    def AsString(self) -> "wxString":
        r"""AsString(KIID_PATH self) -> wxString"""
        return _pcbnew.KIID_PATH_AsString(self)

    def __eq__(self, rhs: "KIID_PATH") -> "bool":
        r"""__eq__(KIID_PATH self, KIID_PATH rhs) -> bool"""
        return _pcbnew.KIID_PATH___eq__(self, rhs)

    def __lt__(self, rhs: "KIID_PATH") -> "bool":
        r"""__lt__(KIID_PATH self, KIID_PATH rhs) -> bool"""
        return _pcbnew.KIID_PATH___lt__(self, rhs)
    __swig_destroy__ = _pcbnew.delete_KIID_PATH

# Register KIID_PATH in _pcbnew:
_pcbnew.KIID_PATH_swigregister(KIID_PATH)

NOT_USED = _pcbnew.NOT_USED

EOT = _pcbnew.EOT

TYPE_NOT_INIT = _pcbnew.TYPE_NOT_INIT

PCB_T = _pcbnew.PCB_T

SCREEN_T = _pcbnew.SCREEN_T

PCB_FOOTPRINT_T = _pcbnew.PCB_FOOTPRINT_T

PCB_PAD_T = _pcbnew.PCB_PAD_T

PCB_SHAPE_T = _pcbnew.PCB_SHAPE_T

PCB_TEXT_T = _pcbnew.PCB_TEXT_T

PCB_FP_TEXT_T = _pcbnew.PCB_FP_TEXT_T

PCB_FP_SHAPE_T = _pcbnew.PCB_FP_SHAPE_T

PCB_FP_ZONE_T = _pcbnew.PCB_FP_ZONE_T

PCB_TRACE_T = _pcbnew.PCB_TRACE_T

PCB_VIA_T = _pcbnew.PCB_VIA_T

PCB_ARC_T = _pcbnew.PCB_ARC_T

PCB_MARKER_T = _pcbnew.PCB_MARKER_T

PCB_DIMENSION_T = _pcbnew.PCB_DIMENSION_T

PCB_DIM_ALIGNED_T = _pcbnew.PCB_DIM_ALIGNED_T

PCB_DIM_LEADER_T = _pcbnew.PCB_DIM_LEADER_T

PCB_DIM_CENTER_T = _pcbnew.PCB_DIM_CENTER_T

PCB_DIM_ORTHOGONAL_T = _pcbnew.PCB_DIM_ORTHOGONAL_T

PCB_TARGET_T = _pcbnew.PCB_TARGET_T

PCB_ZONE_T = _pcbnew.PCB_ZONE_T

PCB_ITEM_LIST_T = _pcbnew.PCB_ITEM_LIST_T

PCB_NETINFO_T = _pcbnew.PCB_NETINFO_T

PCB_GROUP_T = _pcbnew.PCB_GROUP_T

PCB_LOCATE_STDVIA_T = _pcbnew.PCB_LOCATE_STDVIA_T

PCB_LOCATE_UVIA_T = _pcbnew.PCB_LOCATE_UVIA_T

PCB_LOCATE_BBVIA_T = _pcbnew.PCB_LOCATE_BBVIA_T

PCB_LOCATE_TEXT_T = _pcbnew.PCB_LOCATE_TEXT_T

PCB_LOCATE_GRAPHIC_T = _pcbnew.PCB_LOCATE_GRAPHIC_T

PCB_LOCATE_HOLE_T = _pcbnew.PCB_LOCATE_HOLE_T

PCB_LOCATE_PTH_T = _pcbnew.PCB_LOCATE_PTH_T

PCB_LOCATE_NPTH_T = _pcbnew.PCB_LOCATE_NPTH_T

PCB_LOCATE_BOARD_EDGE_T = _pcbnew.PCB_LOCATE_BOARD_EDGE_T

SCH_MARKER_T = _pcbnew.SCH_MARKER_T

SCH_JUNCTION_T = _pcbnew.SCH_JUNCTION_T

SCH_NO_CONNECT_T = _pcbnew.SCH_NO_CONNECT_T

SCH_BUS_WIRE_ENTRY_T = _pcbnew.SCH_BUS_WIRE_ENTRY_T

SCH_BUS_BUS_ENTRY_T = _pcbnew.SCH_BUS_BUS_ENTRY_T

SCH_LINE_T = _pcbnew.SCH_LINE_T

SCH_BITMAP_T = _pcbnew.SCH_BITMAP_T

SCH_TEXT_T = _pcbnew.SCH_TEXT_T

SCH_LABEL_T = _pcbnew.SCH_LABEL_T

SCH_GLOBAL_LABEL_T = _pcbnew.SCH_GLOBAL_LABEL_T

SCH_HIER_LABEL_T = _pcbnew.SCH_HIER_LABEL_T

SCH_FIELD_T = _pcbnew.SCH_FIELD_T

SCH_SYMBOL_T = _pcbnew.SCH_SYMBOL_T

SCH_SHEET_PIN_T = _pcbnew.SCH_SHEET_PIN_T

SCH_SHEET_T = _pcbnew.SCH_SHEET_T

SCH_PIN_T = _pcbnew.SCH_PIN_T

SCH_FIELD_LOCATE_REFERENCE_T = _pcbnew.SCH_FIELD_LOCATE_REFERENCE_T

SCH_FIELD_LOCATE_VALUE_T = _pcbnew.SCH_FIELD_LOCATE_VALUE_T

SCH_FIELD_LOCATE_FOOTPRINT_T = _pcbnew.SCH_FIELD_LOCATE_FOOTPRINT_T

SCH_FIELD_LOCATE_DATASHEET_T = _pcbnew.SCH_FIELD_LOCATE_DATASHEET_T

SCH_LINE_LOCATE_WIRE_T = _pcbnew.SCH_LINE_LOCATE_WIRE_T

SCH_LINE_LOCATE_BUS_T = _pcbnew.SCH_LINE_LOCATE_BUS_T

SCH_LINE_LOCATE_GRAPHIC_LINE_T = _pcbnew.SCH_LINE_LOCATE_GRAPHIC_LINE_T

SCH_LABEL_LOCATE_WIRE_T = _pcbnew.SCH_LABEL_LOCATE_WIRE_T

SCH_LABEL_LOCATE_BUS_T = _pcbnew.SCH_LABEL_LOCATE_BUS_T

SCH_SYMBOL_LOCATE_POWER_T = _pcbnew.SCH_SYMBOL_LOCATE_POWER_T

SCH_LOCATE_ANY_T = _pcbnew.SCH_LOCATE_ANY_T

SCH_SCREEN_T = _pcbnew.SCH_SCREEN_T

SCHEMATIC_T = _pcbnew.SCHEMATIC_T

LIB_SYMBOL_T = _pcbnew.LIB_SYMBOL_T

LIB_ALIAS_T = _pcbnew.LIB_ALIAS_T

LIB_SHAPE_T = _pcbnew.LIB_SHAPE_T

LIB_TEXT_T = _pcbnew.LIB_TEXT_T

LIB_PIN_T = _pcbnew.LIB_PIN_T

LIB_FIELD_T = _pcbnew.LIB_FIELD_T

GERBER_LAYOUT_T = _pcbnew.GERBER_LAYOUT_T

GERBER_DRAW_ITEM_T = _pcbnew.GERBER_DRAW_ITEM_T

GERBER_IMAGE_T = _pcbnew.GERBER_IMAGE_T

WSG_LINE_T = _pcbnew.WSG_LINE_T

WSG_RECT_T = _pcbnew.WSG_RECT_T

WSG_POLY_T = _pcbnew.WSG_POLY_T

WSG_TEXT_T = _pcbnew.WSG_TEXT_T

WSG_BITMAP_T = _pcbnew.WSG_BITMAP_T

WSG_PAGE_T = _pcbnew.WSG_PAGE_T

WS_PROXY_UNDO_ITEM_T = _pcbnew.WS_PROXY_UNDO_ITEM_T

WS_PROXY_UNDO_ITEM_PLUS_T = _pcbnew.WS_PROXY_UNDO_ITEM_PLUS_T

SYMBOL_LIB_TABLE_T = _pcbnew.SYMBOL_LIB_TABLE_T

FP_LIB_TABLE_T = _pcbnew.FP_LIB_TABLE_T

SYMBOL_LIBS_T = _pcbnew.SYMBOL_LIBS_T

SEARCH_STACK_T = _pcbnew.SEARCH_STACK_T

S3D_CACHE_T = _pcbnew.S3D_CACHE_T

MAX_STRUCT_TYPE_ID = _pcbnew.MAX_STRUCT_TYPE_ID


def BaseType(aType: "KICAD_T const") -> "KICAD_T":
    r"""BaseType(KICAD_T const aType) -> KICAD_T"""
    return _pcbnew.BaseType(aType)

def IsNullType(aType: "KICAD_T const") -> "bool":
    r"""IsNullType(KICAD_T const aType) -> bool"""
    return _pcbnew.IsNullType(aType)

def IsInstantiableType(aType: "KICAD_T const") -> "bool":
    r"""IsInstantiableType(KICAD_T const aType) -> bool"""
    return _pcbnew.IsInstantiableType(aType)

def IsEeschemaType(aType: "KICAD_T const") -> "bool":
    r"""IsEeschemaType(KICAD_T const aType) -> bool"""
    return _pcbnew.IsEeschemaType(aType)

def IsPcbnewType(aType: "KICAD_T const") -> "bool":
    r"""IsPcbnewType(KICAD_T const aType) -> bool"""
    return _pcbnew.IsPcbnewType(aType)

def IsGerbviewType(aType: "KICAD_T const") -> "bool":
    r"""IsGerbviewType(KICAD_T const aType) -> bool"""
    return _pcbnew.IsGerbviewType(aType)

def IsPageLayoutEditorType(aType: "KICAD_T const") -> "bool":
    r"""IsPageLayoutEditorType(KICAD_T const aType) -> bool"""
    return _pcbnew.IsPageLayoutEditorType(aType)

def IsMiscType(aType: "KICAD_T const") -> "bool":
    r"""IsMiscType(KICAD_T const aType) -> bool"""
    return _pcbnew.IsMiscType(aType)

def IsTypeCorrect(aType: "KICAD_T") -> "bool":
    r"""IsTypeCorrect(KICAD_T aType) -> bool"""
    return _pcbnew.IsTypeCorrect(aType)

def IsTypeAvailable(aType: "KICAD_T") -> "bool":
    r"""IsTypeAvailable(KICAD_T aType) -> bool"""
    return _pcbnew.IsTypeAvailable(aType)
SEARCH_RESULT_QUIT = _pcbnew.SEARCH_RESULT_QUIT

SEARCH_RESULT_CONTINUE = _pcbnew.SEARCH_RESULT_CONTINUE

FR_CURRENT_SHEET_ONLY = _pcbnew.FR_CURRENT_SHEET_ONLY

FR_SEARCH_ALL_FIELDS = _pcbnew.FR_SEARCH_ALL_FIELDS

FR_SEARCH_ALL_PINS = _pcbnew.FR_SEARCH_ALL_PINS

FR_MATCH_WILDCARD = _pcbnew.FR_MATCH_WILDCARD

FR_SEARCH_WRAP = _pcbnew.FR_SEARCH_WRAP

FR_SEARCH_REPLACE = _pcbnew.FR_SEARCH_REPLACE

FR_REPLACE_ITEM_FOUND = _pcbnew.FR_REPLACE_ITEM_FOUND

FR_REPLACE_REFERENCES = _pcbnew.FR_REPLACE_REFERENCES

class EDA_ITEM(object):
    r"""Proxy of C++ EDA_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__ = _pcbnew.delete_EDA_ITEM

    def Type(self) -> "KICAD_T":
        r"""Type(EDA_ITEM self) -> KICAD_T"""
        return _pcbnew.EDA_ITEM_Type(self)

    def GetParent(self) -> "EDA_ITEM *":
        r"""GetParent(EDA_ITEM self) -> EDA_ITEM"""
        return _pcbnew.EDA_ITEM_GetParent(self)

    def SetParent(self, aParent: "EDA_ITEM") -> "void":
        r"""SetParent(EDA_ITEM self, EDA_ITEM aParent)"""
        return _pcbnew.EDA_ITEM_SetParent(self, aParent)

    def IsModified(self) -> "bool":
        r"""IsModified(EDA_ITEM self) -> bool"""
        return _pcbnew.EDA_ITEM_IsModified(self)

    def IsNew(self) -> "bool":
        r"""IsNew(EDA_ITEM self) -> bool"""
        return _pcbnew.EDA_ITEM_IsNew(self)

    def IsMoving(self) -> "bool":
        r"""IsMoving(EDA_ITEM self) -> bool"""
        return _pcbnew.EDA_ITEM_IsMoving(self)

    def IsDragging(self) -> "bool":
        r"""IsDragging(EDA_ITEM self) -> bool"""
        return _pcbnew.EDA_ITEM_IsDragging(self)

    def IsWireImage(self) -> "bool":
        r"""IsWireImage(EDA_ITEM self) -> bool"""
        return _pcbnew.EDA_ITEM_IsWireImage(self)

    def IsSelected(self) -> "bool":
        r"""IsSelected(EDA_ITEM self) -> bool"""
        return _pcbnew.EDA_ITEM_IsSelected(self)

    def IsEntered(self) -> "bool":
        r"""IsEntered(EDA_ITEM self) -> bool"""
        return _pcbnew.EDA_ITEM_IsEntered(self)

    def IsResized(self) -> "bool":
        r"""IsResized(EDA_ITEM self) -> bool"""
        return _pcbnew.EDA_ITEM_IsResized(self)

    def IsBrightened(self) -> "bool":
        r"""IsBrightened(EDA_ITEM self) -> bool"""
        return _pcbnew.EDA_ITEM_IsBrightened(self)

    def SetWireImage(self) -> "void":
        r"""SetWireImage(EDA_ITEM self)"""
        return _pcbnew.EDA_ITEM_SetWireImage(self)

    def SetSelected(self) -> "void":
        r"""SetSelected(EDA_ITEM self)"""
        return _pcbnew.EDA_ITEM_SetSelected(self)

    def SetBrightened(self) -> "void":
        r"""SetBrightened(EDA_ITEM self)"""
        return _pcbnew.EDA_ITEM_SetBrightened(self)

    def ClearSelected(self) -> "void":
        r"""ClearSelected(EDA_ITEM self)"""
        return _pcbnew.EDA_ITEM_ClearSelected(self)

    def ClearBrightened(self) -> "void":
        r"""ClearBrightened(EDA_ITEM self)"""
        return _pcbnew.EDA_ITEM_ClearBrightened(self)

    def SetModified(self) -> "void":
        r"""SetModified(EDA_ITEM self)"""
        return _pcbnew.EDA_ITEM_SetModified(self)

    def GetState(self, type: "EDA_ITEM_FLAGS") -> "int":
        r"""GetState(EDA_ITEM self, EDA_ITEM_FLAGS type) -> int"""
        return _pcbnew.EDA_ITEM_GetState(self, type)

    def SetState(self, type: "EDA_ITEM_FLAGS", state: "bool") -> "void":
        r"""SetState(EDA_ITEM self, EDA_ITEM_FLAGS type, bool state)"""
        return _pcbnew.EDA_ITEM_SetState(self, type, state)

    def GetStatus(self) -> "EDA_ITEM_FLAGS":
        r"""GetStatus(EDA_ITEM self) -> EDA_ITEM_FLAGS"""
        return _pcbnew.EDA_ITEM_GetStatus(self)

    def SetStatus(self, aStatus: "EDA_ITEM_FLAGS") -> "void":
        r"""SetStatus(EDA_ITEM self, EDA_ITEM_FLAGS aStatus)"""
        return _pcbnew.EDA_ITEM_SetStatus(self, aStatus)

    def SetFlags(self, aMask: "EDA_ITEM_FLAGS") -> "void":
        r"""SetFlags(EDA_ITEM self, EDA_ITEM_FLAGS aMask)"""
        return _pcbnew.EDA_ITEM_SetFlags(self, aMask)

    def ClearFlags(self, *args) -> "void":
        r"""ClearFlags(EDA_ITEM self, EDA_ITEM_FLAGS aMask=EDA_ITEM_ALL_FLAGS)"""
        return _pcbnew.EDA_ITEM_ClearFlags(self, *args)

    def GetFlags(self) -> "EDA_ITEM_FLAGS":
        r"""GetFlags(EDA_ITEM self) -> EDA_ITEM_FLAGS"""
        return _pcbnew.EDA_ITEM_GetFlags(self)

    def HasFlag(self, aFlag: "EDA_ITEM_FLAGS") -> "bool":
        r"""HasFlag(EDA_ITEM self, EDA_ITEM_FLAGS aFlag) -> bool"""
        return _pcbnew.EDA_ITEM_HasFlag(self, aFlag)

    def GetEditFlags(self) -> "EDA_ITEM_FLAGS":
        r"""GetEditFlags(EDA_ITEM self) -> EDA_ITEM_FLAGS"""
        return _pcbnew.EDA_ITEM_GetEditFlags(self)

    def ClearTempFlags(self) -> "void":
        r"""ClearTempFlags(EDA_ITEM self)"""
        return _pcbnew.EDA_ITEM_ClearTempFlags(self)

    def ClearEditFlags(self) -> "void":
        r"""ClearEditFlags(EDA_ITEM self)"""
        return _pcbnew.EDA_ITEM_ClearEditFlags(self)

    def IsType(self, aScanTypes: "KICAD_T const []") -> "bool":
        r"""IsType(EDA_ITEM self, KICAD_T const [] aScanTypes) -> bool"""
        return _pcbnew.EDA_ITEM_IsType(self, aScanTypes)

    def SetForceVisible(self, aEnable: "bool") -> "void":
        r"""SetForceVisible(EDA_ITEM self, bool aEnable)"""
        return _pcbnew.EDA_ITEM_SetForceVisible(self, aEnable)

    def IsForceVisible(self) -> "bool":
        r"""IsForceVisible(EDA_ITEM self) -> bool"""
        return _pcbnew.EDA_ITEM_IsForceVisible(self)

    def GetMsgPanelInfo(self, aFrame: "EDA_DRAW_FRAME *", aList: "std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > &") -> "void":
        r"""GetMsgPanelInfo(EDA_ITEM self, EDA_DRAW_FRAME * aFrame, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.EDA_ITEM_GetMsgPanelInfo(self, aFrame, aList)

    def HitTest(self, *args) -> "bool":
        r"""
        HitTest(EDA_ITEM self, wxPoint aPosition, int aAccuracy=0) -> bool
        HitTest(EDA_ITEM self, EDA_RECT aRect, bool aContained, int aAccuracy=0) -> bool
        """
        return _pcbnew.EDA_ITEM_HitTest(self, *args)

    def GetBoundingBox(self) -> "EDA_RECT const":
        r"""GetBoundingBox(EDA_ITEM self) -> EDA_RECT"""
        return _pcbnew.EDA_ITEM_GetBoundingBox(self)

    def GetPosition(self) -> "wxPoint":
        r"""GetPosition(EDA_ITEM self) -> wxPoint"""
        return _pcbnew.EDA_ITEM_GetPosition(self)

    def SetPosition(self, aPos: "wxPoint") -> "void":
        r"""SetPosition(EDA_ITEM self, wxPoint aPos)"""
        return _pcbnew.EDA_ITEM_SetPosition(self, aPos)

    def GetFocusPosition(self) -> "wxPoint const":
        r"""GetFocusPosition(EDA_ITEM self) -> wxPoint"""
        return _pcbnew.EDA_ITEM_GetFocusPosition(self)

    def Clone(self) -> "EDA_ITEM *":
        r"""Clone(EDA_ITEM self) -> EDA_ITEM"""
        return _pcbnew.EDA_ITEM_Clone(self)

    def Visit(self, inspector: "INSPECTOR", testData: "void *", scanTypes: "KICAD_T const []") -> "SEARCH_RESULT":
        r"""Visit(EDA_ITEM self, INSPECTOR inspector, void * testData, KICAD_T const [] scanTypes) -> SEARCH_RESULT"""
        return _pcbnew.EDA_ITEM_Visit(self, inspector, testData, scanTypes)

    def GetClass(self) -> "wxString":
        r"""GetClass(EDA_ITEM self) -> wxString"""
        return _pcbnew.EDA_ITEM_GetClass(self)

    def GetSelectMenuText(self, aUnits: "EDA_UNITS") -> "wxString":
        r"""GetSelectMenuText(EDA_ITEM self, EDA_UNITS aUnits) -> wxString"""
        return _pcbnew.EDA_ITEM_GetSelectMenuText(self, aUnits)

    def GetMenuImage(self) -> "BITMAPS":
        r"""GetMenuImage(EDA_ITEM self) -> BITMAPS"""
        return _pcbnew.EDA_ITEM_GetMenuImage(self)

    def Matches(self, aSearchData: "wxFindReplaceData const &", aAuxData: "void *") -> "bool":
        r"""Matches(EDA_ITEM self, wxFindReplaceData const & aSearchData, void * aAuxData) -> bool"""
        return _pcbnew.EDA_ITEM_Matches(self, aSearchData, aAuxData)

    def Replace(self, *args) -> "bool":
        r"""
        Replace(EDA_ITEM self, wxFindReplaceData const & aSearchData, wxString aText) -> bool
        Replace(EDA_ITEM self, wxFindReplaceData const & aSearchData, void * aAuxData=None) -> bool
        """
        return _pcbnew.EDA_ITEM_Replace(self, *args)

    def IsReplaceable(self) -> "bool":
        r"""IsReplaceable(EDA_ITEM self) -> bool"""
        return _pcbnew.EDA_ITEM_IsReplaceable(self)

    def __lt__(self, aItem: "EDA_ITEM") -> "bool":
        r"""__lt__(EDA_ITEM self, EDA_ITEM aItem) -> bool"""
        return _pcbnew.EDA_ITEM___lt__(self, aItem)

    @staticmethod
    def Sort(aLeft: "EDA_ITEM", aRight: "EDA_ITEM") -> "bool":
        r"""Sort(EDA_ITEM aLeft, EDA_ITEM aRight) -> bool"""
        return _pcbnew.EDA_ITEM_Sort(aLeft, aRight)

    def ViewBBox(self) -> "BOX2I const":
        r"""ViewBBox(EDA_ITEM self) -> BOX2I const"""
        return _pcbnew.EDA_ITEM_ViewBBox(self)

    def ViewGetLayers(self, aLayers: "int []", aCount: "int &") -> "void":
        r"""ViewGetLayers(EDA_ITEM self, int [] aLayers, int & aCount)"""
        return _pcbnew.EDA_ITEM_ViewGetLayers(self, aLayers, aCount)
    m_Uuid = property(_pcbnew.EDA_ITEM_m_Uuid_get, doc=r"""m_Uuid : q(const).KIID""")

# Register EDA_ITEM in _pcbnew:
_pcbnew.EDA_ITEM_swigregister(EDA_ITEM)

def EDA_ITEM_Sort(aLeft: "EDA_ITEM", aRight: "EDA_ITEM") -> "bool":
    r"""EDA_ITEM_Sort(EDA_ITEM aLeft, EDA_ITEM aRight) -> bool"""
    return _pcbnew.EDA_ITEM_Sort(aLeft, aRight)


def new_clone(aItem: "EDA_ITEM") -> "EDA_ITEM *":
    r"""new_clone(EDA_ITEM aItem) -> EDA_ITEM"""
    return _pcbnew.new_clone(aItem)
class EDA_RECT(object):
    r"""Proxy of C++ EDA_RECT 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__(EDA_RECT self) -> EDA_RECT
        __init__(EDA_RECT self, wxPoint aPos, wxSize aSize) -> EDA_RECT
        """
        _pcbnew.EDA_RECT_swiginit(self, _pcbnew.new_EDA_RECT(*args))
    __swig_destroy__ = _pcbnew.delete_EDA_RECT

    def Centre(self) -> "wxPoint":
        r"""Centre(EDA_RECT self) -> wxPoint"""
        return _pcbnew.EDA_RECT_Centre(self)

    def Move(self, aMoveVector: "wxPoint") -> "void":
        r"""Move(EDA_RECT self, wxPoint aMoveVector)"""
        return _pcbnew.EDA_RECT_Move(self, aMoveVector)

    def Normalize(self) -> "void":
        r"""Normalize(EDA_RECT self)"""
        return _pcbnew.EDA_RECT_Normalize(self)

    def Contains(self, *args) -> "bool":
        r"""
        Contains(EDA_RECT self, wxPoint aPoint) -> bool
        Contains(EDA_RECT self, int x, int y) -> bool
        Contains(EDA_RECT self, EDA_RECT aRect) -> bool
        """
        return _pcbnew.EDA_RECT_Contains(self, *args)

    def GetSize(self) -> "wxSize const":
        r"""GetSize(EDA_RECT self) -> wxSize"""
        return _pcbnew.EDA_RECT_GetSize(self)

    def GetSizeMax(self) -> "int":
        r"""GetSizeMax(EDA_RECT self) -> int"""
        return _pcbnew.EDA_RECT_GetSizeMax(self)

    def GetX(self) -> "int":
        r"""GetX(EDA_RECT self) -> int"""
        return _pcbnew.EDA_RECT_GetX(self)

    def GetY(self) -> "int":
        r"""GetY(EDA_RECT self) -> int"""
        return _pcbnew.EDA_RECT_GetY(self)

    def GetOrigin(self) -> "wxPoint const":
        r"""GetOrigin(EDA_RECT self) -> wxPoint"""
        return _pcbnew.EDA_RECT_GetOrigin(self)

    def GetPosition(self) -> "wxPoint const":
        r"""GetPosition(EDA_RECT self) -> wxPoint"""
        return _pcbnew.EDA_RECT_GetPosition(self)

    def GetEnd(self) -> "wxPoint const":
        r"""GetEnd(EDA_RECT self) -> wxPoint"""
        return _pcbnew.EDA_RECT_GetEnd(self)

    def GetCenter(self) -> "wxPoint const":
        r"""GetCenter(EDA_RECT self) -> wxPoint"""
        return _pcbnew.EDA_RECT_GetCenter(self)

    def GetWidth(self) -> "int":
        r"""GetWidth(EDA_RECT self) -> int"""
        return _pcbnew.EDA_RECT_GetWidth(self)

    def GetHeight(self) -> "int":
        r"""GetHeight(EDA_RECT self) -> int"""
        return _pcbnew.EDA_RECT_GetHeight(self)

    def GetRight(self) -> "int":
        r"""GetRight(EDA_RECT self) -> int"""
        return _pcbnew.EDA_RECT_GetRight(self)

    def GetLeft(self) -> "int":
        r"""GetLeft(EDA_RECT self) -> int"""
        return _pcbnew.EDA_RECT_GetLeft(self)

    def GetTop(self) -> "int":
        r"""GetTop(EDA_RECT self) -> int"""
        return _pcbnew.EDA_RECT_GetTop(self)

    def GetBottom(self) -> "int":
        r"""GetBottom(EDA_RECT self) -> int"""
        return _pcbnew.EDA_RECT_GetBottom(self)

    def IsValid(self) -> "bool":
        r"""IsValid(EDA_RECT self) -> bool"""
        return _pcbnew.EDA_RECT_IsValid(self)

    def SetOrigin(self, *args) -> "void":
        r"""
        SetOrigin(EDA_RECT self, wxPoint pos)
        SetOrigin(EDA_RECT self, int x, int y)
        """
        return _pcbnew.EDA_RECT_SetOrigin(self, *args)

    def SetSize(self, *args) -> "void":
        r"""
        SetSize(EDA_RECT self, wxSize size)
        SetSize(EDA_RECT self, int w, int h)
        """
        return _pcbnew.EDA_RECT_SetSize(self, *args)

    def Offset(self, *args) -> "void":
        r"""
        Offset(EDA_RECT self, int dx, int dy)
        Offset(EDA_RECT self, wxPoint offset)
        """
        return _pcbnew.EDA_RECT_Offset(self, *args)

    def SetX(self, val: "int") -> "void":
        r"""SetX(EDA_RECT self, int val)"""
        return _pcbnew.EDA_RECT_SetX(self, val)

    def SetY(self, val: "int") -> "void":
        r"""SetY(EDA_RECT self, int val)"""
        return _pcbnew.EDA_RECT_SetY(self, val)

    def SetWidth(self, val: "int") -> "void":
        r"""SetWidth(EDA_RECT self, int val)"""
        return _pcbnew.EDA_RECT_SetWidth(self, val)

    def SetHeight(self, val: "int") -> "void":
        r"""SetHeight(EDA_RECT self, int val)"""
        return _pcbnew.EDA_RECT_SetHeight(self, val)

    def SetEnd(self, *args) -> "void":
        r"""
        SetEnd(EDA_RECT self, int x, int y)
        SetEnd(EDA_RECT self, wxPoint pos)
        """
        return _pcbnew.EDA_RECT_SetEnd(self, *args)

    def RevertYAxis(self) -> "void":
        r"""RevertYAxis(EDA_RECT self)"""
        return _pcbnew.EDA_RECT_RevertYAxis(self)

    def Intersects(self, *args) -> "bool":
        r"""
        Intersects(EDA_RECT self, EDA_RECT aRect) -> bool
        Intersects(EDA_RECT self, EDA_RECT aRect, double aRot) -> bool
        Intersects(EDA_RECT self, wxPoint aPoint1, wxPoint aPoint2) -> bool
        Intersects(EDA_RECT self, wxPoint aPoint1, wxPoint aPoint2, wxPoint aIntersection1, wxPoint aIntersection2) -> bool
        """
        return _pcbnew.EDA_RECT_Intersects(self, *args)

    def ClosestPointTo(self, aPoint: "wxPoint") -> "wxPoint const":
        r"""ClosestPointTo(EDA_RECT self, wxPoint aPoint) -> wxPoint"""
        return _pcbnew.EDA_RECT_ClosestPointTo(self, aPoint)

    def FarthestPointTo(self, aPoint: "wxPoint") -> "wxPoint const":
        r"""FarthestPointTo(EDA_RECT self, wxPoint aPoint) -> wxPoint"""
        return _pcbnew.EDA_RECT_FarthestPointTo(self, aPoint)

    def IntersectsCircle(self, aCenter: "wxPoint", aRadius: "int const") -> "bool":
        r"""IntersectsCircle(EDA_RECT self, wxPoint aCenter, int const aRadius) -> bool"""
        return _pcbnew.EDA_RECT_IntersectsCircle(self, aCenter, aRadius)

    def IntersectsCircleEdge(self, aCenter: "wxPoint", aRadius: "int const", aWidth: "int const") -> "bool":
        r"""IntersectsCircleEdge(EDA_RECT self, wxPoint aCenter, int const aRadius, int const aWidth) -> bool"""
        return _pcbnew.EDA_RECT_IntersectsCircleEdge(self, aCenter, aRadius, aWidth)

    def getWxRect(self) -> "wxRect":
        r"""getWxRect(EDA_RECT self) -> wxRect"""
        return _pcbnew.EDA_RECT_getWxRect(self)

    def getBOX2I(self) -> "BOX2I":
        r"""getBOX2I(EDA_RECT self) -> BOX2I"""
        return _pcbnew.EDA_RECT_getBOX2I(self)

    def Inflate(self, *args) -> "EDA_RECT &":
        r"""
        Inflate(EDA_RECT self, wxCoord dx, wxCoord dy) -> EDA_RECT
        Inflate(EDA_RECT self, int aDelta) -> EDA_RECT
        """
        return _pcbnew.EDA_RECT_Inflate(self, *args)

    def Merge(self, *args) -> "void":
        r"""
        Merge(EDA_RECT self, EDA_RECT aRect)
        Merge(EDA_RECT self, wxPoint aPoint)
        """
        return _pcbnew.EDA_RECT_Merge(self, *args)

    def GetArea(self) -> "double":
        r"""GetArea(EDA_RECT self) -> double"""
        return _pcbnew.EDA_RECT_GetArea(self)

    def Common(self, aRect: "EDA_RECT") -> "EDA_RECT":
        r"""Common(EDA_RECT self, EDA_RECT aRect) -> EDA_RECT"""
        return _pcbnew.EDA_RECT_Common(self, aRect)

    def GetBoundingBoxRotated(self, aRotCenter: "wxPoint", aAngle: "double") -> "EDA_RECT const":
        r"""GetBoundingBoxRotated(EDA_RECT self, wxPoint aRotCenter, double aAngle) -> EDA_RECT"""
        return _pcbnew.EDA_RECT_GetBoundingBoxRotated(self, aRotCenter, aAngle)

# Register EDA_RECT in _pcbnew:
_pcbnew.EDA_RECT_swigregister(EDA_RECT)

EDA_DATA_TYPE_DISTANCE = _pcbnew.EDA_DATA_TYPE_DISTANCE

EDA_DATA_TYPE_AREA = _pcbnew.EDA_DATA_TYPE_AREA

EDA_DATA_TYPE_VOLUME = _pcbnew.EDA_DATA_TYPE_VOLUME

EDA_UNITS_INCHES = _pcbnew.EDA_UNITS_INCHES

EDA_UNITS_MILLIMETRES = _pcbnew.EDA_UNITS_MILLIMETRES

EDA_UNITS_UNSCALED = _pcbnew.EDA_UNITS_UNSCALED

EDA_UNITS_DEGREES = _pcbnew.EDA_UNITS_DEGREES

EDA_UNITS_PERCENT = _pcbnew.EDA_UNITS_PERCENT

EDA_UNITS_MILS = _pcbnew.EDA_UNITS_MILS


def IsImperialUnit(aUnit: "EDA_UNITS") -> "bool":
    r"""IsImperialUnit(EDA_UNITS aUnit) -> bool"""
    return _pcbnew.IsImperialUnit(aUnit)

def IsMetricUnit(aUnit: "EDA_UNITS") -> "bool":
    r"""IsMetricUnit(EDA_UNITS aUnit) -> bool"""
    return _pcbnew.IsMetricUnit(aUnit)

def SearchHelpFileFullPath(aBaseName: "wxString") -> "wxString":
    r"""SearchHelpFileFullPath(wxString aBaseName) -> wxString"""
    return _pcbnew.SearchHelpFileFullPath(aBaseName)

def EnsureFileDirectoryExists(aTargetFullFileName: "wxFileName *", aBaseFilename: "wxString", aReporter: "REPORTER *"=None) -> "bool":
    r"""EnsureFileDirectoryExists(wxFileName * aTargetFullFileName, wxString aBaseFilename, REPORTER * aReporter=None) -> bool"""
    return _pcbnew.EnsureFileDirectoryExists(aTargetFullFileName, aBaseFilename, aReporter)

def ExpandEnvVarSubstitutions(aString: "wxString", aProject: "PROJECT *") -> "wxString const":
    r"""ExpandEnvVarSubstitutions(wxString aString, PROJECT * aProject) -> wxString"""
    return _pcbnew.ExpandEnvVarSubstitutions(aString, aProject)

def ExpandTextVars(*args) -> "wxString":
    r"""
    ExpandTextVars(wxString aSource, std::function< bool (wxString *) > const * aLocalResolver, std::function< bool (wxString *) > const * aFallbackResolver, PROJECT const * aProject) -> wxString
    ExpandTextVars(wxString aSource, PROJECT const * aProject) -> wxString
    """
    return _pcbnew.ExpandTextVars(*args)

def ResolveUriByEnvVars(aUri: "wxString", aProject: "PROJECT *") -> "wxString const":
    r"""ResolveUriByEnvVars(wxString aUri, PROJECT * aProject) -> wxString"""
    return _pcbnew.ResolveUriByEnvVars(aUri, aProject)

def TimestampDir(aDirPath: "wxString", aFilespec: "wxString") -> "long long":
    r"""TimestampDir(wxString aDirPath, wxString aFilespec) -> long long"""
    return _pcbnew.TimestampDir(aDirPath, aFilespec)

def WarnUserIfOperatingSystemUnsupported() -> "bool":
    r"""WarnUserIfOperatingSystemUnsupported() -> bool"""
    return _pcbnew.WarnUserIfOperatingSystemUnsupported()

def StrPrintf(*args) -> "std::string":
    r"""
    StrPrintf(string aResult, char const * aFormat) -> int
    StrPrintf(char const * format) -> string
    """
    return _pcbnew.StrPrintf(*args)
LINE_READER_LINE_DEFAULT_MAX = _pcbnew.LINE_READER_LINE_DEFAULT_MAX

LINE_READER_LINE_INITIAL_SIZE = _pcbnew.LINE_READER_LINE_INITIAL_SIZE

class LINE_READER(object):
    r"""Proxy of C++ LINE_READER 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__ = _pcbnew.delete_LINE_READER

    def ReadLine(self) -> "char *":
        r"""ReadLine(LINE_READER self) -> char *"""
        return _pcbnew.LINE_READER_ReadLine(self)

    def GetSource(self) -> "wxString const &":
        r"""GetSource(LINE_READER self) -> wxString"""
        return _pcbnew.LINE_READER_GetSource(self)

    def Line(self) -> "char *":
        r"""Line(LINE_READER self) -> char *"""
        return _pcbnew.LINE_READER_Line(self)

    def LineNumber(self) -> "unsigned int":
        r"""LineNumber(LINE_READER self) -> unsigned int"""
        return _pcbnew.LINE_READER_LineNumber(self)

    def Length(self) -> "unsigned int":
        r"""Length(LINE_READER self) -> unsigned int"""
        return _pcbnew.LINE_READER_Length(self)

# Register LINE_READER in _pcbnew:
_pcbnew.LINE_READER_swigregister(LINE_READER)

class FILE_LINE_READER(LINE_READER):
    r"""Proxy of C++ FILE_LINE_READER 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__(FILE_LINE_READER self, wxString aFileName, unsigned int aStartingLineNumber=0, unsigned int aMaxLineLength=1000000) -> FILE_LINE_READER
        __init__(FILE_LINE_READER self, FILE * aFile, wxString aFileName, bool doOwn=True, unsigned int aStartingLineNumber=0, unsigned int aMaxLineLength=1000000) -> FILE_LINE_READER
        """
        _pcbnew.FILE_LINE_READER_swiginit(self, _pcbnew.new_FILE_LINE_READER(*args))
    __swig_destroy__ = _pcbnew.delete_FILE_LINE_READER

    def ReadLine(self) -> "char *":
        r"""ReadLine(FILE_LINE_READER self) -> char *"""
        return _pcbnew.FILE_LINE_READER_ReadLine(self)

    def Rewind(self) -> "void":
        r"""Rewind(FILE_LINE_READER self)"""
        return _pcbnew.FILE_LINE_READER_Rewind(self)

    def FileLength(self) -> "long":
        r"""FileLength(FILE_LINE_READER self) -> long"""
        return _pcbnew.FILE_LINE_READER_FileLength(self)

    def CurPos(self) -> "long":
        r"""CurPos(FILE_LINE_READER self) -> long"""
        return _pcbnew.FILE_LINE_READER_CurPos(self)

# Register FILE_LINE_READER in _pcbnew:
_pcbnew.FILE_LINE_READER_swigregister(FILE_LINE_READER)

class STRING_LINE_READER(LINE_READER):
    r"""Proxy of C++ STRING_LINE_READER 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__(STRING_LINE_READER self, string aString, wxString aSource) -> STRING_LINE_READER
        __init__(STRING_LINE_READER self, STRING_LINE_READER aStartingPoint) -> STRING_LINE_READER
        """
        _pcbnew.STRING_LINE_READER_swiginit(self, _pcbnew.new_STRING_LINE_READER(*args))

    def ReadLine(self) -> "char *":
        r"""ReadLine(STRING_LINE_READER self) -> char *"""
        return _pcbnew.STRING_LINE_READER_ReadLine(self)
    __swig_destroy__ = _pcbnew.delete_STRING_LINE_READER

# Register STRING_LINE_READER in _pcbnew:
_pcbnew.STRING_LINE_READER_swigregister(STRING_LINE_READER)

class INPUTSTREAM_LINE_READER(LINE_READER):
    r"""Proxy of C++ INPUTSTREAM_LINE_READER 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, aStream: "wxInputStream *", aSource: "wxString"):
        r"""__init__(INPUTSTREAM_LINE_READER self, wxInputStream * aStream, wxString aSource) -> INPUTSTREAM_LINE_READER"""
        _pcbnew.INPUTSTREAM_LINE_READER_swiginit(self, _pcbnew.new_INPUTSTREAM_LINE_READER(aStream, aSource))

    def ReadLine(self) -> "char *":
        r"""ReadLine(INPUTSTREAM_LINE_READER self) -> char *"""
        return _pcbnew.INPUTSTREAM_LINE_READER_ReadLine(self)
    __swig_destroy__ = _pcbnew.delete_INPUTSTREAM_LINE_READER

# Register INPUTSTREAM_LINE_READER in _pcbnew:
_pcbnew.INPUTSTREAM_LINE_READER_swigregister(INPUTSTREAM_LINE_READER)

OUTPUTFMTBUFZ = _pcbnew.OUTPUTFMTBUFZ

class OUTPUTFORMATTER(object):
    r"""Proxy of C++ OUTPUTFORMATTER 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(self, nestLevel: "int", fmt: "char const *") -> "int":
        r"""Print(OUTPUTFORMATTER self, int nestLevel, char const * fmt) -> int"""
        return _pcbnew.OUTPUTFORMATTER_Print(self, nestLevel, fmt)

    def GetQuoteChar(self, wrapee: "char const *") -> "char const *":
        r"""GetQuoteChar(OUTPUTFORMATTER self, char const * wrapee) -> char const *"""
        return _pcbnew.OUTPUTFORMATTER_GetQuoteChar(self, wrapee)

    def Quotes(self, aWrapee: "string") -> "std::string":
        r"""Quotes(OUTPUTFORMATTER self, string aWrapee) -> string"""
        return _pcbnew.OUTPUTFORMATTER_Quotes(self, aWrapee)

    def Quotew(self, aWrapee: "wxString") -> "std::string":
        r"""Quotew(OUTPUTFORMATTER self, wxString aWrapee) -> string"""
        return _pcbnew.OUTPUTFORMATTER_Quotew(self, aWrapee)

# Register OUTPUTFORMATTER in _pcbnew:
_pcbnew.OUTPUTFORMATTER_swigregister(OUTPUTFORMATTER)

class STRING_FORMATTER(OUTPUTFORMATTER):
    r"""Proxy of C++ STRING_FORMATTER 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__(STRING_FORMATTER self, int aReserve=500, char aQuoteChar='\"') -> STRING_FORMATTER"""
        _pcbnew.STRING_FORMATTER_swiginit(self, _pcbnew.new_STRING_FORMATTER(*args))

    def Clear(self) -> "void":
        r"""Clear(STRING_FORMATTER self)"""
        return _pcbnew.STRING_FORMATTER_Clear(self)

    def StripUseless(self) -> "void":
        r"""StripUseless(STRING_FORMATTER self)"""
        return _pcbnew.STRING_FORMATTER_StripUseless(self)

    def GetString(self) -> "std::string const &":
        r"""GetString(STRING_FORMATTER self) -> string"""
        return _pcbnew.STRING_FORMATTER_GetString(self)
    __swig_destroy__ = _pcbnew.delete_STRING_FORMATTER

# Register STRING_FORMATTER in _pcbnew:
_pcbnew.STRING_FORMATTER_swigregister(STRING_FORMATTER)

class FILE_OUTPUTFORMATTER(OUTPUTFORMATTER):
    r"""Proxy of C++ FILE_OUTPUTFORMATTER 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__(FILE_OUTPUTFORMATTER self, wxString aFileName, wxChar const * aMode=wxT( "wt" ), char aQuoteChar='\"') -> FILE_OUTPUTFORMATTER"""
        _pcbnew.FILE_OUTPUTFORMATTER_swiginit(self, _pcbnew.new_FILE_OUTPUTFORMATTER(*args))
    __swig_destroy__ = _pcbnew.delete_FILE_OUTPUTFORMATTER

# Register FILE_OUTPUTFORMATTER in _pcbnew:
_pcbnew.FILE_OUTPUTFORMATTER_swigregister(FILE_OUTPUTFORMATTER)

class STREAM_OUTPUTFORMATTER(OUTPUTFORMATTER):
    r"""Proxy of C++ STREAM_OUTPUTFORMATTER 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__(STREAM_OUTPUTFORMATTER self, wxOutputStream & aStream, char aQuoteChar='\"') -> STREAM_OUTPUTFORMATTER"""
        _pcbnew.STREAM_OUTPUTFORMATTER_swiginit(self, _pcbnew.new_STREAM_OUTPUTFORMATTER(*args))
    __swig_destroy__ = _pcbnew.delete_STREAM_OUTPUTFORMATTER

# Register STREAM_OUTPUTFORMATTER in _pcbnew:
_pcbnew.STREAM_OUTPUTFORMATTER_swigregister(STREAM_OUTPUTFORMATTER)

class TITLE_BLOCK(object):
    r"""Proxy of C++ TITLE_BLOCK 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__(TITLE_BLOCK self) -> TITLE_BLOCK"""
        _pcbnew.TITLE_BLOCK_swiginit(self, _pcbnew.new_TITLE_BLOCK())
    __swig_destroy__ = _pcbnew.delete_TITLE_BLOCK

    def SetTitle(self, aTitle: "wxString") -> "void":
        r"""SetTitle(TITLE_BLOCK self, wxString aTitle)"""
        return _pcbnew.TITLE_BLOCK_SetTitle(self, aTitle)

    def GetTitle(self) -> "wxString const &":
        r"""GetTitle(TITLE_BLOCK self) -> wxString"""
        return _pcbnew.TITLE_BLOCK_GetTitle(self)

    def SetDate(self, aDate: "wxString") -> "void":
        r"""SetDate(TITLE_BLOCK self, wxString aDate)"""
        return _pcbnew.TITLE_BLOCK_SetDate(self, aDate)

    def GetDate(self) -> "wxString const &":
        r"""GetDate(TITLE_BLOCK self) -> wxString"""
        return _pcbnew.TITLE_BLOCK_GetDate(self)

    def SetRevision(self, aRevision: "wxString") -> "void":
        r"""SetRevision(TITLE_BLOCK self, wxString aRevision)"""
        return _pcbnew.TITLE_BLOCK_SetRevision(self, aRevision)

    def GetRevision(self) -> "wxString const &":
        r"""GetRevision(TITLE_BLOCK self) -> wxString"""
        return _pcbnew.TITLE_BLOCK_GetRevision(self)

    def SetCompany(self, aCompany: "wxString") -> "void":
        r"""SetCompany(TITLE_BLOCK self, wxString aCompany)"""
        return _pcbnew.TITLE_BLOCK_SetCompany(self, aCompany)

    def GetCompany(self) -> "wxString const &":
        r"""GetCompany(TITLE_BLOCK self) -> wxString"""
        return _pcbnew.TITLE_BLOCK_GetCompany(self)

    def SetComment(self, aIdx: "int", aComment: "wxString") -> "void":
        r"""SetComment(TITLE_BLOCK self, int aIdx, wxString aComment)"""
        return _pcbnew.TITLE_BLOCK_SetComment(self, aIdx, aComment)

    def GetComment(self, aIdx: "int") -> "wxString const &":
        r"""GetComment(TITLE_BLOCK self, int aIdx) -> wxString"""
        return _pcbnew.TITLE_BLOCK_GetComment(self, aIdx)

    def Clear(self) -> "void":
        r"""Clear(TITLE_BLOCK self)"""
        return _pcbnew.TITLE_BLOCK_Clear(self)

    @staticmethod
    def GetContextualTextVars(aVars: "wxArrayString *") -> "void":
        r"""GetContextualTextVars(wxArrayString * aVars)"""
        return _pcbnew.TITLE_BLOCK_GetContextualTextVars(aVars)

    def TextVarResolver(self, aToken: "wxString", aProject: "PROJECT const *") -> "bool":
        r"""TextVarResolver(TITLE_BLOCK self, wxString aToken, PROJECT const * aProject) -> bool"""
        return _pcbnew.TITLE_BLOCK_TextVarResolver(self, aToken, aProject)

    def Format(self, aFormatter: "OUTPUTFORMATTER", aNestLevel: "int", aControlBits: "int") -> "void":
        r"""Format(TITLE_BLOCK self, OUTPUTFORMATTER aFormatter, int aNestLevel, int aControlBits)"""
        return _pcbnew.TITLE_BLOCK_Format(self, aFormatter, aNestLevel, aControlBits)

# Register TITLE_BLOCK in _pcbnew:
_pcbnew.TITLE_BLOCK_swigregister(TITLE_BLOCK)

def TITLE_BLOCK_GetContextualTextVars(aVars: "wxArrayString *") -> "void":
    r"""TITLE_BLOCK_GetContextualTextVars(wxArrayString * aVars)"""
    return _pcbnew.TITLE_BLOCK_GetContextualTextVars(aVars)

UNSPECIFIED_COLOR = _pcbnew.UNSPECIFIED_COLOR

BLACK = _pcbnew.BLACK

DARKDARKGRAY = _pcbnew.DARKDARKGRAY

DARKGRAY = _pcbnew.DARKGRAY

LIGHTGRAY = _pcbnew.LIGHTGRAY

WHITE = _pcbnew.WHITE

LIGHTYELLOW = _pcbnew.LIGHTYELLOW

DARKBLUE = _pcbnew.DARKBLUE

DARKGREEN = _pcbnew.DARKGREEN

DARKCYAN = _pcbnew.DARKCYAN

DARKRED = _pcbnew.DARKRED

DARKMAGENTA = _pcbnew.DARKMAGENTA

DARKBROWN = _pcbnew.DARKBROWN

BLUE = _pcbnew.BLUE

GREEN = _pcbnew.GREEN

CYAN = _pcbnew.CYAN

RED = _pcbnew.RED

MAGENTA = _pcbnew.MAGENTA

BROWN = _pcbnew.BROWN

LIGHTBLUE = _pcbnew.LIGHTBLUE

LIGHTGREEN = _pcbnew.LIGHTGREEN

LIGHTCYAN = _pcbnew.LIGHTCYAN

LIGHTRED = _pcbnew.LIGHTRED

LIGHTMAGENTA = _pcbnew.LIGHTMAGENTA

YELLOW = _pcbnew.YELLOW

PUREBLUE = _pcbnew.PUREBLUE

PUREGREEN = _pcbnew.PUREGREEN

PURECYAN = _pcbnew.PURECYAN

PURERED = _pcbnew.PURERED

PUREMAGENTA = _pcbnew.PUREMAGENTA

PUREYELLOW = _pcbnew.PUREYELLOW

LIGHTERORANGE = _pcbnew.LIGHTERORANGE

DARKORANGE = _pcbnew.DARKORANGE

ORANGE = _pcbnew.ORANGE

LIGHTORANGE = _pcbnew.LIGHTORANGE

PUREORANGE = _pcbnew.PUREORANGE

NBCOLORS = _pcbnew.NBCOLORS

HIGHLIGHT_FLAG = _pcbnew.HIGHLIGHT_FLAG

MASKCOLOR = _pcbnew.MASKCOLOR

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    m_Blue = property(_pcbnew.StructColors_m_Blue_get, _pcbnew.StructColors_m_Blue_set, doc=r"""m_Blue : unsigned char""")
    m_Green = property(_pcbnew.StructColors_m_Green_get, _pcbnew.StructColors_m_Green_set, doc=r"""m_Green : unsigned char""")
    m_Red = property(_pcbnew.StructColors_m_Red_get, _pcbnew.StructColors_m_Red_set, doc=r"""m_Red : unsigned char""")
    m_Numcolor = property(_pcbnew.StructColors_m_Numcolor_get, _pcbnew.StructColors_m_Numcolor_set, doc=r"""m_Numcolor : EDA_COLOR_T""")
    m_ColorName = property(_pcbnew.StructColors_m_ColorName_get, _pcbnew.StructColors_m_ColorName_set, doc=r"""m_ColorName : std::string""")
    m_LightColor = property(_pcbnew.StructColors_m_LightColor_get, _pcbnew.StructColors_m_LightColor_set, doc=r"""m_LightColor : EDA_COLOR_T""")

    def __init__(self):
        r"""__init__(StructColors self) -> StructColors"""
        _pcbnew.StructColors_swiginit(self, _pcbnew.new_StructColors())
    __swig_destroy__ = _pcbnew.delete_StructColors

# Register StructColors in _pcbnew:
_pcbnew.StructColors_swigregister(StructColors)


def colorRefs() -> "StructColors const *":
    r"""colorRefs() -> StructColors"""
    return _pcbnew.colorRefs()
class COLOR4D(object):
    r"""Proxy of C++ KIGFX::COLOR4D class."""

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

    def FromCSSRGBA(self, aRed: "int", aGreen: "int", aBlue: "int", aAlpha: "double"=1.0) -> "KIGFX::COLOR4D &":
        r"""FromCSSRGBA(COLOR4D self, int aRed, int aGreen, int aBlue, double aAlpha=1.0) -> COLOR4D"""
        return _pcbnew.COLOR4D_FromCSSRGBA(self, aRed, aGreen, aBlue, aAlpha)

    def __init__(self, *args):
        r"""
        __init__(COLOR4D self) -> COLOR4D
        __init__(COLOR4D self, double aRed, double aGreen, double aBlue, double aAlpha) -> COLOR4D
        __init__(COLOR4D self, EDA_COLOR_T aColor) -> COLOR4D
        __init__(COLOR4D self, wxString aColorStr) -> COLOR4D
        __init__(COLOR4D self, wxColour const & aColor) -> COLOR4D
        """
        _pcbnew.COLOR4D_swiginit(self, _pcbnew.new_COLOR4D(*args))

    def SetFromWxString(self, aColorString: "wxString") -> "bool":
        r"""SetFromWxString(COLOR4D self, wxString aColorString) -> bool"""
        return _pcbnew.COLOR4D_SetFromWxString(self, aColorString)

    def ToWxString(self, flags: "long") -> "wxString":
        r"""ToWxString(COLOR4D self, long flags) -> wxString"""
        return _pcbnew.COLOR4D_ToWxString(self, flags)

    def SetFromHexString(self, aColorString: "wxString") -> "bool":
        r"""SetFromHexString(COLOR4D self, wxString aColorString) -> bool"""
        return _pcbnew.COLOR4D_SetFromHexString(self, aColorString)

    def ToHexString(self) -> "wxString":
        r"""ToHexString(COLOR4D self) -> wxString"""
        return _pcbnew.COLOR4D_ToHexString(self)

    def ToColour(self) -> "wxColour":
        r"""ToColour(COLOR4D self) -> wxColour"""
        return _pcbnew.COLOR4D_ToColour(self)

    def LegacyMix(self, aColor: "COLOR4D") -> "KIGFX::COLOR4D":
        r"""LegacyMix(COLOR4D self, COLOR4D aColor) -> COLOR4D"""
        return _pcbnew.COLOR4D_LegacyMix(self, aColor)

    def ToU32(self) -> "unsigned int":
        r"""ToU32(COLOR4D self) -> unsigned int"""
        return _pcbnew.COLOR4D_ToU32(self)

    def FromU32(self, aPackedColor: "unsigned int") -> "void":
        r"""FromU32(COLOR4D self, unsigned int aPackedColor)"""
        return _pcbnew.COLOR4D_FromU32(self, aPackedColor)

    def ToHSL(self, aOutHue: "double &", aOutSaturation: "double &", aOutValue: "double &") -> "void":
        r"""ToHSL(COLOR4D self, double & aOutHue, double & aOutSaturation, double & aOutValue)"""
        return _pcbnew.COLOR4D_ToHSL(self, aOutHue, aOutSaturation, aOutValue)

    def FromHSL(self, aInHue: "double", aInSaturation: "double", aInLightness: "double") -> "void":
        r"""FromHSL(COLOR4D self, double aInHue, double aInSaturation, double aInLightness)"""
        return _pcbnew.COLOR4D_FromHSL(self, aInHue, aInSaturation, aInLightness)

    def Brighten(self, aFactor: "double") -> "KIGFX::COLOR4D &":
        r"""Brighten(COLOR4D self, double aFactor) -> COLOR4D"""
        return _pcbnew.COLOR4D_Brighten(self, aFactor)

    def Darken(self, aFactor: "double") -> "KIGFX::COLOR4D &":
        r"""Darken(COLOR4D self, double aFactor) -> COLOR4D"""
        return _pcbnew.COLOR4D_Darken(self, aFactor)

    def Invert(self) -> "KIGFX::COLOR4D &":
        r"""Invert(COLOR4D self) -> COLOR4D"""
        return _pcbnew.COLOR4D_Invert(self)

    def Saturate(self, aFactor: "double") -> "KIGFX::COLOR4D &":
        r"""Saturate(COLOR4D self, double aFactor) -> COLOR4D"""
        return _pcbnew.COLOR4D_Saturate(self, aFactor)

    def Brightened(self, aFactor: "double") -> "KIGFX::COLOR4D":
        r"""Brightened(COLOR4D self, double aFactor) -> COLOR4D"""
        return _pcbnew.COLOR4D_Brightened(self, aFactor)

    def Darkened(self, aFactor: "double") -> "KIGFX::COLOR4D":
        r"""Darkened(COLOR4D self, double aFactor) -> COLOR4D"""
        return _pcbnew.COLOR4D_Darkened(self, aFactor)

    def Mix(self, aColor: "COLOR4D", aFactor: "double") -> "KIGFX::COLOR4D":
        r"""Mix(COLOR4D self, COLOR4D aColor, double aFactor) -> COLOR4D"""
        return _pcbnew.COLOR4D_Mix(self, aColor, aFactor)

    def WithAlpha(self, aAlpha: "double") -> "KIGFX::COLOR4D":
        r"""WithAlpha(COLOR4D self, double aAlpha) -> COLOR4D"""
        return _pcbnew.COLOR4D_WithAlpha(self, aAlpha)

    def Inverted(self) -> "KIGFX::COLOR4D":
        r"""Inverted(COLOR4D self) -> COLOR4D"""
        return _pcbnew.COLOR4D_Inverted(self)

    def GetBrightness(self) -> "double":
        r"""GetBrightness(COLOR4D self) -> double"""
        return _pcbnew.COLOR4D_GetBrightness(self)

    def ToHSV(self, aOutHue: "double &", aOutSaturation: "double &", aOutValue: "double &", aAlwaysDefineHue: "bool"=False) -> "void":
        r"""ToHSV(COLOR4D self, double & aOutHue, double & aOutSaturation, double & aOutValue, bool aAlwaysDefineHue=False)"""
        return _pcbnew.COLOR4D_ToHSV(self, aOutHue, aOutSaturation, aOutValue, aAlwaysDefineHue)

    def FromHSV(self, aInH: "double", aInS: "double", aInV: "double") -> "void":
        r"""FromHSV(COLOR4D self, double aInH, double aInS, double aInV)"""
        return _pcbnew.COLOR4D_FromHSV(self, aInH, aInS, aInV)

    def Distance(self, other: "COLOR4D") -> "double":
        r"""Distance(COLOR4D self, COLOR4D other) -> double"""
        return _pcbnew.COLOR4D_Distance(self, other)

    @staticmethod
    def FindNearestLegacyColor(aR: "int", aG: "int", aB: "int") -> "EDA_COLOR_T":
        r"""FindNearestLegacyColor(int aR, int aG, int aB) -> EDA_COLOR_T"""
        return _pcbnew.COLOR4D_FindNearestLegacyColor(aR, aG, aB)
    r = property(_pcbnew.COLOR4D_r_get, _pcbnew.COLOR4D_r_set, doc=r"""r : double""")
    g = property(_pcbnew.COLOR4D_g_get, _pcbnew.COLOR4D_g_set, doc=r"""g : double""")
    b = property(_pcbnew.COLOR4D_b_get, _pcbnew.COLOR4D_b_set, doc=r"""b : double""")
    a = property(_pcbnew.COLOR4D_a_get, _pcbnew.COLOR4D_a_set, doc=r"""a : double""")
    __swig_destroy__ = _pcbnew.delete_COLOR4D

# Register COLOR4D in _pcbnew:
_pcbnew.COLOR4D_swigregister(COLOR4D)

def COLOR4D_FindNearestLegacyColor(aR: "int", aG: "int", aB: "int") -> "EDA_COLOR_T":
    r"""COLOR4D_FindNearestLegacyColor(int aR, int aG, int aB) -> EDA_COLOR_T"""
    return _pcbnew.COLOR4D_FindNearestLegacyColor(aR, aG, aB)
COLOR4D.UNSPECIFIED = _pcbnew.cvar.COLOR4D_UNSPECIFIED
COLOR4D.WHITE = _pcbnew.cvar.COLOR4D_WHITE
COLOR4D.BLACK = _pcbnew.cvar.COLOR4D_BLACK
COLOR4D.CLEAR = _pcbnew.cvar.COLOR4D_CLEAR


def __eq__(lhs: "COLOR4D", rhs: "COLOR4D") -> "bool const":
    r"""__eq__(COLOR4D lhs, COLOR4D rhs) -> bool const"""
    return _pcbnew.__eq__(lhs, rhs)

def __ne__(lhs: "COLOR4D", rhs: "COLOR4D") -> "bool const":
    r"""__ne__(COLOR4D lhs, COLOR4D rhs) -> bool const"""
    return _pcbnew.__ne__(lhs, rhs)

def __lt__(lhs: "COLOR4D", rhs: "COLOR4D") -> "bool const":
    r"""__lt__(COLOR4D lhs, COLOR4D rhs) -> bool const"""
    return _pcbnew.__lt__(lhs, rhs)

def __lshift__(aStream: "std::ostream &", aColor: "COLOR4D") -> "std::ostream &":
    r"""__lshift__(std::ostream & aStream, COLOR4D aColor) -> std::ostream &"""
    return _pcbnew.__lshift__(aStream, aColor)

def to_json(aJson: "nlohmann::json &", aColor: "COLOR4D") -> "void":
    r"""to_json(nlohmann::json & aJson, COLOR4D aColor)"""
    return _pcbnew.to_json(aJson, aColor)

def from_json(aJson: "nlohmann::json const &", aColor: "COLOR4D") -> "void":
    r"""from_json(nlohmann::json const & aJson, COLOR4D aColor)"""
    return _pcbnew.from_json(aJson, aColor)
class MARKER_BASE(object):
    r"""Proxy of C++ MARKER_BASE 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
    MARKER_UNSPEC = _pcbnew.MARKER_BASE_MARKER_UNSPEC
    
    MARKER_ERC = _pcbnew.MARKER_BASE_MARKER_ERC
    
    MARKER_PCB = _pcbnew.MARKER_BASE_MARKER_PCB
    
    MARKER_SIMUL = _pcbnew.MARKER_BASE_MARKER_SIMUL
    
    __swig_destroy__ = _pcbnew.delete_MARKER_BASE

    def MarkerScale(self) -> "int":
        r"""MarkerScale(MARKER_BASE self) -> int"""
        return _pcbnew.MARKER_BASE_MarkerScale(self)

    def SetMarkerScale(self, aScale: "int") -> "void":
        r"""SetMarkerScale(MARKER_BASE self, int aScale)"""
        return _pcbnew.MARKER_BASE_SetMarkerScale(self, aScale)

    def ShapeToPolygon(self, aPolygon: "SHAPE_LINE_CHAIN", aScale: "int"=-1) -> "void":
        r"""ShapeToPolygon(MARKER_BASE self, SHAPE_LINE_CHAIN aPolygon, int aScale=-1)"""
        return _pcbnew.MARKER_BASE_ShapeToPolygon(self, aPolygon, aScale)

    def PrintMarker(self, aSettings: "RENDER_SETTINGS const *", aOffset: "wxPoint") -> "void":
        r"""PrintMarker(MARKER_BASE self, RENDER_SETTINGS const * aSettings, wxPoint aOffset)"""
        return _pcbnew.MARKER_BASE_PrintMarker(self, aSettings, aOffset)

    def GetPos(self) -> "wxPoint const &":
        r"""GetPos(MARKER_BASE self) -> wxPoint"""
        return _pcbnew.MARKER_BASE_GetPos(self)

    def GetUUID(self) -> "KIID const":
        r"""GetUUID(MARKER_BASE self) -> KIID"""
        return _pcbnew.MARKER_BASE_GetUUID(self)

    def SetMarkerType(self, aMarkerType: "enum MARKER_BASE::TYPEMARKER") -> "void":
        r"""SetMarkerType(MARKER_BASE self, enum MARKER_BASE::TYPEMARKER aMarkerType)"""
        return _pcbnew.MARKER_BASE_SetMarkerType(self, aMarkerType)

    def GetMarkerType(self) -> "enum MARKER_BASE::TYPEMARKER":
        r"""GetMarkerType(MARKER_BASE self) -> enum MARKER_BASE::TYPEMARKER"""
        return _pcbnew.MARKER_BASE_GetMarkerType(self)

    def IsExcluded(self) -> "bool":
        r"""IsExcluded(MARKER_BASE self) -> bool"""
        return _pcbnew.MARKER_BASE_IsExcluded(self)

    def SetExcluded(self, aExcluded: "bool") -> "void":
        r"""SetExcluded(MARKER_BASE self, bool aExcluded)"""
        return _pcbnew.MARKER_BASE_SetExcluded(self, aExcluded)

    def GetRCItem(self) -> "std::shared_ptr< RC_ITEM >":
        r"""GetRCItem(MARKER_BASE self) -> std::shared_ptr< RC_ITEM >"""
        return _pcbnew.MARKER_BASE_GetRCItem(self)

    def HitTestMarker(self, aHitPosition: "wxPoint", aAccuracy: "int") -> "bool":
        r"""HitTestMarker(MARKER_BASE self, wxPoint aHitPosition, int aAccuracy) -> bool"""
        return _pcbnew.MARKER_BASE_HitTestMarker(self, aHitPosition, aAccuracy)

    def GetBoundingBoxMarker(self) -> "EDA_RECT":
        r"""GetBoundingBoxMarker(MARKER_BASE self) -> EDA_RECT"""
        return _pcbnew.MARKER_BASE_GetBoundingBoxMarker(self)
    m_Pos = property(_pcbnew.MARKER_BASE_m_Pos_get, _pcbnew.MARKER_BASE_m_Pos_set, doc=r"""m_Pos : wxPoint""")

# Register MARKER_BASE in _pcbnew:
_pcbnew.MARKER_BASE_swigregister(MARKER_BASE)

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    m_textWidth = property(_pcbnew.TSEGM_2_POLY_PRMS_m_textWidth_get, _pcbnew.TSEGM_2_POLY_PRMS_m_textWidth_set, doc=r"""m_textWidth : int""")
    m_error = property(_pcbnew.TSEGM_2_POLY_PRMS_m_error_get, _pcbnew.TSEGM_2_POLY_PRMS_m_error_set, doc=r"""m_error : int""")
    m_cornerBuffer = property(_pcbnew.TSEGM_2_POLY_PRMS_m_cornerBuffer_get, _pcbnew.TSEGM_2_POLY_PRMS_m_cornerBuffer_set, doc=r"""m_cornerBuffer : p.SHAPE_POLY_SET""")

    def __init__(self):
        r"""__init__(TSEGM_2_POLY_PRMS self) -> TSEGM_2_POLY_PRMS"""
        _pcbnew.TSEGM_2_POLY_PRMS_swiginit(self, _pcbnew.new_TSEGM_2_POLY_PRMS())
    __swig_destroy__ = _pcbnew.delete_TSEGM_2_POLY_PRMS

# Register TSEGM_2_POLY_PRMS in _pcbnew:
_pcbnew.TSEGM_2_POLY_PRMS_swigregister(TSEGM_2_POLY_PRMS)


def addTextSegmToPoly(x0: "int", y0: "int", xf: "int", yf: "int", aData: "void *") -> "void":
    r"""addTextSegmToPoly(int x0, int y0, int xf, int yf, void * aData)"""
    return _pcbnew.addTextSegmToPoly(x0, y0, xf, yf, aData)
TEXT_ANGLE_HORIZ = _pcbnew.TEXT_ANGLE_HORIZ

TEXT_ANGLE_VERT = _pcbnew.TEXT_ANGLE_VERT

CTL_OMIT_HIDE = _pcbnew.CTL_OMIT_HIDE

GR_TEXT_HJUSTIFY_LEFT = _pcbnew.GR_TEXT_HJUSTIFY_LEFT

GR_TEXT_HJUSTIFY_CENTER = _pcbnew.GR_TEXT_HJUSTIFY_CENTER

GR_TEXT_HJUSTIFY_RIGHT = _pcbnew.GR_TEXT_HJUSTIFY_RIGHT

GR_TEXT_VJUSTIFY_TOP = _pcbnew.GR_TEXT_VJUSTIFY_TOP

GR_TEXT_VJUSTIFY_CENTER = _pcbnew.GR_TEXT_VJUSTIFY_CENTER

GR_TEXT_VJUSTIFY_BOTTOM = _pcbnew.GR_TEXT_VJUSTIFY_BOTTOM

DEFAULT_SIZE_TEXT = _pcbnew.DEFAULT_SIZE_TEXT

DIM_ANCRE_TEXTE = _pcbnew.DIM_ANCRE_TEXTE

class TEXT_EFFECTS(object):
    r"""Proxy of C++ TEXT_EFFECTS 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, aSetOfBits: "int"=0):
        r"""__init__(TEXT_EFFECTS self, int aSetOfBits=0) -> TEXT_EFFECTS"""
        _pcbnew.TEXT_EFFECTS_swiginit(self, _pcbnew.new_TEXT_EFFECTS(aSetOfBits))
    bits = property(_pcbnew.TEXT_EFFECTS_bits_get, _pcbnew.TEXT_EFFECTS_bits_set, doc=r"""bits : int""")
    hjustify = property(_pcbnew.TEXT_EFFECTS_hjustify_get, _pcbnew.TEXT_EFFECTS_hjustify_set, doc=r"""hjustify : signed char""")
    vjustify = property(_pcbnew.TEXT_EFFECTS_vjustify_get, _pcbnew.TEXT_EFFECTS_vjustify_set, doc=r"""vjustify : signed char""")
    size = property(_pcbnew.TEXT_EFFECTS_size_get, _pcbnew.TEXT_EFFECTS_size_set, doc=r"""size : wxSize""")
    penwidth = property(_pcbnew.TEXT_EFFECTS_penwidth_get, _pcbnew.TEXT_EFFECTS_penwidth_set, doc=r"""penwidth : int""")
    angle = property(_pcbnew.TEXT_EFFECTS_angle_get, _pcbnew.TEXT_EFFECTS_angle_set, doc=r"""angle : double""")
    pos = property(_pcbnew.TEXT_EFFECTS_pos_get, _pcbnew.TEXT_EFFECTS_pos_set, doc=r"""pos : wxPoint""")

    def Bit(self, *args) -> "bool":
        r"""
        Bit(TEXT_EFFECTS self, int aBit, bool aValue)
        Bit(TEXT_EFFECTS self, int aBit) -> bool
        """
        return _pcbnew.TEXT_EFFECTS_Bit(self, *args)
    __swig_destroy__ = _pcbnew.delete_TEXT_EFFECTS

# Register TEXT_EFFECTS in _pcbnew:
_pcbnew.TEXT_EFFECTS_swigregister(TEXT_EFFECTS)

class EDA_TEXT(object):
    r"""Proxy of C++ EDA_TEXT 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__(EDA_TEXT self, wxString text=wxEmptyString) -> EDA_TEXT
        __init__(EDA_TEXT self, EDA_TEXT aText) -> EDA_TEXT
        """
        _pcbnew.EDA_TEXT_swiginit(self, _pcbnew.new_EDA_TEXT(*args))
    __swig_destroy__ = _pcbnew.delete_EDA_TEXT

    def GetText(self) -> "wxString const &":
        r"""GetText(EDA_TEXT self) -> wxString"""
        return _pcbnew.EDA_TEXT_GetText(self)

    def GetShownText(self, aDepth: "int"=0) -> "wxString":
        r"""GetShownText(EDA_TEXT self, int aDepth=0) -> wxString"""
        return _pcbnew.EDA_TEXT_GetShownText(self, aDepth)

    def ShortenedShownText(self) -> "wxString":
        r"""ShortenedShownText(EDA_TEXT self) -> wxString"""
        return _pcbnew.EDA_TEXT_ShortenedShownText(self)

    def HasTextVars(self) -> "bool":
        r"""HasTextVars(EDA_TEXT self) -> bool"""
        return _pcbnew.EDA_TEXT_HasTextVars(self)

    def SetText(self, aText: "wxString") -> "void":
        r"""SetText(EDA_TEXT self, wxString aText)"""
        return _pcbnew.EDA_TEXT_SetText(self, aText)

    def SetTextThickness(self, aWidth: "int") -> "void":
        r"""SetTextThickness(EDA_TEXT self, int aWidth)"""
        return _pcbnew.EDA_TEXT_SetTextThickness(self, aWidth)

    def GetTextThickness(self) -> "int":
        r"""GetTextThickness(EDA_TEXT self) -> int"""
        return _pcbnew.EDA_TEXT_GetTextThickness(self)

    def GetEffectiveTextPenWidth(self, aDefaultWidth: "int"=0) -> "int":
        r"""GetEffectiveTextPenWidth(EDA_TEXT self, int aDefaultWidth=0) -> int"""
        return _pcbnew.EDA_TEXT_GetEffectiveTextPenWidth(self, aDefaultWidth)

    def SetTextAngle(self, aAngle: "double") -> "void":
        r"""SetTextAngle(EDA_TEXT self, double aAngle)"""
        return _pcbnew.EDA_TEXT_SetTextAngle(self, aAngle)

    def GetTextAngle(self) -> "double":
        r"""GetTextAngle(EDA_TEXT self) -> double"""
        return _pcbnew.EDA_TEXT_GetTextAngle(self)

    def GetTextAngleDegrees(self) -> "double":
        r"""GetTextAngleDegrees(EDA_TEXT self) -> double"""
        return _pcbnew.EDA_TEXT_GetTextAngleDegrees(self)

    def GetTextAngleRadians(self) -> "double":
        r"""GetTextAngleRadians(EDA_TEXT self) -> double"""
        return _pcbnew.EDA_TEXT_GetTextAngleRadians(self)

    def SetItalic(self, isItalic: "bool") -> "void":
        r"""SetItalic(EDA_TEXT self, bool isItalic)"""
        return _pcbnew.EDA_TEXT_SetItalic(self, isItalic)

    def IsItalic(self) -> "bool":
        r"""IsItalic(EDA_TEXT self) -> bool"""
        return _pcbnew.EDA_TEXT_IsItalic(self)

    def SetBold(self, aBold: "bool") -> "void":
        r"""SetBold(EDA_TEXT self, bool aBold)"""
        return _pcbnew.EDA_TEXT_SetBold(self, aBold)

    def IsBold(self) -> "bool":
        r"""IsBold(EDA_TEXT self) -> bool"""
        return _pcbnew.EDA_TEXT_IsBold(self)

    def SetVisible(self, aVisible: "bool") -> "void":
        r"""SetVisible(EDA_TEXT self, bool aVisible)"""
        return _pcbnew.EDA_TEXT_SetVisible(self, aVisible)

    def IsVisible(self) -> "bool":
        r"""IsVisible(EDA_TEXT self) -> bool"""
        return _pcbnew.EDA_TEXT_IsVisible(self)

    def SetMirrored(self, isMirrored: "bool") -> "void":
        r"""SetMirrored(EDA_TEXT self, bool isMirrored)"""
        return _pcbnew.EDA_TEXT_SetMirrored(self, isMirrored)

    def IsMirrored(self) -> "bool":
        r"""IsMirrored(EDA_TEXT self) -> bool"""
        return _pcbnew.EDA_TEXT_IsMirrored(self)

    def SetMultilineAllowed(self, aAllow: "bool") -> "void":
        r"""SetMultilineAllowed(EDA_TEXT self, bool aAllow)"""
        return _pcbnew.EDA_TEXT_SetMultilineAllowed(self, aAllow)

    def IsMultilineAllowed(self) -> "bool":
        r"""IsMultilineAllowed(EDA_TEXT self) -> bool"""
        return _pcbnew.EDA_TEXT_IsMultilineAllowed(self)

    def GetHorizJustify(self) -> "EDA_TEXT_HJUSTIFY_T":
        r"""GetHorizJustify(EDA_TEXT self) -> EDA_TEXT_HJUSTIFY_T"""
        return _pcbnew.EDA_TEXT_GetHorizJustify(self)

    def GetVertJustify(self) -> "EDA_TEXT_VJUSTIFY_T":
        r"""GetVertJustify(EDA_TEXT self) -> EDA_TEXT_VJUSTIFY_T"""
        return _pcbnew.EDA_TEXT_GetVertJustify(self)

    def SetHorizJustify(self, aType: "EDA_TEXT_HJUSTIFY_T") -> "void":
        r"""SetHorizJustify(EDA_TEXT self, EDA_TEXT_HJUSTIFY_T aType)"""
        return _pcbnew.EDA_TEXT_SetHorizJustify(self, aType)

    def SetVertJustify(self, aType: "EDA_TEXT_VJUSTIFY_T") -> "void":
        r"""SetVertJustify(EDA_TEXT self, EDA_TEXT_VJUSTIFY_T aType)"""
        return _pcbnew.EDA_TEXT_SetVertJustify(self, aType)

    def SetEffects(self, aSrc: "EDA_TEXT") -> "void":
        r"""SetEffects(EDA_TEXT self, EDA_TEXT aSrc)"""
        return _pcbnew.EDA_TEXT_SetEffects(self, aSrc)

    def SwapEffects(self, aTradingPartner: "EDA_TEXT") -> "void":
        r"""SwapEffects(EDA_TEXT self, EDA_TEXT aTradingPartner)"""
        return _pcbnew.EDA_TEXT_SwapEffects(self, aTradingPartner)

    def SwapText(self, aTradingPartner: "EDA_TEXT") -> "void":
        r"""SwapText(EDA_TEXT self, EDA_TEXT aTradingPartner)"""
        return _pcbnew.EDA_TEXT_SwapText(self, aTradingPartner)

    def CopyText(self, aSrc: "EDA_TEXT") -> "void":
        r"""CopyText(EDA_TEXT self, EDA_TEXT aSrc)"""
        return _pcbnew.EDA_TEXT_CopyText(self, aSrc)

    def Replace(self, aSearchData: "wxFindReplaceData const &") -> "bool":
        r"""Replace(EDA_TEXT self, wxFindReplaceData const & aSearchData) -> bool"""
        return _pcbnew.EDA_TEXT_Replace(self, aSearchData)

    def IsDefaultFormatting(self) -> "bool":
        r"""IsDefaultFormatting(EDA_TEXT self) -> bool"""
        return _pcbnew.EDA_TEXT_IsDefaultFormatting(self)

    def SetTextSize(self, aNewSize: "wxSize") -> "void":
        r"""SetTextSize(EDA_TEXT self, wxSize aNewSize)"""
        return _pcbnew.EDA_TEXT_SetTextSize(self, aNewSize)

    def GetTextSize(self) -> "wxSize const &":
        r"""GetTextSize(EDA_TEXT self) -> wxSize"""
        return _pcbnew.EDA_TEXT_GetTextSize(self)

    def SetTextWidth(self, aWidth: "int") -> "void":
        r"""SetTextWidth(EDA_TEXT self, int aWidth)"""
        return _pcbnew.EDA_TEXT_SetTextWidth(self, aWidth)

    def GetTextWidth(self) -> "int":
        r"""GetTextWidth(EDA_TEXT self) -> int"""
        return _pcbnew.EDA_TEXT_GetTextWidth(self)

    def SetTextHeight(self, aHeight: "int") -> "void":
        r"""SetTextHeight(EDA_TEXT self, int aHeight)"""
        return _pcbnew.EDA_TEXT_SetTextHeight(self, aHeight)

    def GetTextHeight(self) -> "int":
        r"""GetTextHeight(EDA_TEXT self) -> int"""
        return _pcbnew.EDA_TEXT_GetTextHeight(self)

    def SetTextPos(self, aPoint: "wxPoint") -> "void":
        r"""SetTextPos(EDA_TEXT self, wxPoint aPoint)"""
        return _pcbnew.EDA_TEXT_SetTextPos(self, aPoint)

    def GetTextPos(self) -> "wxPoint const &":
        r"""GetTextPos(EDA_TEXT self) -> wxPoint"""
        return _pcbnew.EDA_TEXT_GetTextPos(self)

    def SetTextX(self, aX: "int") -> "void":
        r"""SetTextX(EDA_TEXT self, int aX)"""
        return _pcbnew.EDA_TEXT_SetTextX(self, aX)

    def SetTextY(self, aY: "int") -> "void":
        r"""SetTextY(EDA_TEXT self, int aY)"""
        return _pcbnew.EDA_TEXT_SetTextY(self, aY)

    def Offset(self, aOffset: "wxPoint") -> "void":
        r"""Offset(EDA_TEXT self, wxPoint aOffset)"""
        return _pcbnew.EDA_TEXT_Offset(self, aOffset)

    def Empty(self) -> "void":
        r"""Empty(EDA_TEXT self)"""
        return _pcbnew.EDA_TEXT_Empty(self)

    @staticmethod
    def MapHorizJustify(aHorizJustify: "int") -> "EDA_TEXT_HJUSTIFY_T":
        r"""MapHorizJustify(int aHorizJustify) -> EDA_TEXT_HJUSTIFY_T"""
        return _pcbnew.EDA_TEXT_MapHorizJustify(aHorizJustify)

    @staticmethod
    def MapVertJustify(aVertJustify: "int") -> "EDA_TEXT_VJUSTIFY_T":
        r"""MapVertJustify(int aVertJustify) -> EDA_TEXT_VJUSTIFY_T"""
        return _pcbnew.EDA_TEXT_MapVertJustify(aVertJustify)

    def Print(self, aSettings: "RENDER_SETTINGS const *", aOffset: "wxPoint", aColor: "COLOR4D", aDisplay_mode: "OUTLINE_MODE"=FILLED) -> "void":
        r"""Print(EDA_TEXT self, RENDER_SETTINGS const * aSettings, wxPoint aOffset, COLOR4D aColor, OUTLINE_MODE aDisplay_mode=FILLED)"""
        return _pcbnew.EDA_TEXT_Print(self, aSettings, aOffset, aColor, aDisplay_mode)

    def TransformToSegmentList(self) -> "std::vector< wxPoint,std::allocator< wxPoint > >":
        r"""TransformToSegmentList(EDA_TEXT self) -> wxPoint_Vector"""
        return _pcbnew.EDA_TEXT_TransformToSegmentList(self)

    def TransformBoundingBoxWithClearanceToPolygon(self, aCornerBuffer: "SHAPE_POLY_SET", aClearanceValue: "int") -> "void":
        r"""TransformBoundingBoxWithClearanceToPolygon(EDA_TEXT self, SHAPE_POLY_SET aCornerBuffer, int aClearanceValue)"""
        return _pcbnew.EDA_TEXT_TransformBoundingBoxWithClearanceToPolygon(self, aCornerBuffer, aClearanceValue)

    def GetEffectiveTextShape(self) -> "std::shared_ptr< SHAPE_COMPOUND >":
        r"""GetEffectiveTextShape(EDA_TEXT self) -> std::shared_ptr< SHAPE_COMPOUND >"""
        return _pcbnew.EDA_TEXT_GetEffectiveTextShape(self)

    def TextHitTest(self, *args) -> "bool":
        r"""
        TextHitTest(EDA_TEXT self, wxPoint aPoint, int aAccuracy=0) -> bool
        TextHitTest(EDA_TEXT self, EDA_RECT aRect, bool aContains, int aAccuracy=0) -> bool
        """
        return _pcbnew.EDA_TEXT_TextHitTest(self, *args)

    def LenSize(self, aLine: "wxString", aThickness: "int") -> "int":
        r"""LenSize(EDA_TEXT self, wxString aLine, int aThickness) -> int"""
        return _pcbnew.EDA_TEXT_LenSize(self, aLine, aThickness)

    def GetTextBox(self, aLine: "int"=-1, aInvertY: "bool"=False) -> "EDA_RECT":
        r"""GetTextBox(EDA_TEXT self, int aLine=-1, bool aInvertY=False) -> EDA_RECT"""
        return _pcbnew.EDA_TEXT_GetTextBox(self, aLine, aInvertY)

    def GetInterline(self) -> "int":
        r"""GetInterline(EDA_TEXT self) -> int"""
        return _pcbnew.EDA_TEXT_GetInterline(self)

    def GetTextStyleName(self) -> "wxString":
        r"""GetTextStyleName(EDA_TEXT self) -> wxString"""
        return _pcbnew.EDA_TEXT_GetTextStyleName(self)

    def GetLinePositions(self, aPositions: "wxPoint_Vector", aLineCount: "int") -> "void":
        r"""GetLinePositions(EDA_TEXT self, wxPoint_Vector aPositions, int aLineCount)"""
        return _pcbnew.EDA_TEXT_GetLinePositions(self, aPositions, aLineCount)

    def Format(self, aFormatter: "OUTPUTFORMATTER", aNestLevel: "int", aControlBits: "int") -> "void":
        r"""Format(EDA_TEXT self, OUTPUTFORMATTER aFormatter, int aNestLevel, int aControlBits)"""
        return _pcbnew.EDA_TEXT_Format(self, aFormatter, aNestLevel, aControlBits)

    def GetDrawRotation(self) -> "double":
        r"""GetDrawRotation(EDA_TEXT self) -> double"""
        return _pcbnew.EDA_TEXT_GetDrawRotation(self)

    def GetDrawPos(self) -> "wxPoint":
        r"""GetDrawPos(EDA_TEXT self) -> wxPoint"""
        return _pcbnew.EDA_TEXT_GetDrawPos(self)

    def GetDrawHorizJustify(self) -> "EDA_TEXT_HJUSTIFY_T":
        r"""GetDrawHorizJustify(EDA_TEXT self) -> EDA_TEXT_HJUSTIFY_T"""
        return _pcbnew.EDA_TEXT_GetDrawHorizJustify(self)

    def GetDrawVertJustify(self) -> "EDA_TEXT_VJUSTIFY_T":
        r"""GetDrawVertJustify(EDA_TEXT self) -> EDA_TEXT_VJUSTIFY_T"""
        return _pcbnew.EDA_TEXT_GetDrawVertJustify(self)

    def Compare(self, aOther: "EDA_TEXT") -> "int":
        r"""Compare(EDA_TEXT self, EDA_TEXT aOther) -> int"""
        return _pcbnew.EDA_TEXT_Compare(self, aOther)

# Register EDA_TEXT in _pcbnew:
_pcbnew.EDA_TEXT_swigregister(EDA_TEXT)

def EDA_TEXT_MapHorizJustify(aHorizJustify: "int") -> "EDA_TEXT_HJUSTIFY_T":
    r"""EDA_TEXT_MapHorizJustify(int aHorizJustify) -> EDA_TEXT_HJUSTIFY_T"""
    return _pcbnew.EDA_TEXT_MapHorizJustify(aHorizJustify)

def EDA_TEXT_MapVertJustify(aVertJustify: "int") -> "EDA_TEXT_VJUSTIFY_T":
    r"""EDA_TEXT_MapVertJustify(int aVertJustify) -> EDA_TEXT_VJUSTIFY_T"""
    return _pcbnew.EDA_TEXT_MapVertJustify(aVertJustify)


def GetBuildVersion() -> "wxString":
    r"""GetBuildVersion() -> wxString"""
    return _pcbnew.GetBuildVersion()

def GetPlatformGetBitnessName() -> "wxString":
    r"""GetPlatformGetBitnessName() -> wxString"""
    return _pcbnew.GetPlatformGetBitnessName()

def GetSemanticVersion() -> "wxString":
    r"""GetSemanticVersion() -> wxString"""
    return _pcbnew.GetSemanticVersion()

def GetMajorMinorVersion() -> "wxString":
    r"""GetMajorMinorVersion() -> wxString"""
    return _pcbnew.GetMajorMinorVersion()

def GetBuildDate() -> "wxString":
    r"""GetBuildDate() -> wxString"""
    return _pcbnew.GetBuildDate()

def GetVersionInfoData(aTitle: "wxString", aHtml: "bool"=False, aBrief: "bool"=False) -> "wxString":
    r"""GetVersionInfoData(wxString aTitle, bool aHtml=False, bool aBrief=False) -> wxString"""
    return _pcbnew.GetVersionInfoData(aTitle, aHtml, aBrief)
class SETTINGS_MANAGER(object):
    r"""Proxy of C++ SETTINGS_MANAGER 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, aHeadless: "bool"=False):
        r"""__init__(SETTINGS_MANAGER self, bool aHeadless=False) -> SETTINGS_MANAGER"""
        _pcbnew.SETTINGS_MANAGER_swiginit(self, _pcbnew.new_SETTINGS_MANAGER(aHeadless))
    __swig_destroy__ = _pcbnew.delete_SETTINGS_MANAGER

    def IsOK(self) -> "bool":
        r"""IsOK(SETTINGS_MANAGER self) -> bool"""
        return _pcbnew.SETTINGS_MANAGER_IsOK(self)

    def SetKiway(self, aKiway: "KIWAY *") -> "void":
        r"""SetKiway(SETTINGS_MANAGER self, KIWAY * aKiway)"""
        return _pcbnew.SETTINGS_MANAGER_SetKiway(self, aKiway)

    def Load(self, *args) -> "void":
        r"""
        Load(SETTINGS_MANAGER self)
        Load(SETTINGS_MANAGER self, JSON_SETTINGS * aSettings)
        """
        return _pcbnew.SETTINGS_MANAGER_Load(self, *args)

    def Save(self, *args) -> "void":
        r"""
        Save(SETTINGS_MANAGER self)
        Save(SETTINGS_MANAGER self, JSON_SETTINGS * aSettings)
        """
        return _pcbnew.SETTINGS_MANAGER_Save(self, *args)

    def FlushAndRelease(self, aSettings: "JSON_SETTINGS *", aSave: "bool"=True) -> "void":
        r"""FlushAndRelease(SETTINGS_MANAGER self, JSON_SETTINGS * aSettings, bool aSave=True)"""
        return _pcbnew.SETTINGS_MANAGER_FlushAndRelease(self, aSettings, aSave)

    def GetColorSettings(self, *args) -> "COLOR_SETTINGS *":
        r"""GetColorSettings(SETTINGS_MANAGER self, wxString aName="user") -> COLOR_SETTINGS"""
        return _pcbnew.SETTINGS_MANAGER_GetColorSettings(self, *args)

    def GetColorSettingsList(self) -> "std::vector< COLOR_SETTINGS *,std::allocator< COLOR_SETTINGS * > >":
        r"""GetColorSettingsList(SETTINGS_MANAGER self) -> std::vector< COLOR_SETTINGS *,std::allocator< COLOR_SETTINGS * > >"""
        return _pcbnew.SETTINGS_MANAGER_GetColorSettingsList(self)

    def SaveColorSettings(self, *args) -> "void":
        r"""SaveColorSettings(SETTINGS_MANAGER self, COLOR_SETTINGS * aSettings, string aNamespace="")"""
        return _pcbnew.SETTINGS_MANAGER_SaveColorSettings(self, *args)

    def AddNewColorSettings(self, aFilename: "wxString") -> "COLOR_SETTINGS *":
        r"""AddNewColorSettings(SETTINGS_MANAGER self, wxString aFilename) -> COLOR_SETTINGS *"""
        return _pcbnew.SETTINGS_MANAGER_AddNewColorSettings(self, aFilename)

    def GetMigratedColorSettings(self) -> "COLOR_SETTINGS *":
        r"""GetMigratedColorSettings(SETTINGS_MANAGER self) -> COLOR_SETTINGS *"""
        return _pcbnew.SETTINGS_MANAGER_GetMigratedColorSettings(self)

    def GetCommonSettings(self) -> "COMMON_SETTINGS *":
        r"""GetCommonSettings(SETTINGS_MANAGER self) -> COMMON_SETTINGS *"""
        return _pcbnew.SETTINGS_MANAGER_GetCommonSettings(self)

    def GetPathForSettingsFile(self, aSettings: "JSON_SETTINGS *") -> "wxString":
        r"""GetPathForSettingsFile(SETTINGS_MANAGER self, JSON_SETTINGS * aSettings) -> wxString"""
        return _pcbnew.SETTINGS_MANAGER_GetPathForSettingsFile(self, aSettings)

    def MigrateIfNeeded(self) -> "bool":
        r"""MigrateIfNeeded(SETTINGS_MANAGER self) -> bool"""
        return _pcbnew.SETTINGS_MANAGER_MigrateIfNeeded(self)

    def SetMigrationSource(self, aSource: "wxString") -> "void":
        r"""SetMigrationSource(SETTINGS_MANAGER self, wxString aSource)"""
        return _pcbnew.SETTINGS_MANAGER_SetMigrationSource(self, aSource)

    def SetMigrateLibraryTables(self, aMigrate: "bool"=True) -> "void":
        r"""SetMigrateLibraryTables(SETTINGS_MANAGER self, bool aMigrate=True)"""
        return _pcbnew.SETTINGS_MANAGER_SetMigrateLibraryTables(self, aMigrate)

    def GetPreviousVersionPaths(self, aName: "std::vector< wxString,std::allocator< wxString > > *"=None) -> "bool":
        r"""GetPreviousVersionPaths(SETTINGS_MANAGER self, std::vector< wxString,std::allocator< wxString > > * aName=None) -> bool"""
        return _pcbnew.SETTINGS_MANAGER_GetPreviousVersionPaths(self, aName)

    def ReloadColorSettings(self) -> "void":
        r"""ReloadColorSettings(SETTINGS_MANAGER self)"""
        return _pcbnew.SETTINGS_MANAGER_ReloadColorSettings(self)

    def LoadProject(self, aFullPath: "wxString", aSetActive: "bool"=True) -> "bool":
        r"""LoadProject(SETTINGS_MANAGER self, wxString aFullPath, bool aSetActive=True) -> bool"""
        return _pcbnew.SETTINGS_MANAGER_LoadProject(self, aFullPath, aSetActive)

    def UnloadProject(self, aProject: "PROJECT *", aSave: "bool"=True) -> "bool":
        r"""UnloadProject(SETTINGS_MANAGER self, PROJECT * aProject, bool aSave=True) -> bool"""
        return _pcbnew.SETTINGS_MANAGER_UnloadProject(self, aProject, aSave)

    def IsProjectOpen(self) -> "bool":
        r"""IsProjectOpen(SETTINGS_MANAGER self) -> bool"""
        return _pcbnew.SETTINGS_MANAGER_IsProjectOpen(self)

    def Prj(self) -> "PROJECT &":
        r"""Prj(SETTINGS_MANAGER self) -> PROJECT &"""
        return _pcbnew.SETTINGS_MANAGER_Prj(self)

    def GetProject(self, aFullPath: "wxString") -> "PROJECT *":
        r"""GetProject(SETTINGS_MANAGER self, wxString aFullPath) -> PROJECT *"""
        return _pcbnew.SETTINGS_MANAGER_GetProject(self, aFullPath)

    def GetOpenProjects(self) -> "std::vector< wxString,std::allocator< wxString > >":
        r"""GetOpenProjects(SETTINGS_MANAGER self) -> std::vector< wxString,std::allocator< wxString > >"""
        return _pcbnew.SETTINGS_MANAGER_GetOpenProjects(self)

    def SaveProject(self, *args) -> "bool":
        r"""SaveProject(SETTINGS_MANAGER self, wxString aFullPath=wxEmptyString, PROJECT * aProject=None) -> bool"""
        return _pcbnew.SETTINGS_MANAGER_SaveProject(self, *args)

    def SaveProjectAs(self, aFullPath: "wxString", aProject: "PROJECT *"=None) -> "void":
        r"""SaveProjectAs(SETTINGS_MANAGER self, wxString aFullPath, PROJECT * aProject=None)"""
        return _pcbnew.SETTINGS_MANAGER_SaveProjectAs(self, aFullPath, aProject)

    def SaveProjectCopy(self, aFullPath: "wxString", aProject: "PROJECT *"=None) -> "void":
        r"""SaveProjectCopy(SETTINGS_MANAGER self, wxString aFullPath, PROJECT * aProject=None)"""
        return _pcbnew.SETTINGS_MANAGER_SaveProjectCopy(self, aFullPath, aProject)

    def GetProjectBackupsPath(self) -> "wxString":
        r"""GetProjectBackupsPath(SETTINGS_MANAGER self) -> wxString"""
        return _pcbnew.SETTINGS_MANAGER_GetProjectBackupsPath(self)

    def BackupProject(self, aReporter: "REPORTER &") -> "bool":
        r"""BackupProject(SETTINGS_MANAGER self, REPORTER & aReporter) -> bool"""
        return _pcbnew.SETTINGS_MANAGER_BackupProject(self, aReporter)

    def TriggerBackupIfNeeded(self, aReporter: "REPORTER &") -> "bool":
        r"""TriggerBackupIfNeeded(SETTINGS_MANAGER self, REPORTER & aReporter) -> bool"""
        return _pcbnew.SETTINGS_MANAGER_TriggerBackupIfNeeded(self, aReporter)

    @staticmethod
    def IsSettingsPathValid(aPath: "wxString") -> "bool":
        r"""IsSettingsPathValid(wxString aPath) -> bool"""
        return _pcbnew.SETTINGS_MANAGER_IsSettingsPathValid(aPath)

    @staticmethod
    def GetColorSettingsPath() -> "wxString":
        r"""GetColorSettingsPath() -> wxString"""
        return _pcbnew.SETTINGS_MANAGER_GetColorSettingsPath()

    @staticmethod
    def GetUserSettingsPath() -> "wxString":
        r"""GetUserSettingsPath() -> wxString"""
        return _pcbnew.SETTINGS_MANAGER_GetUserSettingsPath()

    @staticmethod
    def GetSettingsVersion() -> "std::string":
        r"""GetSettingsVersion() -> string"""
        return _pcbnew.SETTINGS_MANAGER_GetSettingsVersion()

# Register SETTINGS_MANAGER in _pcbnew:
_pcbnew.SETTINGS_MANAGER_swigregister(SETTINGS_MANAGER)

def SETTINGS_MANAGER_IsSettingsPathValid(aPath: "wxString") -> "bool":
    r"""SETTINGS_MANAGER_IsSettingsPathValid(wxString aPath) -> bool"""
    return _pcbnew.SETTINGS_MANAGER_IsSettingsPathValid(aPath)

def SETTINGS_MANAGER_GetColorSettingsPath() -> "wxString":
    r"""SETTINGS_MANAGER_GetColorSettingsPath() -> wxString"""
    return _pcbnew.SETTINGS_MANAGER_GetColorSettingsPath()

def SETTINGS_MANAGER_GetUserSettingsPath() -> "wxString":
    r"""SETTINGS_MANAGER_GetUserSettingsPath() -> wxString"""
    return _pcbnew.SETTINGS_MANAGER_GetUserSettingsPath()

def SETTINGS_MANAGER_GetSettingsVersion() -> "std::string":
    r"""SETTINGS_MANAGER_GetSettingsVersion() -> string"""
    return _pcbnew.SETTINGS_MANAGER_GetSettingsVersion()

class intVector(object):
    r"""Proxy of C++ std::vector< int > 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) -> "swig::SwigPyIterator *":
        r"""iterator(intVector self) -> SwigPyIterator"""
        return _pcbnew.intVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(intVector self) -> bool"""
        return _pcbnew.intVector___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(intVector self) -> bool"""
        return _pcbnew.intVector___bool__(self)

    def __len__(self) -> "std::vector< int >::size_type":
        r"""__len__(intVector self) -> std::vector< int >::size_type"""
        return _pcbnew.intVector___len__(self)

    def __getslice__(self, i: "std::vector< int >::difference_type", j: "std::vector< int >::difference_type") -> "std::vector< int,std::allocator< int > > *":
        r"""__getslice__(intVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j) -> intVector"""
        return _pcbnew.intVector___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        r"""
        __setslice__(intVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)
        __setslice__(intVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j, intVector v)
        """
        return _pcbnew.intVector___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< int >::difference_type", j: "std::vector< int >::difference_type") -> "void":
        r"""__delslice__(intVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)"""
        return _pcbnew.intVector___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        r"""
        __delitem__(intVector self, std::vector< int >::difference_type i)
        __delitem__(intVector self, PySliceObject * slice)
        """
        return _pcbnew.intVector___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< int >::value_type const &":
        r"""
        __getitem__(intVector self, PySliceObject * slice) -> intVector
        __getitem__(intVector self, std::vector< int >::difference_type i) -> std::vector< int >::value_type const &
        """
        return _pcbnew.intVector___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(intVector self, PySliceObject * slice, intVector v)
        __setitem__(intVector self, PySliceObject * slice)
        __setitem__(intVector self, std::vector< int >::difference_type i, std::vector< int >::value_type const & x)
        """
        return _pcbnew.intVector___setitem__(self, *args)

    def pop(self) -> "std::vector< int >::value_type":
        r"""pop(intVector self) -> std::vector< int >::value_type"""
        return _pcbnew.intVector_pop(self)

    def append(self, x: "std::vector< int >::value_type const &") -> "void":
        r"""append(intVector self, std::vector< int >::value_type const & x)"""
        return _pcbnew.intVector_append(self, x)

    def empty(self) -> "bool":
        r"""empty(intVector self) -> bool"""
        return _pcbnew.intVector_empty(self)

    def size(self) -> "std::vector< int >::size_type":
        r"""size(intVector self) -> std::vector< int >::size_type"""
        return _pcbnew.intVector_size(self)

    def swap(self, v: "intVector") -> "void":
        r"""swap(intVector self, intVector v)"""
        return _pcbnew.intVector_swap(self, v)

    def begin(self) -> "std::vector< int >::iterator":
        r"""begin(intVector self) -> std::vector< int >::iterator"""
        return _pcbnew.intVector_begin(self)

    def end(self) -> "std::vector< int >::iterator":
        r"""end(intVector self) -> std::vector< int >::iterator"""
        return _pcbnew.intVector_end(self)

    def rbegin(self) -> "std::vector< int >::reverse_iterator":
        r"""rbegin(intVector self) -> std::vector< int >::reverse_iterator"""
        return _pcbnew.intVector_rbegin(self)

    def rend(self) -> "std::vector< int >::reverse_iterator":
        r"""rend(intVector self) -> std::vector< int >::reverse_iterator"""
        return _pcbnew.intVector_rend(self)

    def clear(self) -> "void":
        r"""clear(intVector self)"""
        return _pcbnew.intVector_clear(self)

    def get_allocator(self) -> "std::vector< int >::allocator_type":
        r"""get_allocator(intVector self) -> std::vector< int >::allocator_type"""
        return _pcbnew.intVector_get_allocator(self)

    def pop_back(self) -> "void":
        r"""pop_back(intVector self)"""
        return _pcbnew.intVector_pop_back(self)

    def erase(self, *args) -> "std::vector< int >::iterator":
        r"""
        erase(intVector self, std::vector< int >::iterator pos) -> std::vector< int >::iterator
        erase(intVector self, std::vector< int >::iterator first, std::vector< int >::iterator last) -> std::vector< int >::iterator
        """
        return _pcbnew.intVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(intVector self) -> intVector
        __init__(intVector self, intVector other) -> intVector
        __init__(intVector self, std::vector< int >::size_type size) -> intVector
        __init__(intVector self, std::vector< int >::size_type size, std::vector< int >::value_type const & value) -> intVector
        """
        _pcbnew.intVector_swiginit(self, _pcbnew.new_intVector(*args))

    def push_back(self, x: "std::vector< int >::value_type const &") -> "void":
        r"""push_back(intVector self, std::vector< int >::value_type const & x)"""
        return _pcbnew.intVector_push_back(self, x)

    def front(self) -> "std::vector< int >::value_type const &":
        r"""front(intVector self) -> std::vector< int >::value_type const &"""
        return _pcbnew.intVector_front(self)

    def back(self) -> "std::vector< int >::value_type const &":
        r"""back(intVector self) -> std::vector< int >::value_type const &"""
        return _pcbnew.intVector_back(self)

    def assign(self, n: "std::vector< int >::size_type", x: "std::vector< int >::value_type const &") -> "void":
        r"""assign(intVector self, std::vector< int >::size_type n, std::vector< int >::value_type const & x)"""
        return _pcbnew.intVector_assign(self, n, x)

    def resize(self, *args) -> "void":
        r"""
        resize(intVector self, std::vector< int >::size_type new_size)
        resize(intVector self, std::vector< int >::size_type new_size, std::vector< int >::value_type const & x)
        """
        return _pcbnew.intVector_resize(self, *args)

    def insert(self, *args) -> "void":
        r"""
        insert(intVector self, std::vector< int >::iterator pos, std::vector< int >::value_type const & x) -> std::vector< int >::iterator
        insert(intVector self, std::vector< int >::iterator pos, std::vector< int >::size_type n, std::vector< int >::value_type const & x)
        """
        return _pcbnew.intVector_insert(self, *args)

    def reserve(self, n: "std::vector< int >::size_type") -> "void":
        r"""reserve(intVector self, std::vector< int >::size_type n)"""
        return _pcbnew.intVector_reserve(self, n)

    def capacity(self) -> "std::vector< int >::size_type":
        r"""capacity(intVector self) -> std::vector< int >::size_type"""
        return _pcbnew.intVector_capacity(self)
    __swig_destroy__ = _pcbnew.delete_intVector

# Register intVector in _pcbnew:
_pcbnew.intVector_swigregister(intVector)

class str_utf8_Map(object):
    r"""Proxy of C++ std::map< std::string,UTF8 > 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) -> "swig::SwigPyIterator *":
        r"""iterator(str_utf8_Map self) -> SwigPyIterator"""
        return _pcbnew.str_utf8_Map_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(str_utf8_Map self) -> bool"""
        return _pcbnew.str_utf8_Map___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(str_utf8_Map self) -> bool"""
        return _pcbnew.str_utf8_Map___bool__(self)

    def __len__(self) -> "std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::size_type":
        r"""__len__(str_utf8_Map self) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::size_type"""
        return _pcbnew.str_utf8_Map___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "string") -> "std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::mapped_type const &":
        r"""__getitem__(str_utf8_Map self, string key) -> UTF8"""
        return _pcbnew.str_utf8_Map___getitem__(self, key)

    def __delitem__(self, key: "string") -> "void":
        r"""__delitem__(str_utf8_Map self, string key)"""
        return _pcbnew.str_utf8_Map___delitem__(self, key)

    def has_key(self, key: "string") -> "bool":
        r"""has_key(str_utf8_Map self, string key) -> bool"""
        return _pcbnew.str_utf8_Map_has_key(self, key)

    def keys(self) -> "PyObject *":
        r"""keys(str_utf8_Map self) -> PyObject *"""
        return _pcbnew.str_utf8_Map_keys(self)

    def values(self) -> "PyObject *":
        r"""values(str_utf8_Map self) -> PyObject *"""
        return _pcbnew.str_utf8_Map_values(self)

    def items(self) -> "PyObject *":
        r"""items(str_utf8_Map self) -> PyObject *"""
        return _pcbnew.str_utf8_Map_items(self)

    def __contains__(self, key: "string") -> "bool":
        r"""__contains__(str_utf8_Map self, string key) -> bool"""
        return _pcbnew.str_utf8_Map___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        r"""key_iterator(str_utf8_Map self) -> SwigPyIterator"""
        return _pcbnew.str_utf8_Map_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        r"""value_iterator(str_utf8_Map self) -> SwigPyIterator"""
        return _pcbnew.str_utf8_Map_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(str_utf8_Map self, string key)
        __setitem__(str_utf8_Map self, string key, UTF8 x)
        """
        return _pcbnew.str_utf8_Map___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        r"""asdict(str_utf8_Map self) -> PyObject *"""
        return _pcbnew.str_utf8_Map_asdict(self)

    def __init__(self, *args):
        r"""
        __init__(str_utf8_Map self, std::less< std::basic_string< char,std::char_traits< char >,std::allocator< char > > > const & other) -> str_utf8_Map
        __init__(str_utf8_Map self) -> str_utf8_Map
        __init__(str_utf8_Map self, str_utf8_Map other) -> str_utf8_Map
        """
        _pcbnew.str_utf8_Map_swiginit(self, _pcbnew.new_str_utf8_Map(*args))

    def empty(self) -> "bool":
        r"""empty(str_utf8_Map self) -> bool"""
        return _pcbnew.str_utf8_Map_empty(self)

    def size(self) -> "std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::size_type":
        r"""size(str_utf8_Map self) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::size_type"""
        return _pcbnew.str_utf8_Map_size(self)

    def swap(self, v: "str_utf8_Map") -> "void":
        r"""swap(str_utf8_Map self, str_utf8_Map v)"""
        return _pcbnew.str_utf8_Map_swap(self, v)

    def begin(self) -> "std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator":
        r"""begin(str_utf8_Map self) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator"""
        return _pcbnew.str_utf8_Map_begin(self)

    def end(self) -> "std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator":
        r"""end(str_utf8_Map self) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator"""
        return _pcbnew.str_utf8_Map_end(self)

    def rbegin(self) -> "std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::reverse_iterator":
        r"""rbegin(str_utf8_Map self) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::reverse_iterator"""
        return _pcbnew.str_utf8_Map_rbegin(self)

    def rend(self) -> "std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::reverse_iterator":
        r"""rend(str_utf8_Map self) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::reverse_iterator"""
        return _pcbnew.str_utf8_Map_rend(self)

    def clear(self) -> "void":
        r"""clear(str_utf8_Map self)"""
        return _pcbnew.str_utf8_Map_clear(self)

    def get_allocator(self) -> "std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::allocator_type":
        r"""get_allocator(str_utf8_Map self) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::allocator_type"""
        return _pcbnew.str_utf8_Map_get_allocator(self)

    def count(self, x: "string") -> "std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::size_type":
        r"""count(str_utf8_Map self, string x) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::size_type"""
        return _pcbnew.str_utf8_Map_count(self, x)

    def erase(self, *args) -> "void":
        r"""
        erase(str_utf8_Map self, string x) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::size_type
        erase(str_utf8_Map self, std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator position)
        erase(str_utf8_Map self, std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator first, std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator last)
        """
        return _pcbnew.str_utf8_Map_erase(self, *args)

    def find(self, x: "string") -> "std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator":
        r"""find(str_utf8_Map self, string x) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator"""
        return _pcbnew.str_utf8_Map_find(self, x)

    def lower_bound(self, x: "string") -> "std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator":
        r"""lower_bound(str_utf8_Map self, string x) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator"""
        return _pcbnew.str_utf8_Map_lower_bound(self, x)

    def upper_bound(self, x: "string") -> "std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator":
        r"""upper_bound(str_utf8_Map self, string x) -> std::map< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,UTF8 >::iterator"""
        return _pcbnew.str_utf8_Map_upper_bound(self, x)
    __swig_destroy__ = _pcbnew.delete_str_utf8_Map

# Register str_utf8_Map in _pcbnew:
_pcbnew.str_utf8_Map_swigregister(str_utf8_Map)

class base_seqVect(object):
    r"""Proxy of C++ std::vector< enum PCB_LAYER_ID > 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) -> "swig::SwigPyIterator *":
        r"""iterator(base_seqVect self) -> SwigPyIterator"""
        return _pcbnew.base_seqVect_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(base_seqVect self) -> bool"""
        return _pcbnew.base_seqVect___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(base_seqVect self) -> bool"""
        return _pcbnew.base_seqVect___bool__(self)

    def __len__(self) -> "std::vector< enum PCB_LAYER_ID >::size_type":
        r"""__len__(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::size_type"""
        return _pcbnew.base_seqVect___len__(self)

    def __getslice__(self, i: "std::vector< enum PCB_LAYER_ID >::difference_type", j: "std::vector< enum PCB_LAYER_ID >::difference_type") -> "std::vector< enum PCB_LAYER_ID,std::allocator< enum PCB_LAYER_ID > > *":
        r"""__getslice__(base_seqVect self, std::vector< enum PCB_LAYER_ID >::difference_type i, std::vector< enum PCB_LAYER_ID >::difference_type j) -> base_seqVect"""
        return _pcbnew.base_seqVect___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        r"""
        __setslice__(base_seqVect self, std::vector< enum PCB_LAYER_ID >::difference_type i, std::vector< enum PCB_LAYER_ID >::difference_type j)
        __setslice__(base_seqVect self, std::vector< enum PCB_LAYER_ID >::difference_type i, std::vector< enum PCB_LAYER_ID >::difference_type j, base_seqVect v)
        """
        return _pcbnew.base_seqVect___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< enum PCB_LAYER_ID >::difference_type", j: "std::vector< enum PCB_LAYER_ID >::difference_type") -> "void":
        r"""__delslice__(base_seqVect self, std::vector< enum PCB_LAYER_ID >::difference_type i, std::vector< enum PCB_LAYER_ID >::difference_type j)"""
        return _pcbnew.base_seqVect___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        r"""
        __delitem__(base_seqVect self, std::vector< enum PCB_LAYER_ID >::difference_type i)
        __delitem__(base_seqVect self, PySliceObject * slice)
        """
        return _pcbnew.base_seqVect___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< enum PCB_LAYER_ID >::value_type const &":
        r"""
        __getitem__(base_seqVect self, PySliceObject * slice) -> base_seqVect
        __getitem__(base_seqVect self, std::vector< enum PCB_LAYER_ID >::difference_type i) -> std::vector< enum PCB_LAYER_ID >::value_type const &
        """
        return _pcbnew.base_seqVect___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(base_seqVect self, PySliceObject * slice, base_seqVect v)
        __setitem__(base_seqVect self, PySliceObject * slice)
        __setitem__(base_seqVect self, std::vector< enum PCB_LAYER_ID >::difference_type i, std::vector< enum PCB_LAYER_ID >::value_type const & x)
        """
        return _pcbnew.base_seqVect___setitem__(self, *args)

    def pop(self) -> "std::vector< enum PCB_LAYER_ID >::value_type":
        r"""pop(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::value_type"""
        return _pcbnew.base_seqVect_pop(self)

    def append(self, x: "std::vector< enum PCB_LAYER_ID >::value_type const &") -> "void":
        r"""append(base_seqVect self, std::vector< enum PCB_LAYER_ID >::value_type const & x)"""
        return _pcbnew.base_seqVect_append(self, x)

    def empty(self) -> "bool":
        r"""empty(base_seqVect self) -> bool"""
        return _pcbnew.base_seqVect_empty(self)

    def size(self) -> "std::vector< enum PCB_LAYER_ID >::size_type":
        r"""size(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::size_type"""
        return _pcbnew.base_seqVect_size(self)

    def swap(self, v: "base_seqVect") -> "void":
        r"""swap(base_seqVect self, base_seqVect v)"""
        return _pcbnew.base_seqVect_swap(self, v)

    def begin(self) -> "std::vector< enum PCB_LAYER_ID >::iterator":
        r"""begin(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::iterator"""
        return _pcbnew.base_seqVect_begin(self)

    def end(self) -> "std::vector< enum PCB_LAYER_ID >::iterator":
        r"""end(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::iterator"""
        return _pcbnew.base_seqVect_end(self)

    def rbegin(self) -> "std::vector< enum PCB_LAYER_ID >::reverse_iterator":
        r"""rbegin(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::reverse_iterator"""
        return _pcbnew.base_seqVect_rbegin(self)

    def rend(self) -> "std::vector< enum PCB_LAYER_ID >::reverse_iterator":
        r"""rend(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::reverse_iterator"""
        return _pcbnew.base_seqVect_rend(self)

    def clear(self) -> "void":
        r"""clear(base_seqVect self)"""
        return _pcbnew.base_seqVect_clear(self)

    def get_allocator(self) -> "std::vector< enum PCB_LAYER_ID >::allocator_type":
        r"""get_allocator(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::allocator_type"""
        return _pcbnew.base_seqVect_get_allocator(self)

    def pop_back(self) -> "void":
        r"""pop_back(base_seqVect self)"""
        return _pcbnew.base_seqVect_pop_back(self)

    def erase(self, *args) -> "std::vector< enum PCB_LAYER_ID >::iterator":
        r"""
        erase(base_seqVect self, std::vector< enum PCB_LAYER_ID >::iterator pos) -> std::vector< enum PCB_LAYER_ID >::iterator
        erase(base_seqVect self, std::vector< enum PCB_LAYER_ID >::iterator first, std::vector< enum PCB_LAYER_ID >::iterator last) -> std::vector< enum PCB_LAYER_ID >::iterator
        """
        return _pcbnew.base_seqVect_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(base_seqVect self) -> base_seqVect
        __init__(base_seqVect self, base_seqVect other) -> base_seqVect
        __init__(base_seqVect self, std::vector< enum PCB_LAYER_ID >::size_type size) -> base_seqVect
        __init__(base_seqVect self, std::vector< enum PCB_LAYER_ID >::size_type size, std::vector< enum PCB_LAYER_ID >::value_type const & value) -> base_seqVect
        """
        _pcbnew.base_seqVect_swiginit(self, _pcbnew.new_base_seqVect(*args))

    def push_back(self, x: "std::vector< enum PCB_LAYER_ID >::value_type const &") -> "void":
        r"""push_back(base_seqVect self, std::vector< enum PCB_LAYER_ID >::value_type const & x)"""
        return _pcbnew.base_seqVect_push_back(self, x)

    def front(self) -> "std::vector< enum PCB_LAYER_ID >::value_type const &":
        r"""front(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::value_type const &"""
        return _pcbnew.base_seqVect_front(self)

    def back(self) -> "std::vector< enum PCB_LAYER_ID >::value_type const &":
        r"""back(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::value_type const &"""
        return _pcbnew.base_seqVect_back(self)

    def assign(self, n: "std::vector< enum PCB_LAYER_ID >::size_type", x: "std::vector< enum PCB_LAYER_ID >::value_type const &") -> "void":
        r"""assign(base_seqVect self, std::vector< enum PCB_LAYER_ID >::size_type n, std::vector< enum PCB_LAYER_ID >::value_type const & x)"""
        return _pcbnew.base_seqVect_assign(self, n, x)

    def resize(self, *args) -> "void":
        r"""
        resize(base_seqVect self, std::vector< enum PCB_LAYER_ID >::size_type new_size)
        resize(base_seqVect self, std::vector< enum PCB_LAYER_ID >::size_type new_size, std::vector< enum PCB_LAYER_ID >::value_type const & x)
        """
        return _pcbnew.base_seqVect_resize(self, *args)

    def insert(self, *args) -> "void":
        r"""
        insert(base_seqVect self, std::vector< enum PCB_LAYER_ID >::iterator pos, std::vector< enum PCB_LAYER_ID >::value_type const & x) -> std::vector< enum PCB_LAYER_ID >::iterator
        insert(base_seqVect self, std::vector< enum PCB_LAYER_ID >::iterator pos, std::vector< enum PCB_LAYER_ID >::size_type n, std::vector< enum PCB_LAYER_ID >::value_type const & x)
        """
        return _pcbnew.base_seqVect_insert(self, *args)

    def reserve(self, n: "std::vector< enum PCB_LAYER_ID >::size_type") -> "void":
        r"""reserve(base_seqVect self, std::vector< enum PCB_LAYER_ID >::size_type n)"""
        return _pcbnew.base_seqVect_reserve(self, n)

    def capacity(self) -> "std::vector< enum PCB_LAYER_ID >::size_type":
        r"""capacity(base_seqVect self) -> std::vector< enum PCB_LAYER_ID >::size_type"""
        return _pcbnew.base_seqVect_capacity(self)
    __swig_destroy__ = _pcbnew.delete_base_seqVect

# Register base_seqVect in _pcbnew:
_pcbnew.base_seqVect_swigregister(base_seqVect)



KICAD_PLUGINS={}    # the list of loaded footprint wizards

""" the list of not loaded python scripts
    (usually because there is a syntax error in python script)
    this is the python script full filenames list.
    filenames are separated by '\n'
"""
NOT_LOADED_WIZARDS=""

""" the list of paths used to search python scripts.
    Stored here to be displayed on request in Pcbnew
    paths are separated by '\n'
"""
PLUGIN_DIRECTORIES_SEARCH=""

"""
    the trace of errors during execution of footprint wizards scripts
    Warning: strings (internally unicode) are returned as UTF-8 compatible C strings
"""

FULL_BACK_TRACE=""

def GetUnLoadableWizards():
    global NOT_LOADED_WIZARDS
    import sys

    if sys.version_info[0] < 3:
        utf8_str = NOT_LOADED_WIZARDS.encode( 'UTF-8' )
    else:
        utf8_str = NOT_LOADED_WIZARDS

    return utf8_str

def GetWizardsSearchPaths():
    global PLUGIN_DIRECTORIES_SEARCH
    import sys

    if sys.version_info[0] < 3:
        utf8_str = PLUGIN_DIRECTORIES_SEARCH.encode( 'UTF-8' )
    else:
        utf8_str = PLUGIN_DIRECTORIES_SEARCH

    return utf8_str

def GetWizardsBackTrace():
    global FULL_BACK_TRACE  # Already correct format
    return FULL_BACK_TRACE


def LoadPluginModule(Dirname, ModuleName, FileName):
    """
    Load the plugin module named ModuleName located in the folder Dirname.
    The module can be either inside a file called FileName or a subdirectory
    called FileName that contains a __init__.py file.
    If this module cannot be loaded, its name is stored in failed_wizards_list
    and the error trace is stored in FULL_BACK_TRACE
    """
    import os
    import sys
    import traceback

    global NOT_LOADED_WIZARDS
    global FULL_BACK_TRACE
    global KICAD_PLUGINS

    try:  # If there is an error loading the script, skip it

        module_filename = os.path.join( Dirname, FileName )
        mtime = os.path.getmtime( module_filename )
        mods_before = set( sys.modules )

        if ModuleName in KICAD_PLUGINS:
            plugin = KICAD_PLUGINS[ModuleName]

            for dependency in plugin["dependencies"]:
                if dependency in sys.modules:
                    del sys.modules[dependency]

            mods_before = set( sys.modules )

        if sys.version_info >= (3,0,0):
            import importlib
            mod = importlib.import_module( ModuleName )
        else:
            mod = __import__( ModuleName, locals(), globals() )

        mods_after = set( sys.modules ).difference( mods_before )
        dependencies = [m for m in mods_after if m.startswith(ModuleName)]

        KICAD_PLUGINS[ModuleName]={ "filename":module_filename,
                                    "modification_time":mtime,
                                    "ModuleName":mod,
                                    "dependencies": dependencies }

    except:
        if ModuleName in KICAD_PLUGINS:
            del KICAD_PLUGINS[ModuleName]

        if NOT_LOADED_WIZARDS != "" :
            NOT_LOADED_WIZARDS += "\n"
        NOT_LOADED_WIZARDS += module_filename
        FULL_BACK_TRACE += traceback.format_exc()


def LoadPlugins(bundlepath=None, userpath=None, thirdpartypath=None):
    """
    Initialise Scripting/Plugin python environment and load plugins.

    Arguments:
    Note: bundlepath and userpath are given  utf8 encoded, to be compatible with asimple C string
    bundlepath -- The path to the bundled scripts.
                  The bundled Plugins are relative to this path, in the
                  "plugins" subdirectory.
                WARNING: bundlepath must use '/' as path separator, and not '\'
                because it creates issues:
                \n and \r are seen as a escaped seq when passing this string to this method
                I am thinking this is due to the fact LoadPlugins is called from C++ code by
                PyRun_SimpleString()

    NOTE: These are all of the possible "default" search paths for kicad
          python scripts.  These paths will ONLY be added to the python
          search path ONLY IF they already exist.

        The Scripts bundled with the KiCad installation:
            <bundlepath>/
            <bundlepath>/plugins/

        The Scripts relative to the KiCad Users configuration:
            <userpath>/
            <userpath>/plugins/

        The plugins from 3rd party packages:
            $KICAD_3RD_PARTY/plugins/
    """
    import os
    import sys
    import traceback
    import pcbnew

    if sys.version_info >= (3,3,0):
        import importlib
        importlib.invalidate_caches()

    """
    bundlepath and userpath are strings utf-8 encoded (compatible "C" strings).
    So convert these utf8 encoding to unicode strings to avoid any encoding issue.
    """
    try:
        bundlepath = bundlepath.decode( 'UTF-8' )
        userpath = userpath.decode( 'UTF-8' )
        thirdpartypath = thirdpartypath.decode( 'UTF-8' )
    except AttributeError:
        pass

    config_path = pcbnew.SETTINGS_MANAGER.GetUserSettingsPath()
    plugin_directories=[]

    """
    To be consistent with others paths, on windows, convert the unix '/' separator
    to the windows separator, although using '/' works
    """
    if sys.platform.startswith('win32'):
        if bundlepath:
            bundlepath = bundlepath.replace("/","\\")
        if thirdpartypath:
            thirdpartypath = thirdpartypath.replace("/","\\")

    if bundlepath:
        plugin_directories.append(bundlepath)
        plugin_directories.append(os.path.join(bundlepath, 'plugins'))

    if config_path:
        plugin_directories.append(os.path.join(config_path, 'scripting'))
        plugin_directories.append(os.path.join(config_path, 'scripting', 'plugins'))

    if userpath:
        plugin_directories.append(userpath)
        plugin_directories.append(os.path.join(userpath, 'plugins'))

    if thirdpartypath:
        plugin_directories.append(thirdpartypath)

    global PLUGIN_DIRECTORIES_SEARCH
    PLUGIN_DIRECTORIES_SEARCH=""
    for plugins_dir in plugin_directories:    # save search path list for later use
        if PLUGIN_DIRECTORIES_SEARCH != "" :
            PLUGIN_DIRECTORIES_SEARCH += "\n"
        PLUGIN_DIRECTORIES_SEARCH += plugins_dir

    global FULL_BACK_TRACE
    FULL_BACK_TRACE=""          # clear any existing trace

    global NOT_LOADED_WIZARDS
    NOT_LOADED_WIZARDS = ""     # save not loaded wizards names list for later use

    global KICAD_PLUGINS

    for plugins_dir in plugin_directories:
        if not os.path.isdir( plugins_dir ):
            continue

        if plugins_dir not in sys.path:
            sys.path.append( plugins_dir )

        for module in os.listdir(plugins_dir):
            fullPath = os.path.join( plugins_dir, module )

            if os.path.isdir( fullPath ):
                if os.path.exists( os.path.join( fullPath, '__init__.py' ) ):
                    LoadPluginModule( plugins_dir, module, module )
                else:
                    if NOT_LOADED_WIZARDS != "" :
                        NOT_LOADED_WIZARDS += "\n"
                    NOT_LOADED_WIZARDS += 'Skip subdir ' + fullPath
                continue

            if module == '__init__.py' or module[-3:] != '.py':
                continue

            LoadPluginModule( plugins_dir, module[:-3], module )


class KiCadPlugin:
    def __init__(self):
        pass

    def register(self):
        import inspect
        import os

        if isinstance(self,FilePlugin):
            pass # register to file plugins in C++

        if isinstance(self,FootprintWizardPlugin):
            PYTHON_FOOTPRINT_WIZARD_LIST.register_wizard(self)
            return

        if isinstance(self,ActionPlugin):
            """
            Get path to .py or .pyc that has definition of plugin class.
            If path is binary but source also exists, assume definition is in source.
            """
            self.__plugin_path = inspect.getfile(self.__class__)
            if self.__plugin_path.endswith('.pyc') and os.path.isfile(self.__plugin_path[:-1]):
                self.__plugin_path = self.__plugin_path[:-1]
            self.__plugin_path = self.__plugin_path + '/' + self.__class__.__name__
            PYTHON_ACTION_PLUGINS.register_action(self)
            return

        return

    def deregister(self):
        if isinstance(self,FilePlugin):
            pass # deregister to file plugins in C++

        if isinstance(self,FootprintWizardPlugin):
            PYTHON_FOOTPRINT_WIZARD_LIST.deregister_wizard(self)
            return

        if isinstance(self,ActionPlugin):
            PYTHON_ACTION_PLUGINS.deregister_action(self)
            return

        return

    def GetPluginPath( self ):
        return self.__plugin_path


class FilePlugin(KiCadPlugin):
    def __init__(self):
        KiCadPlugin.__init__(self)


from math import ceil, floor, sqrt

uMM = "mm"              # Millimetres
uMils = "mils"          # Mils
uFloat = "float"        # Natural number units (dimensionless)
uInteger = "integer"    # Integer (no decimals, numeric, dimensionless)
uBool = "bool"          # Boolean value
uRadians = "radians"    # Angular units (radians)
uDegrees = "degrees"    # Angular units (degrees)
uPercent = "%"          # Percent (0% -> 100%)
uString = "string"      # Raw string

uNumeric = [uMM, uMils, uFloat, uInteger, uDegrees, uRadians, uPercent]                  # List of numeric types
uUnits   = [uMM, uMils, uFloat, uInteger, uBool, uDegrees, uRadians, uPercent, uString]  # List of allowable types

class FootprintWizardParameter(object):
    _true  = ['true','t','y','yes','on','1',1,]
    _false = ['false','f','n','no','off','0',0,'',None]

    _bools = _true + _false

    def __init__(self, page, name, units, default, **kwarg):
        self.page = page
        self.name = name
        self.hint = kwarg.get('hint','')               # Parameter hint (shown as mouse-over text)
        self.designator = kwarg.get('designator',' ')  # Parameter designator such as "e, D, p" (etc)

        if units.lower() in uUnits:
            self.units = units.lower()
        elif units.lower() == 'percent':
            self.units = uPercent
        elif type(units) in [list, tuple]:  # Convert a list of options into a single string
            self.units = ",".join([str(el).strip() for el in units])
        else:
            self.units = units

        self.multiple = int(kwarg.get('multiple',1))   # Check integer values are multiples of this number
        self.min_value = kwarg.get('min_value',None)   # Check numeric values are above or equal to this number
        self.max_value = kwarg.get('max_value',None)   # Check numeric values are below or equal to this number

        self.SetValue(default)
        self.default = self.raw_value  # Save value as default

    def ClearErrors(self):
        self.error_list = []

    def AddError(self, err, info=None):

        if err in self.error_list:  # prevent duplicate error messages
            return
        if info is not None:
            err = err + " (" + str(info) + ")"

        self.error_list.append(err)

    def Check(self, min_value=None, max_value=None, multiple=None, info=None):

        if min_value is None:
            min_value = self.min_value
        if max_value is None:
            max_value = self.max_value
        if multiple is None:
            multiple = self.multiple

        if self.units not in uUnits and ',' not in self.units:  # Allow either valid units or a list of strings
            self.AddError("type '{t}' unknown".format(t=self.units),info)
            self.AddError("Allowable types: " + str(self.units),info)

        if self.units in uNumeric:
            try:
                to_num = float(self.raw_value)

                if min_value is not None:  # Check minimum value if it is present
                    if to_num < min_value:
                        self.AddError("value '{v}' is below minimum ({m})".format(v=self.raw_value,m=min_value),info)

                if max_value is not None:  # Check maximum value if it is present
                    if to_num > max_value:
                        self.AddError("value '{v}' is above maximum ({m})".format(v=self.raw_value,m=max_value),info)

            except:
                self.AddError("value '{v}' is not of type '{t}'".format(v = self.raw_value, t=self.units),info)

        if self.units == uInteger:  # Perform integer specific checks
            try:
                to_int = int(self.raw_value)

                if multiple is not None and multiple > 1:
                    if (to_int % multiple) > 0:
                        self.AddError("value '{v}' is not a multiple of {m}".format(v=self.raw_value,m=multiple),info)
            except:
                self.AddError("value '{v}' is not an integer".format(v=self.raw_value),info)

        if self.units == uBool:  # Check that the value is of a correct boolean format
            if self.raw_value in [True,False] or str(self.raw_value).lower() in self._bools:
                pass
            else:
                self.AddError("value '{v}' is not a boolean value".format(v = self.raw_value),info)

    @property
    def value(self):  # Return the current value, converted to appropriate units (from string representation) if required
        v = str(self.raw_value)  # Enforce string type for known starting point

        if self.units == uInteger:  # Integer values
            return int(v)
        elif self.units in uNumeric:  # Any values that use floating points
            v = v.replace(",",".")  # Replace "," separators with "."
            v = float(v)

            if self.units == uMM: # Convert from millimetres to nanometres
                return FromMM(v)

            elif self.units == uMils:  # Convert from mils to nanometres
                return FromMils(v)

            else:  # Any other floating-point values
                return v

        elif self.units == uBool:
            if v.lower() in self._true:
                return True
            else:
                return False
        else:
            return v

    def DefaultValue(self):  # Reset the value of the parameter to its default
        self.raw_value = str(self.default)

    def SetValue(self, new_value):  # Update the value
        new_value = str(new_value)

        if len(new_value.strip()) == 0:
            if not self.units in [uString, uBool]:
                return  # Ignore empty values unless for strings or bools

        if self.units == uBool:  # Enforce the same boolean representation as is used in KiCad
            new_value = "1" if new_value.lower() in self._true else "0"
        elif self.units in uNumeric:
            new_value = new_value.replace(",", ".")  # Enforce decimal point separators
        elif ',' in self.units:  # Select from a list of values
            if new_value not in self.units.split(','):
                new_value = self.units.split(',')[0]

        self.raw_value = new_value

    def __str__(self):  # pretty-print the parameter

        s = self.name + ": " + str(self.raw_value)

        if self.units in [uMM, uMils, uPercent, uRadians, uDegrees]:
            s += self.units
        elif self.units == uBool:  # Special case for Boolean values
            s = self.name + ": {b}".format(b = "True" if self.value else "False")
        elif self.units == uString:
            s = self.name + ": '" + self.raw_value + "'"

        return s


class FootprintWizardPlugin(KiCadPlugin, object):
    def __init__(self):
        KiCadPlugin.__init__(self)
        self.defaults()

    def defaults(self):
        self.module = None
        self.params = []  # List of added parameters that observes addition order

        self.name = "KiCad FP Wizard"
        self.description = "Undefined Footprint Wizard plugin"
        self.image = ""
        self.buildmessages = ""

    def AddParam(self, page, name, unit, default, **kwarg):

        if self.GetParam(page,name) is not None:  # Param already exists!
            return

        param = FootprintWizardParameter(page, name, unit, default, **kwarg)  # Create a new parameter
        self.params.append(param)

    @property
    def parameters(self):  # This is a helper function that returns a nested (unordered) dict of the VALUES of parameters
        pages = {}  # Page dict
        for p in self.params:
            if p.page not in pages:
                pages[p.page] = {}

            pages[p.page][p.name] = p.value  # Return the 'converted' value (convert from string to actual useful units)

        return pages

    @property
    def values(self):  # Same as above
        return self.parameters

    def ResetWizard(self):  # Reset all parameters to default values
        for p in self.params:
            p.DefaultValue()

    def GetName(self):  # Return the name of this wizard
        return self.name

    def GetImage(self):  # Return the filename of the preview image associated with this wizard
        return self.image

    def GetDescription(self):  # Return the description text
        return self.description

    def GetValue(self):
        raise NotImplementedError

    def GetReferencePrefix(self):
        return "REF"  # Default reference prefix for any footprint

    def GetParam(self, page, name):  # Grab a parameter
        for p in self.params:
            if p.page == page and p.name == name:
                return p

        return None

    def CheckParam(self, page, name, **kwarg):
        self.GetParam(page,name).Check(**kwarg)

    def AnyErrors(self):
        return any([len(p.error_list) > 0 for p in self.params])

    @property
    def pages(self):  # Return an (ordered) list of the available page names
        page_list = []
        for p in self.params:
            if p.page not in page_list:
                page_list.append(p.page)

        return page_list

    def GetNumParameterPages(self):  # Return the number of parameter pages
        return len(self.pages)

    def GetParameterPageName(self,page_n):  # Return the name of a page at a given index
        return self.pages[page_n]

    def GetParametersByPageName(self, page_name):  # Return a list of parameters on a given page
        params = []

        for p in self.params:
            if p.page == page_name:
                params.append(p)

        return params

    def GetParametersByPageIndex(self, page_index):  # Return an ordered list of parameters on a given page
        return self.GetParametersByPageName(self.GetParameterPageName(page_index))

    def GetParameterDesignators(self, page_index):  # Return a list of designators associated with a given page
        params = self.GetParametersByPageIndex(page_index)
        return [p.designator for p in params]

    def GetParameterNames(self,page_index):  # Return the list of names associated with a given page
        params = self.GetParametersByPageIndex(page_index)
        return [p.name for p in params]

    def GetParameterValues(self,page_index):  # Return the list of values associated with a given page
        params = self.GetParametersByPageIndex(page_index)
        return [str(p.raw_value) for p in params]

    def GetParameterErrors(self,page_index):  # Return list of errors associated with a given page
        params = self.GetParametersByPageIndex(page_index)
        return [str("\n".join(p.error_list)) for p in params]

    def GetParameterTypes(self, page_index):  # Return list of units associated with a given page
        params = self.GetParametersByPageIndex(page_index)
        return [str(p.units) for p in params]

    def GetParameterHints(self, page_index):  # Return a list of units associated with a given page
        params = self.GetParametersByPageIndex(page_index)
        return [str(p.hint) for p in params]

    def GetParameterDesignators(self, page_index):  # Return a list of designators associated with a given page
        params = self.GetParametersByPageIndex(page_index)
        return [str(p.designator) for p in params]

    def SetParameterValues(self, page_index, list_of_values):  # Update values on a given page

        params = self.GetParametersByPageIndex(page_index)

        for i, param in enumerate(params):
            if i >= len(list_of_values):
                break
            param.SetValue(list_of_values[i])

    def GetFootprint( self ):
        self.BuildFootprint()
        return self.module

    def BuildFootprint(self):
        return

    def GetBuildMessages( self ):
        return self.buildmessages

    def Show(self):
        text  = "Footprint Wizard Name:        {name}\n".format(name=self.GetName())
        text += "Footprint Wizard Description: {desc}\n".format(desc=self.GetDescription())

        n_pages = self.GetNumParameterPages()

        text += "Pages: {n}\n".format(n=n_pages)

        for i in range(n_pages):
            name = self.GetParameterPageName(i)

            params = self.GetParametersByPageName(name)

            text += "{name}\n".format(name=name)

            for j in range(len(params)):
                text += ("\t{param}{err}\n".format(
                    param = str(params[j]),
                    err = ' *' if len(params[j].error_list) > 0 else ''
                    ))

        if self.AnyErrors():
            text += " * Errors exist for these parameters"

        return text

class ActionPlugin(KiCadPlugin, object):
    def __init__( self ):
        KiCadPlugin.__init__( self )
        self.icon_file_name = ""
        self.dark_icon_file_name = ""
        self.show_toolbar_button = False
        self.defaults()

    def defaults( self ):
        self.name = "Undefined Action plugin"
        self.category = "Undefined"
        self.description = ""

    def GetName( self ):
        return self.name

    def GetCategoryName( self ):
        return self.category

    def GetDescription( self ):
        return self.description

    def GetShowToolbarButton( self ):
        return self.show_toolbar_button

    def GetIconFileName( self, dark ):
        if dark and self.dark_icon_file_name:
            return self.dark_icon_file_name
        else:
            return self.icon_file_name

    def Run(self):
        return


SH_RECT = _pcbnew.SH_RECT

SH_SEGMENT = _pcbnew.SH_SEGMENT

SH_LINE_CHAIN = _pcbnew.SH_LINE_CHAIN

SH_CIRCLE = _pcbnew.SH_CIRCLE

SH_SIMPLE = _pcbnew.SH_SIMPLE

SH_POLY_SET = _pcbnew.SH_POLY_SET

SH_COMPOUND = _pcbnew.SH_COMPOUND

SH_ARC = _pcbnew.SH_ARC

SH_NULL = _pcbnew.SH_NULL

SH_POLY_SET_TRIANGLE = _pcbnew.SH_POLY_SET_TRIANGLE


def SHAPE_TYPE_asString(a: "SHAPE_TYPE") -> "wxString":
    r"""SHAPE_TYPE_asString(SHAPE_TYPE a) -> wxString"""
    return _pcbnew.SHAPE_TYPE_asString(a)
class SHAPE_BASE(object):
    r"""Proxy of C++ SHAPE_BASE 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, aType: "SHAPE_TYPE"):
        r"""__init__(SHAPE_BASE self, SHAPE_TYPE aType) -> SHAPE_BASE"""
        _pcbnew.SHAPE_BASE_swiginit(self, _pcbnew.new_SHAPE_BASE(aType))
    __swig_destroy__ = _pcbnew.delete_SHAPE_BASE

    def Type(self) -> "SHAPE_TYPE":
        r"""Type(SHAPE_BASE self) -> SHAPE_TYPE"""
        return _pcbnew.SHAPE_BASE_Type(self)

    def HasIndexableSubshapes(self) -> "bool":
        r"""HasIndexableSubshapes(SHAPE_BASE self) -> bool"""
        return _pcbnew.SHAPE_BASE_HasIndexableSubshapes(self)

    def GetIndexableSubshapeCount(self) -> "size_t":
        r"""GetIndexableSubshapeCount(SHAPE_BASE self) -> size_t"""
        return _pcbnew.SHAPE_BASE_GetIndexableSubshapeCount(self)

    def GetIndexableSubshapes(self, aSubshapes: "std::vector< SHAPE *,std::allocator< SHAPE * > > &") -> "void":
        r"""GetIndexableSubshapes(SHAPE_BASE self, std::vector< SHAPE *,std::allocator< SHAPE * > > & aSubshapes)"""
        return _pcbnew.SHAPE_BASE_GetIndexableSubshapes(self, aSubshapes)

# Register SHAPE_BASE in _pcbnew:
_pcbnew.SHAPE_BASE_swigregister(SHAPE_BASE)

class SHAPE(SHAPE_BASE):
    r"""Proxy of C++ SHAPE 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
    MIN_PRECISION_IU = _pcbnew.SHAPE_MIN_PRECISION_IU
    
    __swig_destroy__ = _pcbnew.delete_SHAPE

    def Clone(self) -> "SHAPE *":
        r"""Clone(SHAPE self) -> SHAPE"""
        return _pcbnew.SHAPE_Clone(self)

    def IsNull(self) -> "bool":
        r"""IsNull(SHAPE self) -> bool"""
        return _pcbnew.SHAPE_IsNull(self)

    def Collide(self, *args) -> "bool":
        r"""
        Collide(SHAPE self, VECTOR2I aP, int aClearance=0, int * aActual=None, VECTOR2I aLocation=None) -> bool
        Collide(SHAPE self, SHAPE aShape, int aClearance, VECTOR2I aMTV) -> bool
        Collide(SHAPE self, SHAPE aShape, int aClearance=0, int * aActual=None, VECTOR2I aLocation=None) -> bool
        Collide(SHAPE self, SEG const & aSeg, int aClearance=0, int * aActual=None, VECTOR2I aLocation=None) -> bool
        """
        return _pcbnew.SHAPE_Collide(self, *args)

    def BBox(self, aClearance: "int"=0) -> "BOX2I const":
        r"""BBox(SHAPE self, int aClearance=0) -> BOX2I const"""
        return _pcbnew.SHAPE_BBox(self, aClearance)

    def Centre(self) -> "VECTOR2I":
        r"""Centre(SHAPE self) -> VECTOR2I"""
        return _pcbnew.SHAPE_Centre(self)

    def Rotate(self, *args) -> "void":
        r"""Rotate(SHAPE self, double aAngle, VECTOR2I aCenter={ 0, 0 })"""
        return _pcbnew.SHAPE_Rotate(self, *args)

    def Move(self, aVector: "VECTOR2I") -> "void":
        r"""Move(SHAPE self, VECTOR2I aVector)"""
        return _pcbnew.SHAPE_Move(self, aVector)

    def IsSolid(self) -> "bool":
        r"""IsSolid(SHAPE self) -> bool"""
        return _pcbnew.SHAPE_IsSolid(self)

    def Parse(self, aStream: "std::stringstream &") -> "bool":
        r"""Parse(SHAPE self, std::stringstream & aStream) -> bool"""
        return _pcbnew.SHAPE_Parse(self, aStream)

    def Format(self) -> "std::string const":
        r"""Format(SHAPE self) -> string"""
        return _pcbnew.SHAPE_Format(self)

# Register SHAPE in _pcbnew:
_pcbnew.SHAPE_swigregister(SHAPE)

class SHAPE_LINE_CHAIN_BASE(SHAPE):
    r"""Proxy of C++ SHAPE_LINE_CHAIN_BASE 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__ = _pcbnew.delete_SHAPE_LINE_CHAIN_BASE

    def Collide(self, *args) -> "bool":
        r"""
        Collide(SHAPE_LINE_CHAIN_BASE self, VECTOR2I aP, int aClearance=0, int * aActual=None, VECTOR2I aLocation=None) -> bool
        Collide(SHAPE_LINE_CHAIN_BASE self, SEG const & aSeg, int aClearance=0, int * aActual=None, VECTOR2I aLocation=None) -> bool
        """
        return _pcbnew.SHAPE_LINE_CHAIN_BASE_Collide(self, *args)

    def SquaredDistance(self, aP: "VECTOR2I", aOutlineOnly: "bool"=False) -> "SEG::ecoord":
        r"""SquaredDistance(SHAPE_LINE_CHAIN_BASE self, VECTOR2I aP, bool aOutlineOnly=False) -> SEG::ecoord"""
        return _pcbnew.SHAPE_LINE_CHAIN_BASE_SquaredDistance(self, aP, aOutlineOnly)

    def PointInside(self, aPt: "VECTOR2I", aAccuracy: "int"=0, aUseBBoxCache: "bool"=False) -> "bool":
        r"""PointInside(SHAPE_LINE_CHAIN_BASE self, VECTOR2I aPt, int aAccuracy=0, bool aUseBBoxCache=False) -> bool"""
        return _pcbnew.SHAPE_LINE_CHAIN_BASE_PointInside(self, aPt, aAccuracy, aUseBBoxCache)

    def PointOnEdge(self, aP: "VECTOR2I", aAccuracy: "int"=0) -> "bool":
        r"""PointOnEdge(SHAPE_LINE_CHAIN_BASE self, VECTOR2I aP, int aAccuracy=0) -> bool"""
        return _pcbnew.SHAPE_LINE_CHAIN_BASE_PointOnEdge(self, aP, aAccuracy)

    def EdgeContainingPoint(self, aP: "VECTOR2I", aAccuracy: "int"=0) -> "int":
        r"""EdgeContainingPoint(SHAPE_LINE_CHAIN_BASE self, VECTOR2I aP, int aAccuracy=0) -> int"""
        return _pcbnew.SHAPE_LINE_CHAIN_BASE_EdgeContainingPoint(self, aP, aAccuracy)

    def GetPoint(self, aIndex: "int") -> "VECTOR2I const":
        r"""GetPoint(SHAPE_LINE_CHAIN_BASE self, int aIndex) -> VECTOR2I"""
        return _pcbnew.SHAPE_LINE_CHAIN_BASE_GetPoint(self, aIndex)

    def GetSegment(self, aIndex: "int") -> "SEG const":
        r"""GetSegment(SHAPE_LINE_CHAIN_BASE self, int aIndex) -> SEG const"""
        return _pcbnew.SHAPE_LINE_CHAIN_BASE_GetSegment(self, aIndex)

    def GetPointCount(self) -> "size_t":
        r"""GetPointCount(SHAPE_LINE_CHAIN_BASE self) -> size_t"""
        return _pcbnew.SHAPE_LINE_CHAIN_BASE_GetPointCount(self)

    def GetSegmentCount(self) -> "size_t":
        r"""GetSegmentCount(SHAPE_LINE_CHAIN_BASE self) -> size_t"""
        return _pcbnew.SHAPE_LINE_CHAIN_BASE_GetSegmentCount(self)

    def IsClosed(self) -> "bool":
        r"""IsClosed(SHAPE_LINE_CHAIN_BASE self) -> bool"""
        return _pcbnew.SHAPE_LINE_CHAIN_BASE_IsClosed(self)

    def GetCachedBBox(self) -> "BOX2I *":
        r"""GetCachedBBox(SHAPE_LINE_CHAIN_BASE self) -> BOX2I *"""
        return _pcbnew.SHAPE_LINE_CHAIN_BASE_GetCachedBBox(self)

# Register SHAPE_LINE_CHAIN_BASE in _pcbnew:
_pcbnew.SHAPE_LINE_CHAIN_BASE_swigregister(SHAPE_LINE_CHAIN_BASE)

class VECTOR2I(object):
    r"""Proxy of C++ VECTOR2< int > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    x = property(_pcbnew.VECTOR2I_x_get, _pcbnew.VECTOR2I_x_set, doc=r"""x : int""")
    y = property(_pcbnew.VECTOR2I_y_get, _pcbnew.VECTOR2I_y_set, doc=r"""y : int""")

    def __init__(self, *args):
        r"""
        __init__(VECTOR2I self) -> VECTOR2I
        __init__(VECTOR2I self, wxPoint aPoint) -> VECTOR2I
        __init__(VECTOR2I self, wxSize aSize) -> VECTOR2I
        __init__(VECTOR2I self, int x, int y) -> VECTOR2I
        __init__(VECTOR2I self, VECTOR2I aVec) -> VECTOR2I
        """
        _pcbnew.VECTOR2I_swiginit(self, _pcbnew.new_VECTOR2I(*args))

    def getWxPoint(self) -> "wxPoint":
        r"""getWxPoint(VECTOR2I self) -> wxPoint"""
        return _pcbnew.VECTOR2I_getWxPoint(self)

    def EuclideanNorm(self) -> "int":
        r"""EuclideanNorm(VECTOR2I self) -> int"""
        return _pcbnew.VECTOR2I_EuclideanNorm(self)

    def SquaredEuclideanNorm(self) -> "VECTOR2< int >::extended_type":
        r"""SquaredEuclideanNorm(VECTOR2I self) -> VECTOR2< int >::extended_type"""
        return _pcbnew.VECTOR2I_SquaredEuclideanNorm(self)

    def Perpendicular(self) -> "VECTOR2< int >":
        r"""Perpendicular(VECTOR2I self) -> VECTOR2I"""
        return _pcbnew.VECTOR2I_Perpendicular(self)

    def Resize(self, aNewLength: "int") -> "VECTOR2< int >":
        r"""Resize(VECTOR2I self, int aNewLength) -> VECTOR2I"""
        return _pcbnew.VECTOR2I_Resize(self, aNewLength)

    def Angle(self) -> "double":
        r"""Angle(VECTOR2I self) -> double"""
        return _pcbnew.VECTOR2I_Angle(self)

    def Rotate(self, aAngle: "double") -> "VECTOR2< int >":
        r"""Rotate(VECTOR2I self, double aAngle) -> VECTOR2I"""
        return _pcbnew.VECTOR2I_Rotate(self, aAngle)

    def Format(self) -> "std::string const":
        r"""Format(VECTOR2I self) -> string"""
        return _pcbnew.VECTOR2I_Format(self)

    def Cross(self, aVector: "VECTOR2I") -> "VECTOR2< int >::extended_type":
        r"""Cross(VECTOR2I self, VECTOR2I aVector) -> VECTOR2< int >::extended_type"""
        return _pcbnew.VECTOR2I_Cross(self, aVector)

    def Dot(self, aVector: "VECTOR2I") -> "VECTOR2< int >::extended_type":
        r"""Dot(VECTOR2I self, VECTOR2I aVector) -> VECTOR2< int >::extended_type"""
        return _pcbnew.VECTOR2I_Dot(self, aVector)

    def __add__(self, *args) -> "VECTOR2< int >":
        r"""
        __add__(VECTOR2I self, VECTOR2I aVector) -> VECTOR2I
        __add__(VECTOR2I self, int const & aScalar) -> VECTOR2I
        """
        return _pcbnew.VECTOR2I___add__(self, *args)

    def __iadd__(self, *args) -> "VECTOR2< int > &":
        r"""
        __iadd__(VECTOR2I self, VECTOR2I aVector) -> VECTOR2I
        __iadd__(VECTOR2I self, int const & aScalar) -> VECTOR2I
        """
        return _pcbnew.VECTOR2I___iadd__(self, *args)

    def __sub__(self, *args) -> "VECTOR2< int >":
        r"""
        __sub__(VECTOR2I self, VECTOR2I aVector) -> VECTOR2I
        __sub__(VECTOR2I self, int const & aScalar) -> VECTOR2I
        """
        return _pcbnew.VECTOR2I___sub__(self, *args)

    def __isub__(self, *args) -> "VECTOR2< int > &":
        r"""
        __isub__(VECTOR2I self, VECTOR2I aVector) -> VECTOR2I
        __isub__(VECTOR2I self, int const & aScalar) -> VECTOR2I
        """
        return _pcbnew.VECTOR2I___isub__(self, *args)

    def __neg__(self) -> "VECTOR2< int >":
        r"""__neg__(VECTOR2I self) -> VECTOR2I"""
        return _pcbnew.VECTOR2I___neg__(self)

    def __mul__(self, *args) -> "VECTOR2< int >":
        r"""
        __mul__(VECTOR2I self, VECTOR2I aVector) -> VECTOR2< int >::extended_type
        __mul__(VECTOR2I self, int const & aFactor) -> VECTOR2I
        """
        return _pcbnew.VECTOR2I___mul__(self, *args)

    def __truediv__(self, *args):
        return _pcbnew.VECTOR2I___truediv__(self, *args)
    __div__ = __truediv__



    def __eq__(self, aVector: "VECTOR2I") -> "bool":
        r"""__eq__(VECTOR2I self, VECTOR2I aVector) -> bool"""
        return _pcbnew.VECTOR2I___eq__(self, aVector)

    def __ne__(self, aVector: "VECTOR2I") -> "bool":
        r"""__ne__(VECTOR2I self, VECTOR2I aVector) -> bool"""
        return _pcbnew.VECTOR2I___ne__(self, aVector)

    def __lt__(self, aVector: "VECTOR2I") -> "bool":
        r"""__lt__(VECTOR2I self, VECTOR2I aVector) -> bool"""
        return _pcbnew.VECTOR2I___lt__(self, aVector)

    def __le__(self, aVector: "VECTOR2I") -> "bool":
        r"""__le__(VECTOR2I self, VECTOR2I aVector) -> bool"""
        return _pcbnew.VECTOR2I___le__(self, aVector)

    def __gt__(self, aVector: "VECTOR2I") -> "bool":
        r"""__gt__(VECTOR2I self, VECTOR2I aVector) -> bool"""
        return _pcbnew.VECTOR2I___gt__(self, aVector)

    def __ge__(self, aVector: "VECTOR2I") -> "bool":
        r"""__ge__(VECTOR2I self, VECTOR2I aVector) -> bool"""
        return _pcbnew.VECTOR2I___ge__(self, aVector)

    def Set(self, x: "long", y: "long") -> "void":
        r"""Set(VECTOR2I self, long x, long y)"""
        return _pcbnew.VECTOR2I_Set(self, x, y)

    def Get(self) -> "PyObject *":
        r"""Get(VECTOR2I self) -> PyObject *"""
        return _pcbnew.VECTOR2I_Get(self)

    def __eq__(self,other):            return (self.x==other.x and self.y==other.y)
    def __ne__(self,other):            return not (self==other)
    def __str__(self):                 return str(self.Get())
    def __repr__(self):                return 'VECTOR2I'+str(self.Get())
    def __len__(self):                 return len(self.Get())
    def __getitem__(self, index):      return self.Get()[index]
    def __setitem__(self, index, val):
        if index == 0:
            self.x = val
        elif index == 1:
            self.y = val
        else:
            raise IndexError
    def __nonzero__(self):               return self.Get() != (0,0)


    __swig_destroy__ = _pcbnew.delete_VECTOR2I

# Register VECTOR2I in _pcbnew:
_pcbnew.VECTOR2I_swigregister(VECTOR2I)

class VECTOR_VECTOR2I(object):
    r"""Proxy of C++ std::vector< VECTOR2I > 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) -> "swig::SwigPyIterator *":
        r"""iterator(VECTOR_VECTOR2I self) -> SwigPyIterator"""
        return _pcbnew.VECTOR_VECTOR2I_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(VECTOR_VECTOR2I self) -> bool"""
        return _pcbnew.VECTOR_VECTOR2I___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(VECTOR_VECTOR2I self) -> bool"""
        return _pcbnew.VECTOR_VECTOR2I___bool__(self)

    def __len__(self) -> "std::vector< VECTOR2< int > >::size_type":
        r"""__len__(VECTOR_VECTOR2I self) -> std::vector< VECTOR2< int > >::size_type"""
        return _pcbnew.VECTOR_VECTOR2I___len__(self)

    def __getslice__(self, i: "std::vector< VECTOR2< int > >::difference_type", j: "std::vector< VECTOR2< int > >::difference_type") -> "std::vector< VECTOR2< int >,std::allocator< VECTOR2< int > > > *":
        r"""__getslice__(VECTOR_VECTOR2I self, std::vector< VECTOR2< int > >::difference_type i, std::vector< VECTOR2< int > >::difference_type j) -> VECTOR_VECTOR2I"""
        return _pcbnew.VECTOR_VECTOR2I___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        r"""
        __setslice__(VECTOR_VECTOR2I self, std::vector< VECTOR2< int > >::difference_type i, std::vector< VECTOR2< int > >::difference_type j)
        __setslice__(VECTOR_VECTOR2I self, std::vector< VECTOR2< int > >::difference_type i, std::vector< VECTOR2< int > >::difference_type j, VECTOR_VECTOR2I v)
        """
        return _pcbnew.VECTOR_VECTOR2I___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< VECTOR2< int > >::difference_type", j: "std::vector< VECTOR2< int > >::difference_type") -> "void":
        r"""__delslice__(VECTOR_VECTOR2I self, std::vector< VECTOR2< int > >::difference_type i, std::vector< VECTOR2< int > >::difference_type j)"""
        return _pcbnew.VECTOR_VECTOR2I___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        r"""
        __delitem__(VECTOR_VECTOR2I self, std::vector< VECTOR2< int > >::difference_type i)
        __delitem__(VECTOR_VECTOR2I self, PySliceObject * slice)
        """
        return _pcbnew.VECTOR_VECTOR2I___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< VECTOR2< int > >::value_type const &":
        r"""
        __getitem__(VECTOR_VECTOR2I self, PySliceObject * slice) -> VECTOR_VECTOR2I
        __getitem__(VECTOR_VECTOR2I self, std::vector< VECTOR2< int > >::difference_type i) -> VECTOR2I
        """
        return _pcbnew.VECTOR_VECTOR2I___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(VECTOR_VECTOR2I self, PySliceObject * slice, VECTOR_VECTOR2I v)
        __setitem__(VECTOR_VECTOR2I self, PySliceObject * slice)
        __setitem__(VECTOR_VECTOR2I self, std::vector< VECTOR2< int > >::difference_type i, VECTOR2I x)
        """
        return _pcbnew.VECTOR_VECTOR2I___setitem__(self, *args)

    def pop(self) -> "std::vector< VECTOR2< int > >::value_type":
        r"""pop(VECTOR_VECTOR2I self) -> VECTOR2I"""
        return _pcbnew.VECTOR_VECTOR2I_pop(self)

    def append(self, x: "VECTOR2I") -> "void":
        r"""append(VECTOR_VECTOR2I self, VECTOR2I x)"""
        return _pcbnew.VECTOR_VECTOR2I_append(self, x)

    def empty(self) -> "bool":
        r"""empty(VECTOR_VECTOR2I self) -> bool"""
        return _pcbnew.VECTOR_VECTOR2I_empty(self)

    def size(self) -> "std::vector< VECTOR2< int > >::size_type":
        r"""size(VECTOR_VECTOR2I self) -> std::vector< VECTOR2< int > >::size_type"""
        return _pcbnew.VECTOR_VECTOR2I_size(self)

    def swap(self, v: "VECTOR_VECTOR2I") -> "void":
        r"""swap(VECTOR_VECTOR2I self, VECTOR_VECTOR2I v)"""
        return _pcbnew.VECTOR_VECTOR2I_swap(self, v)

    def begin(self) -> "std::vector< VECTOR2< int > >::iterator":
        r"""begin(VECTOR_VECTOR2I self) -> std::vector< VECTOR2< int > >::iterator"""
        return _pcbnew.VECTOR_VECTOR2I_begin(self)

    def end(self) -> "std::vector< VECTOR2< int > >::iterator":
        r"""end(VECTOR_VECTOR2I self) -> std::vector< VECTOR2< int > >::iterator"""
        return _pcbnew.VECTOR_VECTOR2I_end(self)

    def rbegin(self) -> "std::vector< VECTOR2< int > >::reverse_iterator":
        r"""rbegin(VECTOR_VECTOR2I self) -> std::vector< VECTOR2< int > >::reverse_iterator"""
        return _pcbnew.VECTOR_VECTOR2I_rbegin(self)

    def rend(self) -> "std::vector< VECTOR2< int > >::reverse_iterator":
        r"""rend(VECTOR_VECTOR2I self) -> std::vector< VECTOR2< int > >::reverse_iterator"""
        return _pcbnew.VECTOR_VECTOR2I_rend(self)

    def clear(self) -> "void":
        r"""clear(VECTOR_VECTOR2I self)"""
        return _pcbnew.VECTOR_VECTOR2I_clear(self)

    def get_allocator(self) -> "std::vector< VECTOR2< int > >::allocator_type":
        r"""get_allocator(VECTOR_VECTOR2I self) -> std::vector< VECTOR2< int > >::allocator_type"""
        return _pcbnew.VECTOR_VECTOR2I_get_allocator(self)

    def pop_back(self) -> "void":
        r"""pop_back(VECTOR_VECTOR2I self)"""
        return _pcbnew.VECTOR_VECTOR2I_pop_back(self)

    def erase(self, *args) -> "std::vector< VECTOR2< int > >::iterator":
        r"""
        erase(VECTOR_VECTOR2I self, std::vector< VECTOR2< int > >::iterator pos) -> std::vector< VECTOR2< int > >::iterator
        erase(VECTOR_VECTOR2I self, std::vector< VECTOR2< int > >::iterator first, std::vector< VECTOR2< int > >::iterator last) -> std::vector< VECTOR2< int > >::iterator
        """
        return _pcbnew.VECTOR_VECTOR2I_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(VECTOR_VECTOR2I self) -> VECTOR_VECTOR2I
        __init__(VECTOR_VECTOR2I self, VECTOR_VECTOR2I other) -> VECTOR_VECTOR2I
        __init__(VECTOR_VECTOR2I self, std::vector< VECTOR2< int > >::size_type size) -> VECTOR_VECTOR2I
        __init__(VECTOR_VECTOR2I self, std::vector< VECTOR2< int > >::size_type size, VECTOR2I value) -> VECTOR_VECTOR2I
        """
        _pcbnew.VECTOR_VECTOR2I_swiginit(self, _pcbnew.new_VECTOR_VECTOR2I(*args))

    def push_back(self, x: "VECTOR2I") -> "void":
        r"""push_back(VECTOR_VECTOR2I self, VECTOR2I x)"""
        return _pcbnew.VECTOR_VECTOR2I_push_back(self, x)

    def front(self) -> "std::vector< VECTOR2< int > >::value_type const &":
        r"""front(VECTOR_VECTOR2I self) -> VECTOR2I"""
        return _pcbnew.VECTOR_VECTOR2I_front(self)

    def back(self) -> "std::vector< VECTOR2< int > >::value_type const &":
        r"""back(VECTOR_VECTOR2I self) -> VECTOR2I"""
        return _pcbnew.VECTOR_VECTOR2I_back(self)

    def assign(self, n: "std::vector< VECTOR2< int > >::size_type", x: "VECTOR2I") -> "void":
        r"""assign(VECTOR_VECTOR2I self, std::vector< VECTOR2< int > >::size_type n, VECTOR2I x)"""
        return _pcbnew.VECTOR_VECTOR2I_assign(self, n, x)

    def resize(self, *args) -> "void":
        r"""
        resize(VECTOR_VECTOR2I self, std::vector< VECTOR2< int > >::size_type new_size)
        resize(VECTOR_VECTOR2I self, std::vector< VECTOR2< int > >::size_type new_size, VECTOR2I x)
        """
        return _pcbnew.VECTOR_VECTOR2I_resize(self, *args)

    def insert(self, *args) -> "void":
        r"""
        insert(VECTOR_VECTOR2I self, std::vector< VECTOR2< int > >::iterator pos, VECTOR2I x) -> std::vector< VECTOR2< int > >::iterator
        insert(VECTOR_VECTOR2I self, std::vector< VECTOR2< int > >::iterator pos, std::vector< VECTOR2< int > >::size_type n, VECTOR2I x)
        """
        return _pcbnew.VECTOR_VECTOR2I_insert(self, *args)

    def reserve(self, n: "std::vector< VECTOR2< int > >::size_type") -> "void":
        r"""reserve(VECTOR_VECTOR2I self, std::vector< VECTOR2< int > >::size_type n)"""
        return _pcbnew.VECTOR_VECTOR2I_reserve(self, n)

    def capacity(self) -> "std::vector< VECTOR2< int > >::size_type":
        r"""capacity(VECTOR_VECTOR2I self) -> std::vector< VECTOR2< int > >::size_type"""
        return _pcbnew.VECTOR_VECTOR2I_capacity(self)
    __swig_destroy__ = _pcbnew.delete_VECTOR_VECTOR2I

# Register VECTOR_VECTOR2I in _pcbnew:
_pcbnew.VECTOR_VECTOR2I_swigregister(VECTOR_VECTOR2I)

class CLIPPER_Z_VALUE(object):
    r"""Proxy of C++ CLIPPER_Z_VALUE 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__(CLIPPER_Z_VALUE self) -> CLIPPER_Z_VALUE
        __init__(CLIPPER_Z_VALUE self, std::pair< ssize_t,ssize_t > const aShapeIndices, ssize_t aOffset=0) -> CLIPPER_Z_VALUE
        """
        _pcbnew.CLIPPER_Z_VALUE_swiginit(self, _pcbnew.new_CLIPPER_Z_VALUE(*args))
    m_FirstArcIdx = property(_pcbnew.CLIPPER_Z_VALUE_m_FirstArcIdx_get, _pcbnew.CLIPPER_Z_VALUE_m_FirstArcIdx_set, doc=r"""m_FirstArcIdx : ssize_t""")
    m_SecondArcIdx = property(_pcbnew.CLIPPER_Z_VALUE_m_SecondArcIdx_get, _pcbnew.CLIPPER_Z_VALUE_m_SecondArcIdx_set, doc=r"""m_SecondArcIdx : ssize_t""")
    __swig_destroy__ = _pcbnew.delete_CLIPPER_Z_VALUE

# Register CLIPPER_Z_VALUE in _pcbnew:
_pcbnew.CLIPPER_Z_VALUE_swigregister(CLIPPER_Z_VALUE)

class SHAPE_LINE_CHAIN(SHAPE_LINE_CHAIN_BASE):
    r"""Proxy of C++ SHAPE_LINE_CHAIN 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__(SHAPE_LINE_CHAIN self) -> SHAPE_LINE_CHAIN
        __init__(SHAPE_LINE_CHAIN self, SHAPE_LINE_CHAIN aShape) -> SHAPE_LINE_CHAIN
        __init__(SHAPE_LINE_CHAIN self, intVector aV) -> SHAPE_LINE_CHAIN
        __init__(SHAPE_LINE_CHAIN self, wxPoint_Vector aV, bool aClosed=False) -> SHAPE_LINE_CHAIN
        __init__(SHAPE_LINE_CHAIN self, VECTOR_VECTOR2I aV, bool aClosed=False) -> SHAPE_LINE_CHAIN
        __init__(SHAPE_LINE_CHAIN self, SHAPE_ARC const & aArc, bool aClosed=False) -> SHAPE_LINE_CHAIN
        __init__(SHAPE_LINE_CHAIN self, ClipperLib::Path const & aPath, std::vector< CLIPPER_Z_VALUE,std::allocator< CLIPPER_Z_VALUE > > const & aZValueBuffer, std::vector< SHAPE_ARC,std::allocator< SHAPE_ARC > > const & aArcBuffer) -> SHAPE_LINE_CHAIN
        """
        _pcbnew.SHAPE_LINE_CHAIN_swiginit(self, _pcbnew.new_SHAPE_LINE_CHAIN(*args))
    __swig_destroy__ = _pcbnew.delete_SHAPE_LINE_CHAIN

    def Collide(self, *args) -> "bool":
        r"""
        Collide(SHAPE_LINE_CHAIN self, VECTOR2I aP, int aClearance=0, int * aActual=None, VECTOR2I aLocation=None) -> bool
        Collide(SHAPE_LINE_CHAIN self, SEG const & aSeg, int aClearance=0, int * aActual=None, VECTOR2I aLocation=None) -> bool
        """
        return _pcbnew.SHAPE_LINE_CHAIN_Collide(self, *args)

    def Clone(self) -> "SHAPE *":
        r"""Clone(SHAPE_LINE_CHAIN self) -> SHAPE"""
        return _pcbnew.SHAPE_LINE_CHAIN_Clone(self)

    def Clear(self) -> "void":
        r"""Clear(SHAPE_LINE_CHAIN self)"""
        return _pcbnew.SHAPE_LINE_CHAIN_Clear(self)

    def SetClosed(self, aClosed: "bool") -> "void":
        r"""SetClosed(SHAPE_LINE_CHAIN self, bool aClosed)"""
        return _pcbnew.SHAPE_LINE_CHAIN_SetClosed(self, aClosed)

    def IsClosed(self) -> "bool":
        r"""IsClosed(SHAPE_LINE_CHAIN self) -> bool"""
        return _pcbnew.SHAPE_LINE_CHAIN_IsClosed(self)

    def SetWidth(self, aWidth: "int") -> "void":
        r"""SetWidth(SHAPE_LINE_CHAIN self, int aWidth)"""
        return _pcbnew.SHAPE_LINE_CHAIN_SetWidth(self, aWidth)

    def Width(self) -> "int":
        r"""Width(SHAPE_LINE_CHAIN self) -> int"""
        return _pcbnew.SHAPE_LINE_CHAIN_Width(self)

    def SegmentCount(self) -> "int":
        r"""SegmentCount(SHAPE_LINE_CHAIN self) -> int"""
        return _pcbnew.SHAPE_LINE_CHAIN_SegmentCount(self)

    def ShapeCount(self) -> "int":
        r"""ShapeCount(SHAPE_LINE_CHAIN self) -> int"""
        return _pcbnew.SHAPE_LINE_CHAIN_ShapeCount(self)

    def PointCount(self) -> "int":
        r"""PointCount(SHAPE_LINE_CHAIN self) -> int"""
        return _pcbnew.SHAPE_LINE_CHAIN_PointCount(self)

    def Segment(self, aIndex: "int") -> "SEG":
        r"""Segment(SHAPE_LINE_CHAIN self, int aIndex) -> SEG"""
        return _pcbnew.SHAPE_LINE_CHAIN_Segment(self, aIndex)

    def CSegment(self, aIndex: "int") -> "SEG const":
        r"""CSegment(SHAPE_LINE_CHAIN self, int aIndex) -> SEG const"""
        return _pcbnew.SHAPE_LINE_CHAIN_CSegment(self, aIndex)

    def NextShape(self, aPointIndex: "int", aForwards: "bool"=True) -> "int":
        r"""NextShape(SHAPE_LINE_CHAIN self, int aPointIndex, bool aForwards=True) -> int"""
        return _pcbnew.SHAPE_LINE_CHAIN_NextShape(self, aPointIndex, aForwards)

    def PrevShape(self, aPointIndex: "int") -> "int":
        r"""PrevShape(SHAPE_LINE_CHAIN self, int aPointIndex) -> int"""
        return _pcbnew.SHAPE_LINE_CHAIN_PrevShape(self, aPointIndex)

    def SetPoint(self, aIndex: "int", aPos: "VECTOR2I") -> "void":
        r"""SetPoint(SHAPE_LINE_CHAIN self, int aIndex, VECTOR2I aPos)"""
        return _pcbnew.SHAPE_LINE_CHAIN_SetPoint(self, aIndex, aPos)

    def CPoint(self, aIndex: "int") -> "VECTOR2I const &":
        r"""CPoint(SHAPE_LINE_CHAIN self, int aIndex) -> VECTOR2I"""
        return _pcbnew.SHAPE_LINE_CHAIN_CPoint(self, aIndex)

    def CPoints(self) -> "std::vector< VECTOR2I,std::allocator< VECTOR2I > > const &":
        r"""CPoints(SHAPE_LINE_CHAIN self) -> VECTOR_VECTOR2I"""
        return _pcbnew.SHAPE_LINE_CHAIN_CPoints(self)

    def CLastPoint(self) -> "VECTOR2I const &":
        r"""CLastPoint(SHAPE_LINE_CHAIN self) -> VECTOR2I"""
        return _pcbnew.SHAPE_LINE_CHAIN_CLastPoint(self)

    def CArcs(self) -> "std::vector< SHAPE_ARC,std::allocator< SHAPE_ARC > > const &":
        r"""CArcs(SHAPE_LINE_CHAIN self) -> std::vector< SHAPE_ARC,std::allocator< SHAPE_ARC > > const &"""
        return _pcbnew.SHAPE_LINE_CHAIN_CArcs(self)

    def CShapes(self) -> "std::vector< std::pair< ssize_t,ssize_t >,std::allocator< std::pair< ssize_t,ssize_t > > > const &":
        r"""CShapes(SHAPE_LINE_CHAIN self) -> std::vector< std::pair< ssize_t,ssize_t >,std::allocator< std::pair< ssize_t,ssize_t > > > const &"""
        return _pcbnew.SHAPE_LINE_CHAIN_CShapes(self)

    def BBox(self, aClearance: "int"=0) -> "BOX2I const":
        r"""BBox(SHAPE_LINE_CHAIN self, int aClearance=0) -> BOX2I const"""
        return _pcbnew.SHAPE_LINE_CHAIN_BBox(self, aClearance)

    def GenerateBBoxCache(self) -> "void":
        r"""GenerateBBoxCache(SHAPE_LINE_CHAIN self)"""
        return _pcbnew.SHAPE_LINE_CHAIN_GenerateBBoxCache(self)

    def GetCachedBBox(self) -> "BOX2I *":
        r"""GetCachedBBox(SHAPE_LINE_CHAIN self) -> BOX2I *"""
        return _pcbnew.SHAPE_LINE_CHAIN_GetCachedBBox(self)

    def Distance(self, aP: "VECTOR2I", aOutlineOnly: "bool"=False) -> "int":
        r"""Distance(SHAPE_LINE_CHAIN self, VECTOR2I aP, bool aOutlineOnly=False) -> int"""
        return _pcbnew.SHAPE_LINE_CHAIN_Distance(self, aP, aOutlineOnly)

    def Reverse(self) -> "SHAPE_LINE_CHAIN const":
        r"""Reverse(SHAPE_LINE_CHAIN self) -> SHAPE_LINE_CHAIN"""
        return _pcbnew.SHAPE_LINE_CHAIN_Reverse(self)

    def ClearArcs(self) -> "void":
        r"""ClearArcs(SHAPE_LINE_CHAIN self)"""
        return _pcbnew.SHAPE_LINE_CHAIN_ClearArcs(self)

    def Length(self) -> "long long":
        r"""Length(SHAPE_LINE_CHAIN self) -> long long"""
        return _pcbnew.SHAPE_LINE_CHAIN_Length(self)

    def Append(self, *args) -> "void":
        r"""
        Append(SHAPE_LINE_CHAIN self, int aX, int aY, bool aAllowDuplication=False)
        Append(SHAPE_LINE_CHAIN self, VECTOR2I aP, bool aAllowDuplication=False)
        Append(SHAPE_LINE_CHAIN self, SHAPE_LINE_CHAIN aOtherLine)
        Append(SHAPE_LINE_CHAIN self, SHAPE_ARC const & aArc)
        """
        return _pcbnew.SHAPE_LINE_CHAIN_Append(self, *args)

    def Insert(self, *args) -> "void":
        r"""
        Insert(SHAPE_LINE_CHAIN self, size_t aVertex, VECTOR2I aP)
        Insert(SHAPE_LINE_CHAIN self, size_t aVertex, SHAPE_ARC const & aArc)
        """
        return _pcbnew.SHAPE_LINE_CHAIN_Insert(self, *args)

    def Replace(self, *args) -> "void":
        r"""
        Replace(SHAPE_LINE_CHAIN self, int aStartIndex, int aEndIndex, VECTOR2I aP)
        Replace(SHAPE_LINE_CHAIN self, int aStartIndex, int aEndIndex, SHAPE_LINE_CHAIN aLine)
        """
        return _pcbnew.SHAPE_LINE_CHAIN_Replace(self, *args)

    def Remove(self, *args) -> "void":
        r"""
        Remove(SHAPE_LINE_CHAIN self, int aStartIndex, int aEndIndex)
        Remove(SHAPE_LINE_CHAIN self, int aIndex)
        """
        return _pcbnew.SHAPE_LINE_CHAIN_Remove(self, *args)

    def RemoveShape(self, aPointIndex: "int") -> "void":
        r"""RemoveShape(SHAPE_LINE_CHAIN self, int aPointIndex)"""
        return _pcbnew.SHAPE_LINE_CHAIN_RemoveShape(self, aPointIndex)

    def Split(self, aP: "VECTOR2I") -> "int":
        r"""Split(SHAPE_LINE_CHAIN self, VECTOR2I aP) -> int"""
        return _pcbnew.SHAPE_LINE_CHAIN_Split(self, aP)

    def Find(self, aP: "VECTOR2I", aThreshold: "int"=0) -> "int":
        r"""Find(SHAPE_LINE_CHAIN self, VECTOR2I aP, int aThreshold=0) -> int"""
        return _pcbnew.SHAPE_LINE_CHAIN_Find(self, aP, aThreshold)

    def FindSegment(self, aP: "VECTOR2I", aThreshold: "int"=1) -> "int":
        r"""FindSegment(SHAPE_LINE_CHAIN self, VECTOR2I aP, int aThreshold=1) -> int"""
        return _pcbnew.SHAPE_LINE_CHAIN_FindSegment(self, aP, aThreshold)

    def Slice(self, aStartIndex: "int", aEndIndex: "int"=-1) -> "SHAPE_LINE_CHAIN const":
        r"""Slice(SHAPE_LINE_CHAIN self, int aStartIndex, int aEndIndex=-1) -> SHAPE_LINE_CHAIN"""
        return _pcbnew.SHAPE_LINE_CHAIN_Slice(self, aStartIndex, aEndIndex)

    def Intersects(self, aChain: "SHAPE_LINE_CHAIN") -> "bool":
        r"""Intersects(SHAPE_LINE_CHAIN self, SHAPE_LINE_CHAIN aChain) -> bool"""
        return _pcbnew.SHAPE_LINE_CHAIN_Intersects(self, aChain)

    def Intersect(self, *args) -> "int":
        r"""
        Intersect(SHAPE_LINE_CHAIN self, SEG const & aSeg, SHAPE_LINE_CHAIN::INTERSECTIONS & aIp) -> int
        Intersect(SHAPE_LINE_CHAIN self, SHAPE_LINE_CHAIN aChain, SHAPE_LINE_CHAIN::INTERSECTIONS & aIp, bool aExcludeColinearAndTouching=False) -> int
        """
        return _pcbnew.SHAPE_LINE_CHAIN_Intersect(self, *args)

    def PathLength(self, aP: "VECTOR2I", aIndex: "int"=-1) -> "int":
        r"""PathLength(SHAPE_LINE_CHAIN self, VECTOR2I aP, int aIndex=-1) -> int"""
        return _pcbnew.SHAPE_LINE_CHAIN_PathLength(self, aP, aIndex)

    def CheckClearance(self, aP: "VECTOR2I", aDist: "int const") -> "bool":
        r"""CheckClearance(SHAPE_LINE_CHAIN self, VECTOR2I aP, int const aDist) -> bool"""
        return _pcbnew.SHAPE_LINE_CHAIN_CheckClearance(self, aP, aDist)

    def SelfIntersecting(self) -> "OPT< SHAPE_LINE_CHAIN::INTERSECTION > const":
        r"""SelfIntersecting(SHAPE_LINE_CHAIN self) -> OPT< SHAPE_LINE_CHAIN::INTERSECTION > const"""
        return _pcbnew.SHAPE_LINE_CHAIN_SelfIntersecting(self)

    def Simplify(self, aRemoveColinear: "bool"=True) -> "SHAPE_LINE_CHAIN &":
        r"""Simplify(SHAPE_LINE_CHAIN self, bool aRemoveColinear=True) -> SHAPE_LINE_CHAIN"""
        return _pcbnew.SHAPE_LINE_CHAIN_Simplify(self, aRemoveColinear)

    def NearestSegment(self, aP: "VECTOR2I") -> "int":
        r"""NearestSegment(SHAPE_LINE_CHAIN self, VECTOR2I aP) -> int"""
        return _pcbnew.SHAPE_LINE_CHAIN_NearestSegment(self, aP)

    def NearestPoint(self, *args) -> "VECTOR2I const":
        r"""
        NearestPoint(SHAPE_LINE_CHAIN self, VECTOR2I aP, bool aAllowInternalShapePoints=True) -> VECTOR2I
        NearestPoint(SHAPE_LINE_CHAIN self, SEG const & aSeg, int & dist) -> VECTOR2I
        """
        return _pcbnew.SHAPE_LINE_CHAIN_NearestPoint(self, *args)

    def Format(self) -> "std::string const":
        r"""Format(SHAPE_LINE_CHAIN self) -> string"""
        return _pcbnew.SHAPE_LINE_CHAIN_Format(self)

    def Parse(self, aStream: "std::stringstream &") -> "bool":
        r"""Parse(SHAPE_LINE_CHAIN self, std::stringstream & aStream) -> bool"""
        return _pcbnew.SHAPE_LINE_CHAIN_Parse(self, aStream)

    def __ne__(self, aRhs: "SHAPE_LINE_CHAIN") -> "bool":
        r"""__ne__(SHAPE_LINE_CHAIN self, SHAPE_LINE_CHAIN aRhs) -> bool"""
        return _pcbnew.SHAPE_LINE_CHAIN___ne__(self, aRhs)

    def CompareGeometry(self, aOther: "SHAPE_LINE_CHAIN") -> "bool":
        r"""CompareGeometry(SHAPE_LINE_CHAIN self, SHAPE_LINE_CHAIN aOther) -> bool"""
        return _pcbnew.SHAPE_LINE_CHAIN_CompareGeometry(self, aOther)

    def Move(self, aVector: "VECTOR2I") -> "void":
        r"""Move(SHAPE_LINE_CHAIN self, VECTOR2I aVector)"""
        return _pcbnew.SHAPE_LINE_CHAIN_Move(self, aVector)

    def Mirror(self, *args) -> "void":
        r"""
        Mirror(SHAPE_LINE_CHAIN self, bool aX=True, bool aY=False, VECTOR2I aRef={ 0, 0 })
        Mirror(SHAPE_LINE_CHAIN self, SEG const & axis)
        """
        return _pcbnew.SHAPE_LINE_CHAIN_Mirror(self, *args)

    def Rotate(self, *args) -> "void":
        r"""Rotate(SHAPE_LINE_CHAIN self, double aAngle, VECTOR2I aCenter=VECTOR2I( 0, 0 ))"""
        return _pcbnew.SHAPE_LINE_CHAIN_Rotate(self, *args)

    def IsSolid(self) -> "bool":
        r"""IsSolid(SHAPE_LINE_CHAIN self) -> bool"""
        return _pcbnew.SHAPE_LINE_CHAIN_IsSolid(self)

    def PointAlong(self, aPathLength: "int") -> "VECTOR2I const":
        r"""PointAlong(SHAPE_LINE_CHAIN self, int aPathLength) -> VECTOR2I"""
        return _pcbnew.SHAPE_LINE_CHAIN_PointAlong(self, aPathLength)

    def Area(self, aAbsolute: "bool"=True) -> "double":
        r"""Area(SHAPE_LINE_CHAIN self, bool aAbsolute=True) -> double"""
        return _pcbnew.SHAPE_LINE_CHAIN_Area(self, aAbsolute)

    def ArcCount(self) -> "size_t":
        r"""ArcCount(SHAPE_LINE_CHAIN self) -> size_t"""
        return _pcbnew.SHAPE_LINE_CHAIN_ArcCount(self)

    def ArcIndex(self, aSegment: "size_t") -> "ssize_t":
        r"""ArcIndex(SHAPE_LINE_CHAIN self, size_t aSegment) -> ssize_t"""
        return _pcbnew.SHAPE_LINE_CHAIN_ArcIndex(self, aSegment)

    def Arc(self, aArc: "size_t") -> "SHAPE_ARC const &":
        r"""Arc(SHAPE_LINE_CHAIN self, size_t aArc) -> SHAPE_ARC const &"""
        return _pcbnew.SHAPE_LINE_CHAIN_Arc(self, aArc)

    def IsSharedPt(self, aIndex: "size_t") -> "bool":
        r"""IsSharedPt(SHAPE_LINE_CHAIN self, size_t aIndex) -> bool"""
        return _pcbnew.SHAPE_LINE_CHAIN_IsSharedPt(self, aIndex)

    def IsPtOnArc(self, aPtIndex: "size_t") -> "bool":
        r"""IsPtOnArc(SHAPE_LINE_CHAIN self, size_t aPtIndex) -> bool"""
        return _pcbnew.SHAPE_LINE_CHAIN_IsPtOnArc(self, aPtIndex)

    def IsArcSegment(self, aSegment: "size_t") -> "bool":
        r"""IsArcSegment(SHAPE_LINE_CHAIN self, size_t aSegment) -> bool"""
        return _pcbnew.SHAPE_LINE_CHAIN_IsArcSegment(self, aSegment)

    def IsArcStart(self, aIndex: "size_t") -> "bool":
        r"""IsArcStart(SHAPE_LINE_CHAIN self, size_t aIndex) -> bool"""
        return _pcbnew.SHAPE_LINE_CHAIN_IsArcStart(self, aIndex)

    def IsArcEnd(self, aIndex: "size_t") -> "bool":
        r"""IsArcEnd(SHAPE_LINE_CHAIN self, size_t aIndex) -> bool"""
        return _pcbnew.SHAPE_LINE_CHAIN_IsArcEnd(self, aIndex)

    def GetPoint(self, aIndex: "int") -> "VECTOR2I const":
        r"""GetPoint(SHAPE_LINE_CHAIN self, int aIndex) -> VECTOR2I"""
        return _pcbnew.SHAPE_LINE_CHAIN_GetPoint(self, aIndex)

    def GetSegment(self, aIndex: "int") -> "SEG const":
        r"""GetSegment(SHAPE_LINE_CHAIN self, int aIndex) -> SEG const"""
        return _pcbnew.SHAPE_LINE_CHAIN_GetSegment(self, aIndex)

    def GetPointCount(self) -> "size_t":
        r"""GetPointCount(SHAPE_LINE_CHAIN self) -> size_t"""
        return _pcbnew.SHAPE_LINE_CHAIN_GetPointCount(self)

    def GetSegmentCount(self) -> "size_t":
        r"""GetSegmentCount(SHAPE_LINE_CHAIN self) -> size_t"""
        return _pcbnew.SHAPE_LINE_CHAIN_GetSegmentCount(self)

# Register SHAPE_LINE_CHAIN in _pcbnew:
_pcbnew.SHAPE_LINE_CHAIN_swigregister(SHAPE_LINE_CHAIN)

class SHAPE_POLY_SET(SHAPE):
    r"""Proxy of C++ SHAPE_POLY_SET 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__(SHAPE_POLY_SET self) -> SHAPE_POLY_SET
        __init__(SHAPE_POLY_SET self, BOX2D const & aRect) -> SHAPE_POLY_SET
        __init__(SHAPE_POLY_SET self, SHAPE_LINE_CHAIN aOutline) -> SHAPE_POLY_SET
        __init__(SHAPE_POLY_SET self, SHAPE_POLY_SET aOther) -> SHAPE_POLY_SET
        """
        _pcbnew.SHAPE_POLY_SET_swiginit(self, _pcbnew.new_SHAPE_POLY_SET(*args))
    __swig_destroy__ = _pcbnew.delete_SHAPE_POLY_SET

    def CacheTriangulation(self, aPartition: "bool"=True) -> "void":
        r"""CacheTriangulation(SHAPE_POLY_SET self, bool aPartition=True)"""
        return _pcbnew.SHAPE_POLY_SET_CacheTriangulation(self, aPartition)

    def IsTriangulationUpToDate(self) -> "bool":
        r"""IsTriangulationUpToDate(SHAPE_POLY_SET self) -> bool"""
        return _pcbnew.SHAPE_POLY_SET_IsTriangulationUpToDate(self)

    def GetHash(self) -> "MD5_HASH":
        r"""GetHash(SHAPE_POLY_SET self) -> MD5_HASH"""
        return _pcbnew.SHAPE_POLY_SET_GetHash(self)

    def HasIndexableSubshapes(self) -> "bool":
        r"""HasIndexableSubshapes(SHAPE_POLY_SET self) -> bool"""
        return _pcbnew.SHAPE_POLY_SET_HasIndexableSubshapes(self)

    def GetIndexableSubshapeCount(self) -> "size_t":
        r"""GetIndexableSubshapeCount(SHAPE_POLY_SET self) -> size_t"""
        return _pcbnew.SHAPE_POLY_SET_GetIndexableSubshapeCount(self)

    def GetIndexableSubshapes(self, aSubshapes: "std::vector< SHAPE *,std::allocator< SHAPE * > > &") -> "void":
        r"""GetIndexableSubshapes(SHAPE_POLY_SET self, std::vector< SHAPE *,std::allocator< SHAPE * > > & aSubshapes)"""
        return _pcbnew.SHAPE_POLY_SET_GetIndexableSubshapes(self, aSubshapes)

    def GetRelativeIndices(self, aGlobalIdx: "int", aRelativeIndices: "SHAPE_POLY_SET::VERTEX_INDEX *") -> "bool":
        r"""GetRelativeIndices(SHAPE_POLY_SET self, int aGlobalIdx, SHAPE_POLY_SET::VERTEX_INDEX * aRelativeIndices) -> bool"""
        return _pcbnew.SHAPE_POLY_SET_GetRelativeIndices(self, aGlobalIdx, aRelativeIndices)

    def GetGlobalIndex(self, aRelativeIndices: "SHAPE_POLY_SET::VERTEX_INDEX", aGlobalIdx: "int &") -> "bool":
        r"""GetGlobalIndex(SHAPE_POLY_SET self, SHAPE_POLY_SET::VERTEX_INDEX aRelativeIndices, int & aGlobalIdx) -> bool"""
        return _pcbnew.SHAPE_POLY_SET_GetGlobalIndex(self, aRelativeIndices, aGlobalIdx)

    def Clone(self) -> "SHAPE *":
        r"""Clone(SHAPE_POLY_SET self) -> SHAPE"""
        return _pcbnew.SHAPE_POLY_SET_Clone(self)

    def NewOutline(self) -> "int":
        r"""NewOutline(SHAPE_POLY_SET self) -> int"""
        return _pcbnew.SHAPE_POLY_SET_NewOutline(self)

    def NewHole(self, aOutline: "int"=-1) -> "int":
        r"""NewHole(SHAPE_POLY_SET self, int aOutline=-1) -> int"""
        return _pcbnew.SHAPE_POLY_SET_NewHole(self, aOutline)

    def AddOutline(self, aOutline: "SHAPE_LINE_CHAIN") -> "int":
        r"""AddOutline(SHAPE_POLY_SET self, SHAPE_LINE_CHAIN aOutline) -> int"""
        return _pcbnew.SHAPE_POLY_SET_AddOutline(self, aOutline)

    def AddHole(self, aHole: "SHAPE_LINE_CHAIN", aOutline: "int"=-1) -> "int":
        r"""AddHole(SHAPE_POLY_SET self, SHAPE_LINE_CHAIN aHole, int aOutline=-1) -> int"""
        return _pcbnew.SHAPE_POLY_SET_AddHole(self, aHole, aOutline)

    def Area(self) -> "double":
        r"""Area(SHAPE_POLY_SET self) -> double"""
        return _pcbnew.SHAPE_POLY_SET_Area(self)

    def ArcCount(self) -> "int":
        r"""ArcCount(SHAPE_POLY_SET self) -> int"""
        return _pcbnew.SHAPE_POLY_SET_ArcCount(self)

    def GetArcs(self, aArcBuffer: "std::vector< SHAPE_ARC,std::allocator< SHAPE_ARC > > &") -> "void":
        r"""GetArcs(SHAPE_POLY_SET self, std::vector< SHAPE_ARC,std::allocator< SHAPE_ARC > > & aArcBuffer)"""
        return _pcbnew.SHAPE_POLY_SET_GetArcs(self, aArcBuffer)

    def ClearArcs(self) -> "void":
        r"""ClearArcs(SHAPE_POLY_SET self)"""
        return _pcbnew.SHAPE_POLY_SET_ClearArcs(self)

    def Append(self, *args) -> "int":
        r"""
        Append(SHAPE_POLY_SET self, int x, int y, int aOutline=-1, int aHole=-1, bool aAllowDuplication=False) -> int
        Append(SHAPE_POLY_SET self, SHAPE_POLY_SET aSet)
        Append(SHAPE_POLY_SET self, VECTOR2I aP, int aOutline=-1, int aHole=-1)
        Append(SHAPE_POLY_SET self, SHAPE_ARC & aArc, int aOutline=-1, int aHole=-1) -> int
        """
        return _pcbnew.SHAPE_POLY_SET_Append(self, *args)

    def InsertVertex(self, aGlobalIndex: "int", aNewVertex: "VECTOR2I") -> "void":
        r"""InsertVertex(SHAPE_POLY_SET self, int aGlobalIndex, VECTOR2I aNewVertex)"""
        return _pcbnew.SHAPE_POLY_SET_InsertVertex(self, aGlobalIndex, aNewVertex)

    def CVertex(self, *args) -> "VECTOR2I const &":
        r"""
        CVertex(SHAPE_POLY_SET self, int aIndex, int aOutline, int aHole) -> VECTOR2I
        CVertex(SHAPE_POLY_SET self, int aGlobalIndex) -> VECTOR2I
        CVertex(SHAPE_POLY_SET self, SHAPE_POLY_SET::VERTEX_INDEX aIndex) -> VECTOR2I
        """
        return _pcbnew.SHAPE_POLY_SET_CVertex(self, *args)

    def GetNeighbourIndexes(self, aGlobalIndex: "int", aPrevious: "int *", aNext: "int *") -> "bool":
        r"""GetNeighbourIndexes(SHAPE_POLY_SET self, int aGlobalIndex, int * aPrevious, int * aNext) -> bool"""
        return _pcbnew.SHAPE_POLY_SET_GetNeighbourIndexes(self, aGlobalIndex, aPrevious, aNext)

    def IsPolygonSelfIntersecting(self, aPolygonIndex: "int") -> "bool":
        r"""IsPolygonSelfIntersecting(SHAPE_POLY_SET self, int aPolygonIndex) -> bool"""
        return _pcbnew.SHAPE_POLY_SET_IsPolygonSelfIntersecting(self, aPolygonIndex)

    def IsSelfIntersecting(self) -> "bool":
        r"""IsSelfIntersecting(SHAPE_POLY_SET self) -> bool"""
        return _pcbnew.SHAPE_POLY_SET_IsSelfIntersecting(self)

    def TriangulatedPolyCount(self) -> "unsigned int":
        r"""TriangulatedPolyCount(SHAPE_POLY_SET self) -> unsigned int"""
        return _pcbnew.SHAPE_POLY_SET_TriangulatedPolyCount(self)

    def OutlineCount(self) -> "int":
        r"""OutlineCount(SHAPE_POLY_SET self) -> int"""
        return _pcbnew.SHAPE_POLY_SET_OutlineCount(self)

    def VertexCount(self, aOutline: "int"=-1, aHole: "int"=-1) -> "int":
        r"""VertexCount(SHAPE_POLY_SET self, int aOutline=-1, int aHole=-1) -> int"""
        return _pcbnew.SHAPE_POLY_SET_VertexCount(self, aOutline, aHole)

    def FullPointCount(self) -> "int":
        r"""FullPointCount(SHAPE_POLY_SET self) -> int"""
        return _pcbnew.SHAPE_POLY_SET_FullPointCount(self)

    def HoleCount(self, aOutline: "int") -> "int":
        r"""HoleCount(SHAPE_POLY_SET self, int aOutline) -> int"""
        return _pcbnew.SHAPE_POLY_SET_HoleCount(self, aOutline)

    def Outline(self, *args) -> "SHAPE_LINE_CHAIN const &":
        r"""
        Outline(SHAPE_POLY_SET self, int aIndex) -> SHAPE_LINE_CHAIN
        Outline(SHAPE_POLY_SET self, int aIndex) -> SHAPE_LINE_CHAIN
        """
        return _pcbnew.SHAPE_POLY_SET_Outline(self, *args)

    def Subset(self, aFirstPolygon: "int", aLastPolygon: "int") -> "SHAPE_POLY_SET":
        r"""Subset(SHAPE_POLY_SET self, int aFirstPolygon, int aLastPolygon) -> SHAPE_POLY_SET"""
        return _pcbnew.SHAPE_POLY_SET_Subset(self, aFirstPolygon, aLastPolygon)

    def UnitSet(self, aPolygonIndex: "int") -> "SHAPE_POLY_SET":
        r"""UnitSet(SHAPE_POLY_SET self, int aPolygonIndex) -> SHAPE_POLY_SET"""
        return _pcbnew.SHAPE_POLY_SET_UnitSet(self, aPolygonIndex)

    def Hole(self, aOutline: "int", aHole: "int") -> "SHAPE_LINE_CHAIN &":
        r"""Hole(SHAPE_POLY_SET self, int aOutline, int aHole) -> SHAPE_LINE_CHAIN"""
        return _pcbnew.SHAPE_POLY_SET_Hole(self, aOutline, aHole)

    def Polygon(self, *args) -> "SHAPE_POLY_SET::POLYGON const &":
        r"""
        Polygon(SHAPE_POLY_SET self, int aIndex) -> SHAPE_POLY_SET::POLYGON
        Polygon(SHAPE_POLY_SET self, int aIndex) -> SHAPE_POLY_SET::POLYGON const &
        """
        return _pcbnew.SHAPE_POLY_SET_Polygon(self, *args)

    def TriangulatedPolygon(self, aIndex: "int") -> "SHAPE_POLY_SET::TRIANGULATED_POLYGON const *":
        r"""TriangulatedPolygon(SHAPE_POLY_SET self, int aIndex) -> SHAPE_POLY_SET::TRIANGULATED_POLYGON const *"""
        return _pcbnew.SHAPE_POLY_SET_TriangulatedPolygon(self, aIndex)

    def COutline(self, aIndex: "int") -> "SHAPE_LINE_CHAIN const &":
        r"""COutline(SHAPE_POLY_SET self, int aIndex) -> SHAPE_LINE_CHAIN"""
        return _pcbnew.SHAPE_POLY_SET_COutline(self, aIndex)

    def CHole(self, aOutline: "int", aHole: "int") -> "SHAPE_LINE_CHAIN const &":
        r"""CHole(SHAPE_POLY_SET self, int aOutline, int aHole) -> SHAPE_LINE_CHAIN"""
        return _pcbnew.SHAPE_POLY_SET_CHole(self, aOutline, aHole)

    def CPolygon(self, aIndex: "int") -> "SHAPE_POLY_SET::POLYGON const &":
        r"""CPolygon(SHAPE_POLY_SET self, int aIndex) -> SHAPE_POLY_SET::POLYGON const &"""
        return _pcbnew.SHAPE_POLY_SET_CPolygon(self, aIndex)

    def Iterate(self, *args) -> "SHAPE_POLY_SET::ITERATOR":
        r"""
        Iterate(SHAPE_POLY_SET self, int aFirst, int aLast, bool aIterateHoles=False) -> SHAPE_POLY_SET::ITERATOR
        Iterate(SHAPE_POLY_SET self, int aOutline) -> SHAPE_POLY_SET::ITERATOR
        Iterate(SHAPE_POLY_SET self) -> SHAPE_POLY_SET::ITERATOR
        """
        return _pcbnew.SHAPE_POLY_SET_Iterate(self, *args)

    def IterateWithHoles(self, *args) -> "SHAPE_POLY_SET::ITERATOR":
        r"""
        IterateWithHoles(SHAPE_POLY_SET self, int aOutline) -> SHAPE_POLY_SET::ITERATOR
        IterateWithHoles(SHAPE_POLY_SET self) -> SHAPE_POLY_SET::ITERATOR
        """
        return _pcbnew.SHAPE_POLY_SET_IterateWithHoles(self, *args)

    def CIterate(self, *args) -> "SHAPE_POLY_SET::CONST_ITERATOR":
        r"""
        CIterate(SHAPE_POLY_SET self, int aFirst, int aLast, bool aIterateHoles=False) -> SHAPE_POLY_SET::CONST_ITERATOR
        CIterate(SHAPE_POLY_SET self, int aOutline) -> SHAPE_POLY_SET::CONST_ITERATOR
        CIterate(SHAPE_POLY_SET self) -> SHAPE_POLY_SET::CONST_ITERATOR
        """
        return _pcbnew.SHAPE_POLY_SET_CIterate(self, *args)

    def CIterateWithHoles(self, *args) -> "SHAPE_POLY_SET::CONST_ITERATOR":
        r"""
        CIterateWithHoles(SHAPE_POLY_SET self, int aOutline) -> SHAPE_POLY_SET::CONST_ITERATOR
        CIterateWithHoles(SHAPE_POLY_SET self) -> SHAPE_POLY_SET::CONST_ITERATOR
        """
        return _pcbnew.SHAPE_POLY_SET_CIterateWithHoles(self, *args)

    def IterateFromVertexWithHoles(self, aGlobalIdx: "int") -> "SHAPE_POLY_SET::ITERATOR":
        r"""IterateFromVertexWithHoles(SHAPE_POLY_SET self, int aGlobalIdx) -> SHAPE_POLY_SET::ITERATOR"""
        return _pcbnew.SHAPE_POLY_SET_IterateFromVertexWithHoles(self, aGlobalIdx)

    def IterateSegments(self, *args) -> "SHAPE_POLY_SET::SEGMENT_ITERATOR":
        r"""
        IterateSegments(SHAPE_POLY_SET self, int aFirst, int aLast, bool aIterateHoles=False) -> SHAPE_POLY_SET::SEGMENT_ITERATOR
        IterateSegments(SHAPE_POLY_SET self, int aPolygonIdx) -> SHAPE_POLY_SET::SEGMENT_ITERATOR
        IterateSegments(SHAPE_POLY_SET self) -> SHAPE_POLY_SET::SEGMENT_ITERATOR
        """
        return _pcbnew.SHAPE_POLY_SET_IterateSegments(self, *args)

    def CIterateSegments(self, *args) -> "SHAPE_POLY_SET::CONST_SEGMENT_ITERATOR":
        r"""
        CIterateSegments(SHAPE_POLY_SET self, int aFirst, int aLast, bool aIterateHoles=False) -> SHAPE_POLY_SET::CONST_SEGMENT_ITERATOR
        CIterateSegments(SHAPE_POLY_SET self, int aPolygonIdx) -> SHAPE_POLY_SET::CONST_SEGMENT_ITERATOR
        CIterateSegments(SHAPE_POLY_SET self) -> SHAPE_POLY_SET::CONST_SEGMENT_ITERATOR
        """
        return _pcbnew.SHAPE_POLY_SET_CIterateSegments(self, *args)

    def IterateSegmentsWithHoles(self, *args) -> "SHAPE_POLY_SET::SEGMENT_ITERATOR":
        r"""
        IterateSegmentsWithHoles(SHAPE_POLY_SET self) -> SHAPE_POLY_SET::SEGMENT_ITERATOR
        IterateSegmentsWithHoles(SHAPE_POLY_SET self, int aOutline) -> SHAPE_POLY_SET::SEGMENT_ITERATOR
        """
        return _pcbnew.SHAPE_POLY_SET_IterateSegmentsWithHoles(self, *args)

    def CIterateSegmentsWithHoles(self, *args) -> "SHAPE_POLY_SET::CONST_SEGMENT_ITERATOR":
        r"""
        CIterateSegmentsWithHoles(SHAPE_POLY_SET self) -> SHAPE_POLY_SET::CONST_SEGMENT_ITERATOR
        CIterateSegmentsWithHoles(SHAPE_POLY_SET self, int aOutline) -> SHAPE_POLY_SET::CONST_SEGMENT_ITERATOR
        """
        return _pcbnew.SHAPE_POLY_SET_CIterateSegmentsWithHoles(self, *args)
    PM_FAST = _pcbnew.SHAPE_POLY_SET_PM_FAST
    
    PM_STRICTLY_SIMPLE = _pcbnew.SHAPE_POLY_SET_PM_STRICTLY_SIMPLE
    

    def BooleanAdd(self, *args) -> "void":
        r"""
        BooleanAdd(SHAPE_POLY_SET self, SHAPE_POLY_SET b, SHAPE_POLY_SET::POLYGON_MODE aFastMode)
        BooleanAdd(SHAPE_POLY_SET self, SHAPE_POLY_SET a, SHAPE_POLY_SET b, SHAPE_POLY_SET::POLYGON_MODE aFastMode)
        """
        return _pcbnew.SHAPE_POLY_SET_BooleanAdd(self, *args)

    def BooleanSubtract(self, *args) -> "void":
        r"""
        BooleanSubtract(SHAPE_POLY_SET self, SHAPE_POLY_SET b, SHAPE_POLY_SET::POLYGON_MODE aFastMode)
        BooleanSubtract(SHAPE_POLY_SET self, SHAPE_POLY_SET a, SHAPE_POLY_SET b, SHAPE_POLY_SET::POLYGON_MODE aFastMode)
        """
        return _pcbnew.SHAPE_POLY_SET_BooleanSubtract(self, *args)

    def BooleanIntersection(self, *args) -> "void":
        r"""
        BooleanIntersection(SHAPE_POLY_SET self, SHAPE_POLY_SET b, SHAPE_POLY_SET::POLYGON_MODE aFastMode)
        BooleanIntersection(SHAPE_POLY_SET self, SHAPE_POLY_SET a, SHAPE_POLY_SET b, SHAPE_POLY_SET::POLYGON_MODE aFastMode)
        """
        return _pcbnew.SHAPE_POLY_SET_BooleanIntersection(self, *args)
    ALLOW_ACUTE_CORNERS = _pcbnew.SHAPE_POLY_SET_ALLOW_ACUTE_CORNERS
    
    CHAMFER_ACUTE_CORNERS = _pcbnew.SHAPE_POLY_SET_CHAMFER_ACUTE_CORNERS
    
    ROUND_ACUTE_CORNERS = _pcbnew.SHAPE_POLY_SET_ROUND_ACUTE_CORNERS
    
    CHAMFER_ALL_CORNERS = _pcbnew.SHAPE_POLY_SET_CHAMFER_ALL_CORNERS
    
    ROUND_ALL_CORNERS = _pcbnew.SHAPE_POLY_SET_ROUND_ALL_CORNERS
    

    def Inflate(self, *args) -> "void":
        r"""Inflate(SHAPE_POLY_SET self, int aAmount, int aCircleSegCount, SHAPE_POLY_SET::CORNER_STRATEGY aCornerStrategy=ROUND_ALL_CORNERS)"""
        return _pcbnew.SHAPE_POLY_SET_Inflate(self, *args)

    def Deflate(self, *args) -> "void":
        r"""Deflate(SHAPE_POLY_SET self, int aAmount, int aCircleSegmentsCount, SHAPE_POLY_SET::CORNER_STRATEGY aCornerStrategy=ROUND_ALL_CORNERS)"""
        return _pcbnew.SHAPE_POLY_SET_Deflate(self, *args)

    def InflateWithLinkedHoles(self, aFactor: "int", aCircleSegmentsCount: "int", aFastMode: "SHAPE_POLY_SET::POLYGON_MODE") -> "void":
        r"""InflateWithLinkedHoles(SHAPE_POLY_SET self, int aFactor, int aCircleSegmentsCount, SHAPE_POLY_SET::POLYGON_MODE aFastMode)"""
        return _pcbnew.SHAPE_POLY_SET_InflateWithLinkedHoles(self, aFactor, aCircleSegmentsCount, aFastMode)

    def Fracture(self, aFastMode: "SHAPE_POLY_SET::POLYGON_MODE") -> "void":
        r"""Fracture(SHAPE_POLY_SET self, SHAPE_POLY_SET::POLYGON_MODE aFastMode)"""
        return _pcbnew.SHAPE_POLY_SET_Fracture(self, aFastMode)

    def Unfracture(self, aFastMode: "SHAPE_POLY_SET::POLYGON_MODE") -> "void":
        r"""Unfracture(SHAPE_POLY_SET self, SHAPE_POLY_SET::POLYGON_MODE aFastMode)"""
        return _pcbnew.SHAPE_POLY_SET_Unfracture(self, aFastMode)

    def HasHoles(self) -> "bool":
        r"""HasHoles(SHAPE_POLY_SET self) -> bool"""
        return _pcbnew.SHAPE_POLY_SET_HasHoles(self)

    def HasTouchingHoles(self) -> "bool":
        r"""HasTouchingHoles(SHAPE_POLY_SET self) -> bool"""
        return _pcbnew.SHAPE_POLY_SET_HasTouchingHoles(self)

    def Simplify(self, aFastMode: "SHAPE_POLY_SET::POLYGON_MODE") -> "void":
        r"""Simplify(SHAPE_POLY_SET self, SHAPE_POLY_SET::POLYGON_MODE aFastMode)"""
        return _pcbnew.SHAPE_POLY_SET_Simplify(self, aFastMode)

    def NormalizeAreaOutlines(self) -> "int":
        r"""NormalizeAreaOutlines(SHAPE_POLY_SET self) -> int"""
        return _pcbnew.SHAPE_POLY_SET_NormalizeAreaOutlines(self)

    def Format(self) -> "std::string const":
        r"""Format(SHAPE_POLY_SET self) -> string"""
        return _pcbnew.SHAPE_POLY_SET_Format(self)

    def Parse(self, aStream: "std::stringstream &") -> "bool":
        r"""Parse(SHAPE_POLY_SET self, std::stringstream & aStream) -> bool"""
        return _pcbnew.SHAPE_POLY_SET_Parse(self, aStream)

    def Move(self, aVector: "VECTOR2I") -> "void":
        r"""Move(SHAPE_POLY_SET self, VECTOR2I aVector)"""
        return _pcbnew.SHAPE_POLY_SET_Move(self, aVector)

    def Mirror(self, *args) -> "void":
        r"""Mirror(SHAPE_POLY_SET self, bool aX=True, bool aY=False, VECTOR2I aRef={ 0, 0 })"""
        return _pcbnew.SHAPE_POLY_SET_Mirror(self, *args)

    def Rotate(self, *args) -> "void":
        r"""Rotate(SHAPE_POLY_SET self, double aAngle, VECTOR2I aCenter={ 0, 0 })"""
        return _pcbnew.SHAPE_POLY_SET_Rotate(self, *args)

    def IsSolid(self) -> "bool":
        r"""IsSolid(SHAPE_POLY_SET self) -> bool"""
        return _pcbnew.SHAPE_POLY_SET_IsSolid(self)

    def BBox(self, aClearance: "int"=0) -> "BOX2I const":
        r"""BBox(SHAPE_POLY_SET self, int aClearance=0) -> BOX2I const"""
        return _pcbnew.SHAPE_POLY_SET_BBox(self, aClearance)

    def PointOnEdge(self, aP: "VECTOR2I") -> "bool":
        r"""PointOnEdge(SHAPE_POLY_SET self, VECTOR2I aP) -> bool"""
        return _pcbnew.SHAPE_POLY_SET_PointOnEdge(self, aP)

    def Collide(self, *args) -> "bool":
        r"""
        Collide(SHAPE_POLY_SET self, SHAPE aShape, int aClearance=0, int * aActual=None, VECTOR2I aLocation=None) -> bool
        Collide(SHAPE_POLY_SET self, VECTOR2I aP, int aClearance=0, int * aActual=None, VECTOR2I aLocation=None) -> bool
        Collide(SHAPE_POLY_SET self, SEG const & aSeg, int aClearance=0, int * aActual=None, VECTOR2I aLocation=None) -> bool
        """
        return _pcbnew.SHAPE_POLY_SET_Collide(self, *args)

    def CollideVertex(self, aPoint: "VECTOR2I", aClosestVertex: "SHAPE_POLY_SET::VERTEX_INDEX &", aClearance: "int"=0) -> "bool":
        r"""CollideVertex(SHAPE_POLY_SET self, VECTOR2I aPoint, SHAPE_POLY_SET::VERTEX_INDEX & aClosestVertex, int aClearance=0) -> bool"""
        return _pcbnew.SHAPE_POLY_SET_CollideVertex(self, aPoint, aClosestVertex, aClearance)

    def CollideEdge(self, aPoint: "VECTOR2I", aClosestVertex: "SHAPE_POLY_SET::VERTEX_INDEX &", aClearance: "int"=0) -> "bool":
        r"""CollideEdge(SHAPE_POLY_SET self, VECTOR2I aPoint, SHAPE_POLY_SET::VERTEX_INDEX & aClosestVertex, int aClearance=0) -> bool"""
        return _pcbnew.SHAPE_POLY_SET_CollideEdge(self, aPoint, aClosestVertex, aClearance)

    def BuildBBoxCaches(self) -> "void":
        r"""BuildBBoxCaches(SHAPE_POLY_SET self)"""
        return _pcbnew.SHAPE_POLY_SET_BuildBBoxCaches(self)

    def BBoxFromCaches(self) -> "BOX2I const":
        r"""BBoxFromCaches(SHAPE_POLY_SET self) -> BOX2I const"""
        return _pcbnew.SHAPE_POLY_SET_BBoxFromCaches(self)

    def Contains(self, aP: "VECTOR2I", aSubpolyIndex: "int"=-1, aAccuracy: "int"=0, aUseBBoxCaches: "bool"=False) -> "bool":
        r"""Contains(SHAPE_POLY_SET self, VECTOR2I aP, int aSubpolyIndex=-1, int aAccuracy=0, bool aUseBBoxCaches=False) -> bool"""
        return _pcbnew.SHAPE_POLY_SET_Contains(self, aP, aSubpolyIndex, aAccuracy, aUseBBoxCaches)

    def IsEmpty(self) -> "bool":
        r"""IsEmpty(SHAPE_POLY_SET self) -> bool"""
        return _pcbnew.SHAPE_POLY_SET_IsEmpty(self)

    def RemoveVertex(self, *args) -> "void":
        r"""
        RemoveVertex(SHAPE_POLY_SET self, int aGlobalIndex)
        RemoveVertex(SHAPE_POLY_SET self, SHAPE_POLY_SET::VERTEX_INDEX aRelativeIndices)
        """
        return _pcbnew.SHAPE_POLY_SET_RemoveVertex(self, *args)

    def RemoveAllContours(self) -> "void":
        r"""RemoveAllContours(SHAPE_POLY_SET self)"""
        return _pcbnew.SHAPE_POLY_SET_RemoveAllContours(self)

    def RemoveContour(self, aContourIdx: "int", aPolygonIdx: "int"=-1) -> "void":
        r"""RemoveContour(SHAPE_POLY_SET self, int aContourIdx, int aPolygonIdx=-1)"""
        return _pcbnew.SHAPE_POLY_SET_RemoveContour(self, aContourIdx, aPolygonIdx)

    def RemoveNullSegments(self) -> "int":
        r"""RemoveNullSegments(SHAPE_POLY_SET self) -> int"""
        return _pcbnew.SHAPE_POLY_SET_RemoveNullSegments(self)

    def SetVertex(self, *args) -> "void":
        r"""
        SetVertex(SHAPE_POLY_SET self, SHAPE_POLY_SET::VERTEX_INDEX const & aIndex, VECTOR2I aPos)
        SetVertex(SHAPE_POLY_SET self, int aGlobalIndex, VECTOR2I aPos)
        """
        return _pcbnew.SHAPE_POLY_SET_SetVertex(self, *args)

    def TotalVertices(self) -> "int":
        r"""TotalVertices(SHAPE_POLY_SET self) -> int"""
        return _pcbnew.SHAPE_POLY_SET_TotalVertices(self)

    def DeletePolygon(self, aIdx: "int") -> "void":
        r"""DeletePolygon(SHAPE_POLY_SET self, int aIdx)"""
        return _pcbnew.SHAPE_POLY_SET_DeletePolygon(self, aIdx)

    def ChamferPolygon(self, aDistance: "unsigned int", aIndex: "int") -> "SHAPE_POLY_SET::POLYGON":
        r"""ChamferPolygon(SHAPE_POLY_SET self, unsigned int aDistance, int aIndex) -> SHAPE_POLY_SET::POLYGON"""
        return _pcbnew.SHAPE_POLY_SET_ChamferPolygon(self, aDistance, aIndex)

    def FilletPolygon(self, aRadius: "unsigned int", aErrorMax: "int", aIndex: "int") -> "SHAPE_POLY_SET::POLYGON":
        r"""FilletPolygon(SHAPE_POLY_SET self, unsigned int aRadius, int aErrorMax, int aIndex) -> SHAPE_POLY_SET::POLYGON"""
        return _pcbnew.SHAPE_POLY_SET_FilletPolygon(self, aRadius, aErrorMax, aIndex)

    def Chamfer(self, aDistance: "int") -> "SHAPE_POLY_SET":
        r"""Chamfer(SHAPE_POLY_SET self, int aDistance) -> SHAPE_POLY_SET"""
        return _pcbnew.SHAPE_POLY_SET_Chamfer(self, aDistance)

    def Fillet(self, aRadius: "int", aErrorMax: "int") -> "SHAPE_POLY_SET":
        r"""Fillet(SHAPE_POLY_SET self, int aRadius, int aErrorMax) -> SHAPE_POLY_SET"""
        return _pcbnew.SHAPE_POLY_SET_Fillet(self, aRadius, aErrorMax)

    def SquaredDistanceToPolygon(self, *args) -> "SEG::ecoord":
        r"""
        SquaredDistanceToPolygon(SHAPE_POLY_SET self, VECTOR2I aPoint, int aIndex, VECTOR2I aNearest) -> SEG::ecoord
        SquaredDistanceToPolygon(SHAPE_POLY_SET self, SEG const & aSegment, int aIndex, VECTOR2I aNearest) -> SEG::ecoord
        """
        return _pcbnew.SHAPE_POLY_SET_SquaredDistanceToPolygon(self, *args)

    def SquaredDistance(self, *args) -> "SEG::ecoord":
        r"""
        SquaredDistance(SHAPE_POLY_SET self, VECTOR2I aPoint, VECTOR2I aNearest=None) -> SEG::ecoord
        SquaredDistance(SHAPE_POLY_SET self, SEG const & aSegment, VECTOR2I aNearest=None) -> SEG::ecoord
        """
        return _pcbnew.SHAPE_POLY_SET_SquaredDistance(self, *args)

    def IsVertexInHole(self, aGlobalIdx: "int") -> "bool":
        r"""IsVertexInHole(SHAPE_POLY_SET self, int aGlobalIdx) -> bool"""
        return _pcbnew.SHAPE_POLY_SET_IsVertexInHole(self, aGlobalIdx)

    @staticmethod
    def BuildPolysetFromOrientedPaths(aPaths: "std::vector< SHAPE_LINE_CHAIN,std::allocator< SHAPE_LINE_CHAIN > > const &", aReverseOrientation: "bool"=False, aEvenOdd: "bool"=False) -> "SHAPE_POLY_SET const":
        r"""BuildPolysetFromOrientedPaths(std::vector< SHAPE_LINE_CHAIN,std::allocator< SHAPE_LINE_CHAIN > > const & aPaths, bool aReverseOrientation=False, bool aEvenOdd=False) -> SHAPE_POLY_SET"""
        return _pcbnew.SHAPE_POLY_SET_BuildPolysetFromOrientedPaths(aPaths, aReverseOrientation, aEvenOdd)

# Register SHAPE_POLY_SET in _pcbnew:
_pcbnew.SHAPE_POLY_SET_swigregister(SHAPE_POLY_SET)

def SHAPE_POLY_SET_BuildPolysetFromOrientedPaths(aPaths: "std::vector< SHAPE_LINE_CHAIN,std::allocator< SHAPE_LINE_CHAIN > > const &", aReverseOrientation: "bool"=False, aEvenOdd: "bool"=False) -> "SHAPE_POLY_SET const":
    r"""SHAPE_POLY_SET_BuildPolysetFromOrientedPaths(std::vector< SHAPE_LINE_CHAIN,std::allocator< SHAPE_LINE_CHAIN > > const & aPaths, bool aReverseOrientation=False, bool aEvenOdd=False) -> SHAPE_POLY_SET"""
    return _pcbnew.SHAPE_POLY_SET_BuildPolysetFromOrientedPaths(aPaths, aReverseOrientation, aEvenOdd)


def IsUTF8(aString: "char const *") -> "bool":
    r"""IsUTF8(char const * aString) -> bool"""
    return _pcbnew.IsUTF8(aString)
class UTF8(object):
    r"""Proxy of C++ UTF8 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__(UTF8 self, wxString o) -> UTF8
        __init__(UTF8 self, char const * txt) -> UTF8
        __init__(UTF8 self, wchar_t const * txt) -> UTF8
        __init__(UTF8 self, string o) -> UTF8
        __init__(UTF8 self) -> UTF8
        """
        _pcbnew.UTF8_swiginit(self, _pcbnew.new_UTF8(*args))
    __swig_destroy__ = _pcbnew.delete_UTF8

    def c_str(self) -> "char const *":
        r"""c_str(UTF8 self) -> char const *"""
        return _pcbnew.UTF8_c_str(self)

    def empty(self) -> "bool":
        r"""empty(UTF8 self) -> bool"""
        return _pcbnew.UTF8_empty(self)

    def find(self, *args) -> "std::string::size_type":
        r"""
        find(UTF8 self, char c) -> std::string::size_type
        find(UTF8 self, char c, size_t s) -> std::string::size_type
        """
        return _pcbnew.UTF8_find(self, *args)

    def clear(self) -> "void":
        r"""clear(UTF8 self)"""
        return _pcbnew.UTF8_clear(self)

    def length(self) -> "std::string::size_type":
        r"""length(UTF8 self) -> std::string::size_type"""
        return _pcbnew.UTF8_length(self)

    def size(self) -> "std::string::size_type":
        r"""size(UTF8 self) -> std::string::size_type"""
        return _pcbnew.UTF8_size(self)

    def compare(self, s: "string") -> "int":
        r"""compare(UTF8 self, string s) -> int"""
        return _pcbnew.UTF8_compare(self, s)

    def __eq__(self, *args) -> "bool":
        r"""
        __eq__(UTF8 self, UTF8 rhs) -> bool
        __eq__(UTF8 self, string rhs) -> bool
        __eq__(UTF8 self, char const * s) -> bool
        """
        return _pcbnew.UTF8___eq__(self, *args)

    def find_first_of(self, str: "string", pos: "std::string::size_type"=0) -> "std::string::size_type":
        r"""find_first_of(UTF8 self, string str, std::string::size_type pos=0) -> std::string::size_type"""
        return _pcbnew.UTF8_find_first_of(self, str, pos)

    def __iadd__(self, *args) -> "UTF8 &":
        r"""
        __iadd__(UTF8 self, UTF8 str) -> UTF8
        __iadd__(UTF8 self, char ch) -> UTF8
        __iadd__(UTF8 self, char const * s) -> UTF8
        __iadd__(UTF8 self, unsigned int w_ch) -> UTF8
        """
        return _pcbnew.UTF8___iadd__(self, *args)
    npos = _pcbnew.UTF8_npos
    

    def substr(self, *args) -> "std::string":
        r"""substr(UTF8 self, size_t pos=0, size_t len=npos) -> string"""
        return _pcbnew.UTF8_substr(self, *args)

    def utf8_to_string(self) -> "std::string const &":
        r"""utf8_to_string(UTF8 self) -> string"""
        return _pcbnew.UTF8_utf8_to_string(self)

    def wx_str(self) -> "wxString":
        r"""wx_str(UTF8 self) -> wxString"""
        return _pcbnew.UTF8_wx_str(self)

    def utf8_to_wxstring(self) -> "wxString":
        r"""utf8_to_wxstring(UTF8 self) -> wxString"""
        return _pcbnew.UTF8_utf8_to_wxstring(self)

    def begin(self) -> "std::string::const_iterator":
        r"""begin(UTF8 self) -> std::string::const_iterator"""
        return _pcbnew.UTF8_begin(self)

    def end(self) -> "std::string::const_iterator":
        r"""end(UTF8 self) -> std::string::const_iterator"""
        return _pcbnew.UTF8_end(self)

    def Cast_to_CChar(self) -> "char const *":
        r"""Cast_to_CChar(UTF8 self) -> char const *"""
        return _pcbnew.UTF8_Cast_to_CChar(self)


        # Get the char buffer of the UTF8 string
    def GetChars(self):
        return self.Cast_to_CChar()

    # Convert the UTF8 string to a python string
    # Same as GetChars(), but more easy to use in print command
    def __str__(self):
        return self.GetChars()



# Register UTF8 in _pcbnew:
_pcbnew.UTF8_swigregister(UTF8)


def Mils2iu(mils: "int") -> "int":
    r"""Mils2iu(int mils) -> int"""
    return _pcbnew.Mils2iu(mils)

def Iu2Mils(iu: "int") -> "double":
    r"""Iu2Mils(int iu) -> double"""
    return _pcbnew.Iu2Mils(iu)

def Millimeter2iu(mm: "double") -> "int":
    r"""Millimeter2iu(double mm) -> int"""
    return _pcbnew.Millimeter2iu(mm)

def Iu2Millimeter(iu: "int") -> "double":
    r"""Iu2Millimeter(int iu) -> double"""
    return _pcbnew.Iu2Millimeter(iu)
class LIB_ID(object):
    r"""Proxy of C++ LIB_ID 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__(LIB_ID self) -> LIB_ID
        __init__(LIB_ID self, wxString aLibraryName, wxString aItemName) -> LIB_ID
        """
        _pcbnew.LIB_ID_swiginit(self, _pcbnew.new_LIB_ID(*args))

    def Parse(self, aId: "UTF8", aFix: "bool"=False) -> "int":
        r"""Parse(LIB_ID self, UTF8 aId, bool aFix=False) -> int"""
        return _pcbnew.LIB_ID_Parse(self, aId, aFix)

    def GetLibNickname(self) -> "UTF8 const &":
        r"""GetLibNickname(LIB_ID self) -> UTF8"""
        return _pcbnew.LIB_ID_GetLibNickname(self)

    def SetLibNickname(self, aNickname: "UTF8") -> "int":
        r"""SetLibNickname(LIB_ID self, UTF8 aNickname) -> int"""
        return _pcbnew.LIB_ID_SetLibNickname(self, aNickname)

    def GetLibItemName(self) -> "UTF8 const &":
        r"""GetLibItemName(LIB_ID self) -> UTF8"""
        return _pcbnew.LIB_ID_GetLibItemName(self)

    def GetUniStringLibItemName(self) -> "wxString const":
        r"""GetUniStringLibItemName(LIB_ID self) -> wxString"""
        return _pcbnew.LIB_ID_GetUniStringLibItemName(self)

    def SetLibItemName(self, aLibItemName: "UTF8") -> "int":
        r"""SetLibItemName(LIB_ID self, UTF8 aLibItemName) -> int"""
        return _pcbnew.LIB_ID_SetLibItemName(self, aLibItemName)

    def GetUniStringLibId(self) -> "wxString":
        r"""GetUniStringLibId(LIB_ID self) -> wxString"""
        return _pcbnew.LIB_ID_GetUniStringLibId(self)

    @staticmethod
    def Format(*args) -> "UTF8":
        r"""
        Format() -> UTF8
        Format(UTF8 aLibraryName, UTF8 aLibItemName) -> UTF8
        """
        return _pcbnew.LIB_ID_Format(*args)

    def IsValid(self) -> "bool":
        r"""IsValid(LIB_ID self) -> bool"""
        return _pcbnew.LIB_ID_IsValid(self)

    def IsLegacy(self) -> "bool":
        r"""IsLegacy(LIB_ID self) -> bool"""
        return _pcbnew.LIB_ID_IsLegacy(self)

    def clear(self) -> "void":
        r"""clear(LIB_ID self)"""
        return _pcbnew.LIB_ID_clear(self)

    def empty(self) -> "bool":
        r"""empty(LIB_ID self) -> bool"""
        return _pcbnew.LIB_ID_empty(self)

    def compare(self, aLibId: "LIB_ID") -> "int":
        r"""compare(LIB_ID self, LIB_ID aLibId) -> int"""
        return _pcbnew.LIB_ID_compare(self, aLibId)

    def __lt__(self, aLibId: "LIB_ID") -> "bool":
        r"""__lt__(LIB_ID self, LIB_ID aLibId) -> bool"""
        return _pcbnew.LIB_ID___lt__(self, aLibId)

    def __gt__(self, aLibId: "LIB_ID") -> "bool":
        r"""__gt__(LIB_ID self, LIB_ID aLibId) -> bool"""
        return _pcbnew.LIB_ID___gt__(self, aLibId)

    def __eq__(self, aLibId: "LIB_ID") -> "bool":
        r"""__eq__(LIB_ID self, LIB_ID aLibId) -> bool"""
        return _pcbnew.LIB_ID___eq__(self, aLibId)

    def __ne__(self, aLibId: "LIB_ID") -> "bool":
        r"""__ne__(LIB_ID self, LIB_ID aLibId) -> bool"""
        return _pcbnew.LIB_ID___ne__(self, aLibId)

    @staticmethod
    def HasIllegalChars(aLibItemName: "UTF8") -> "int":
        r"""HasIllegalChars(UTF8 aLibItemName) -> int"""
        return _pcbnew.LIB_ID_HasIllegalChars(aLibItemName)

    @staticmethod
    def FixIllegalChars(aLibItemName: "UTF8", aLib: "bool") -> "UTF8":
        r"""FixIllegalChars(UTF8 aLibItemName, bool aLib) -> UTF8"""
        return _pcbnew.LIB_ID_FixIllegalChars(aLibItemName, aLib)

    @staticmethod
    def FindIllegalLibraryNameChar(aLibraryName: "UTF8") -> "unsigned int":
        r"""FindIllegalLibraryNameChar(UTF8 aLibraryName) -> unsigned int"""
        return _pcbnew.LIB_ID_FindIllegalLibraryNameChar(aLibraryName)
    __swig_destroy__ = _pcbnew.delete_LIB_ID

# Register LIB_ID in _pcbnew:
_pcbnew.LIB_ID_swigregister(LIB_ID)
GERB_IU_PER_MM = cvar.GERB_IU_PER_MM
PCB_IU_PER_MM = cvar.PCB_IU_PER_MM
PL_IU_PER_MM = cvar.PL_IU_PER_MM
SCH_IU_PER_MM = cvar.SCH_IU_PER_MM
IU_PER_MM = cvar.IU_PER_MM
IU_PER_MILS = cvar.IU_PER_MILS
MM_PER_IU = cvar.MM_PER_IU
ARC_LOW_DEF = cvar.ARC_LOW_DEF
ARC_HIGH_DEF = cvar.ARC_HIGH_DEF

def LIB_ID_Format(*args) -> "UTF8":
    r"""
    LIB_ID_Format() -> UTF8
    LIB_ID_Format(UTF8 aLibraryName, UTF8 aLibItemName) -> UTF8
    """
    return _pcbnew.LIB_ID_Format(*args)

def LIB_ID_HasIllegalChars(aLibItemName: "UTF8") -> "int":
    r"""LIB_ID_HasIllegalChars(UTF8 aLibItemName) -> int"""
    return _pcbnew.LIB_ID_HasIllegalChars(aLibItemName)

def LIB_ID_FixIllegalChars(aLibItemName: "UTF8", aLib: "bool") -> "UTF8":
    r"""LIB_ID_FixIllegalChars(UTF8 aLibItemName, bool aLib) -> UTF8"""
    return _pcbnew.LIB_ID_FixIllegalChars(aLibItemName, aLib)

def LIB_ID_FindIllegalLibraryNameChar(aLibraryName: "UTF8") -> "unsigned int":
    r"""LIB_ID_FindIllegalLibraryNameChar(UTF8 aLibraryName) -> unsigned int"""
    return _pcbnew.LIB_ID_FindIllegalLibraryNameChar(aLibraryName)

class BASE_SET(object):
    r"""Proxy of C++ BASE_SET 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__ = _pcbnew.delete_BASE_SET

# Register BASE_SET in _pcbnew:
_pcbnew.BASE_SET_swigregister(BASE_SET)

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    LEGACY = _pcbnew.IO_MGR_LEGACY
    
    KICAD_SEXP = _pcbnew.IO_MGR_KICAD_SEXP
    
    EAGLE = _pcbnew.IO_MGR_EAGLE
    
    PCAD = _pcbnew.IO_MGR_PCAD
    
    FABMASTER = _pcbnew.IO_MGR_FABMASTER
    
    ALTIUM_DESIGNER = _pcbnew.IO_MGR_ALTIUM_DESIGNER
    
    ALTIUM_CIRCUIT_STUDIO = _pcbnew.IO_MGR_ALTIUM_CIRCUIT_STUDIO
    
    ALTIUM_CIRCUIT_MAKER = _pcbnew.IO_MGR_ALTIUM_CIRCUIT_MAKER
    
    CADSTAR_PCB_ARCHIVE = _pcbnew.IO_MGR_CADSTAR_PCB_ARCHIVE
    
    GEDA_PCB = _pcbnew.IO_MGR_GEDA_PCB
    
    FILE_TYPE_NONE = _pcbnew.IO_MGR_FILE_TYPE_NONE
    

    @staticmethod
    def PluginFind(aFileType: "IO_MGR::PCB_FILE_T") -> "PLUGIN *":
        r"""PluginFind(IO_MGR::PCB_FILE_T aFileType) -> PLUGIN"""
        return _pcbnew.IO_MGR_PluginFind(aFileType)

    @staticmethod
    def PluginRelease(aPlugin: "PLUGIN") -> "void":
        r"""PluginRelease(PLUGIN aPlugin)"""
        return _pcbnew.IO_MGR_PluginRelease(aPlugin)

    @staticmethod
    def ShowType(aFileType: "IO_MGR::PCB_FILE_T") -> "wxString const":
        r"""ShowType(IO_MGR::PCB_FILE_T aFileType) -> wxString"""
        return _pcbnew.IO_MGR_ShowType(aFileType)

    @staticmethod
    def EnumFromStr(aFileType: "wxString") -> "IO_MGR::PCB_FILE_T":
        r"""EnumFromStr(wxString aFileType) -> IO_MGR::PCB_FILE_T"""
        return _pcbnew.IO_MGR_EnumFromStr(aFileType)

    @staticmethod
    def GetFileExtension(aFileType: "IO_MGR::PCB_FILE_T") -> "wxString const":
        r"""GetFileExtension(IO_MGR::PCB_FILE_T aFileType) -> wxString"""
        return _pcbnew.IO_MGR_GetFileExtension(aFileType)

    @staticmethod
    def GuessPluginTypeFromLibPath(aLibPath: "wxString") -> "IO_MGR::PCB_FILE_T":
        r"""GuessPluginTypeFromLibPath(wxString aLibPath) -> IO_MGR::PCB_FILE_T"""
        return _pcbnew.IO_MGR_GuessPluginTypeFromLibPath(aLibPath)

    @staticmethod
    def Load(aFileType: "IO_MGR::PCB_FILE_T", aFileName: "wxString", aAppendToMe: "BOARD"=None, aProperties: "PROPERTIES const *"=None, aProject: "PROJECT *"=None, aProgressReporter: "PROGRESS_REPORTER *"=None) -> "BOARD *":
        r"""Load(IO_MGR::PCB_FILE_T aFileType, wxString aFileName, BOARD aAppendToMe=None, PROPERTIES const * aProperties=None, PROJECT * aProject=None, PROGRESS_REPORTER * aProgressReporter=None) -> BOARD"""
        return _pcbnew.IO_MGR_Load(aFileType, aFileName, aAppendToMe, aProperties, aProject, aProgressReporter)

    @staticmethod
    def Save(aFileType: "IO_MGR::PCB_FILE_T", aFileName: "wxString", aBoard: "BOARD", aProperties: "PROPERTIES const *"=None) -> "void":
        r"""Save(IO_MGR::PCB_FILE_T aFileType, wxString aFileName, BOARD aBoard, PROPERTIES const * aProperties=None)"""
        return _pcbnew.IO_MGR_Save(aFileType, aFileName, aBoard, aProperties)

    def __init__(self):
        r"""__init__(IO_MGR self) -> IO_MGR"""
        _pcbnew.IO_MGR_swiginit(self, _pcbnew.new_IO_MGR())
    __swig_destroy__ = _pcbnew.delete_IO_MGR

# Register IO_MGR in _pcbnew:
_pcbnew.IO_MGR_swigregister(IO_MGR)

def IO_MGR_PluginFind(aFileType: "IO_MGR::PCB_FILE_T") -> "PLUGIN *":
    r"""IO_MGR_PluginFind(IO_MGR::PCB_FILE_T aFileType) -> PLUGIN"""
    return _pcbnew.IO_MGR_PluginFind(aFileType)

def IO_MGR_PluginRelease(aPlugin: "PLUGIN") -> "void":
    r"""IO_MGR_PluginRelease(PLUGIN aPlugin)"""
    return _pcbnew.IO_MGR_PluginRelease(aPlugin)

def IO_MGR_ShowType(aFileType: "IO_MGR::PCB_FILE_T") -> "wxString const":
    r"""IO_MGR_ShowType(IO_MGR::PCB_FILE_T aFileType) -> wxString"""
    return _pcbnew.IO_MGR_ShowType(aFileType)

def IO_MGR_EnumFromStr(aFileType: "wxString") -> "IO_MGR::PCB_FILE_T":
    r"""IO_MGR_EnumFromStr(wxString aFileType) -> IO_MGR::PCB_FILE_T"""
    return _pcbnew.IO_MGR_EnumFromStr(aFileType)

def IO_MGR_GetFileExtension(aFileType: "IO_MGR::PCB_FILE_T") -> "wxString const":
    r"""IO_MGR_GetFileExtension(IO_MGR::PCB_FILE_T aFileType) -> wxString"""
    return _pcbnew.IO_MGR_GetFileExtension(aFileType)

def IO_MGR_GuessPluginTypeFromLibPath(aLibPath: "wxString") -> "IO_MGR::PCB_FILE_T":
    r"""IO_MGR_GuessPluginTypeFromLibPath(wxString aLibPath) -> IO_MGR::PCB_FILE_T"""
    return _pcbnew.IO_MGR_GuessPluginTypeFromLibPath(aLibPath)

def IO_MGR_Load(aFileType: "IO_MGR::PCB_FILE_T", aFileName: "wxString", aAppendToMe: "BOARD"=None, aProperties: "PROPERTIES const *"=None, aProject: "PROJECT *"=None, aProgressReporter: "PROGRESS_REPORTER *"=None) -> "BOARD *":
    r"""IO_MGR_Load(IO_MGR::PCB_FILE_T aFileType, wxString aFileName, BOARD aAppendToMe=None, PROPERTIES const * aProperties=None, PROJECT * aProject=None, PROGRESS_REPORTER * aProgressReporter=None) -> BOARD"""
    return _pcbnew.IO_MGR_Load(aFileType, aFileName, aAppendToMe, aProperties, aProject, aProgressReporter)

def IO_MGR_Save(aFileType: "IO_MGR::PCB_FILE_T", aFileName: "wxString", aBoard: "BOARD", aProperties: "PROPERTIES const *"=None) -> "void":
    r"""IO_MGR_Save(IO_MGR::PCB_FILE_T aFileType, wxString aFileName, BOARD aBoard, PROPERTIES const * aProperties=None)"""
    return _pcbnew.IO_MGR_Save(aFileType, aFileName, aBoard, aProperties)

class PLUGIN(object):
    r"""Proxy of C++ PLUGIN 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 PluginName(self) -> "wxString const":
        r"""PluginName(PLUGIN self) -> wxString"""
        return _pcbnew.PLUGIN_PluginName(self)

    def GetFileExtension(self) -> "wxString const":
        r"""GetFileExtension(PLUGIN self) -> wxString"""
        return _pcbnew.PLUGIN_GetFileExtension(self)

    def Load(self, aFileName: "wxString", aAppendToMe: "BOARD", aProperties: "PROPERTIES const *"=None, aProject: "PROJECT *"=None, aProgressReporter: "PROGRESS_REPORTER *"=None) -> "BOARD *":
        r"""Load(PLUGIN self, wxString aFileName, BOARD aAppendToMe, PROPERTIES const * aProperties=None, PROJECT * aProject=None, PROGRESS_REPORTER * aProgressReporter=None) -> BOARD"""
        return _pcbnew.PLUGIN_Load(self, aFileName, aAppendToMe, aProperties, aProject, aProgressReporter)

    def GetImportedCachedLibraryFootprints(self) -> "std::vector< FOOTPRINT *,std::allocator< FOOTPRINT * > >":
        r"""GetImportedCachedLibraryFootprints(PLUGIN self) -> std::vector< FOOTPRINT *,std::allocator< FOOTPRINT * > >"""
        return _pcbnew.PLUGIN_GetImportedCachedLibraryFootprints(self)

    def Save(self, aFileName: "wxString", aBoard: "BOARD", aProperties: "PROPERTIES const *"=None) -> "void":
        r"""Save(PLUGIN self, wxString aFileName, BOARD aBoard, PROPERTIES const * aProperties=None)"""
        return _pcbnew.PLUGIN_Save(self, aFileName, aBoard, aProperties)

    def FootprintEnumerate(self, aFootprintNames: "wxArrayString &", aLibraryPath: "wxString", aBestEfforts: "bool", aProperties: "PROPERTIES const *"=None) -> "void":
        r"""FootprintEnumerate(PLUGIN self, wxArrayString & aFootprintNames, wxString aLibraryPath, bool aBestEfforts, PROPERTIES const * aProperties=None)"""
        return _pcbnew.PLUGIN_FootprintEnumerate(self, aFootprintNames, aLibraryPath, aBestEfforts, aProperties)

    def GetLibraryTimestamp(self, aLibraryPath: "wxString") -> "long long":
        r"""GetLibraryTimestamp(PLUGIN self, wxString aLibraryPath) -> long long"""
        return _pcbnew.PLUGIN_GetLibraryTimestamp(self, aLibraryPath)

    def PrefetchLib(self, aLibraryPath: "wxString", aProperties: "PROPERTIES const *"=None) -> "void":
        r"""PrefetchLib(PLUGIN self, wxString aLibraryPath, PROPERTIES const * aProperties=None)"""
        return _pcbnew.PLUGIN_PrefetchLib(self, aLibraryPath, aProperties)

    def FootprintLoad(self, aLibraryPath: "wxString", aFootprintName: "wxString", aKeepUUID: "bool"=False, aProperties: "PROPERTIES const *"=None) -> "FOOTPRINT *":
        r"""FootprintLoad(PLUGIN self, wxString aLibraryPath, wxString aFootprintName, bool aKeepUUID=False, PROPERTIES const * aProperties=None) -> FOOTPRINT"""
        return _pcbnew.PLUGIN_FootprintLoad(self, aLibraryPath, aFootprintName, aKeepUUID, aProperties)

    def GetEnumeratedFootprint(self, aLibraryPath: "wxString", aFootprintName: "wxString", aProperties: "PROPERTIES const *"=None) -> "FOOTPRINT const *":
        r"""GetEnumeratedFootprint(PLUGIN self, wxString aLibraryPath, wxString aFootprintName, PROPERTIES const * aProperties=None) -> FOOTPRINT"""
        return _pcbnew.PLUGIN_GetEnumeratedFootprint(self, aLibraryPath, aFootprintName, aProperties)

    def FootprintExists(self, aLibraryPath: "wxString", aFootprintName: "wxString", aProperties: "PROPERTIES const *"=None) -> "bool":
        r"""FootprintExists(PLUGIN self, wxString aLibraryPath, wxString aFootprintName, PROPERTIES const * aProperties=None) -> bool"""
        return _pcbnew.PLUGIN_FootprintExists(self, aLibraryPath, aFootprintName, aProperties)

    def FootprintSave(self, aLibraryPath: "wxString", aFootprint: "FOOTPRINT", aProperties: "PROPERTIES const *"=None) -> "void":
        r"""FootprintSave(PLUGIN self, wxString aLibraryPath, FOOTPRINT aFootprint, PROPERTIES const * aProperties=None)"""
        return _pcbnew.PLUGIN_FootprintSave(self, aLibraryPath, aFootprint, aProperties)

    def FootprintDelete(self, aLibraryPath: "wxString", aFootprintName: "wxString", aProperties: "PROPERTIES const *"=None) -> "void":
        r"""FootprintDelete(PLUGIN self, wxString aLibraryPath, wxString aFootprintName, PROPERTIES const * aProperties=None)"""
        return _pcbnew.PLUGIN_FootprintDelete(self, aLibraryPath, aFootprintName, aProperties)

    def FootprintLibCreate(self, aLibraryPath: "wxString", aProperties: "PROPERTIES const *"=None) -> "void":
        r"""FootprintLibCreate(PLUGIN self, wxString aLibraryPath, PROPERTIES const * aProperties=None)"""
        return _pcbnew.PLUGIN_FootprintLibCreate(self, aLibraryPath, aProperties)

    def FootprintLibDelete(self, aLibraryPath: "wxString", aProperties: "PROPERTIES const *"=None) -> "bool":
        r"""FootprintLibDelete(PLUGIN self, wxString aLibraryPath, PROPERTIES const * aProperties=None) -> bool"""
        return _pcbnew.PLUGIN_FootprintLibDelete(self, aLibraryPath, aProperties)

    def IsFootprintLibWritable(self, aLibraryPath: "wxString") -> "bool":
        r"""IsFootprintLibWritable(PLUGIN self, wxString aLibraryPath) -> bool"""
        return _pcbnew.PLUGIN_IsFootprintLibWritable(self, aLibraryPath)

    def FootprintLibOptions(self, aListToAppendTo: "PROPERTIES *") -> "void":
        r"""FootprintLibOptions(PLUGIN self, PROPERTIES * aListToAppendTo)"""
        return _pcbnew.PLUGIN_FootprintLibOptions(self, aListToAppendTo)
    __swig_destroy__ = _pcbnew.delete_PLUGIN

    def footprintPyEnumerate(self, aLibraryPath: "wxString", aExitOnError: "bool") -> "wxArrayString":
        r"""footprintPyEnumerate(PLUGIN self, wxString aLibraryPath, bool aExitOnError) -> wxArrayString"""
        return _pcbnew.PLUGIN_footprintPyEnumerate(self, aLibraryPath, aExitOnError)

    def FootprintEnumerate(self, libname):
        return self.footprintPyEnumerate( libname, True )


# Register PLUGIN in _pcbnew:
_pcbnew.PLUGIN_swigregister(PLUGIN)

SEXPR_BOARD_FILE_VERSION = _pcbnew.SEXPR_BOARD_FILE_VERSION

BOARD_FILE_HOST_VERSION = _pcbnew.BOARD_FILE_HOST_VERSION

LEGACY_ARC_FORMATTING = _pcbnew.LEGACY_ARC_FORMATTING

CTL_OMIT_PAD_NETS = _pcbnew.CTL_OMIT_PAD_NETS

CTL_OMIT_TSTAMPS = _pcbnew.CTL_OMIT_TSTAMPS

CTL_OMIT_INITIAL_COMMENTS = _pcbnew.CTL_OMIT_INITIAL_COMMENTS

CTL_OMIT_PATH = _pcbnew.CTL_OMIT_PATH

CTL_OMIT_AT = _pcbnew.CTL_OMIT_AT

CTL_OMIT_LIBNAME = _pcbnew.CTL_OMIT_LIBNAME

CTL_OMIT_FOOTPRINT_VERSION = _pcbnew.CTL_OMIT_FOOTPRINT_VERSION

CTL_FOR_CLIPBOARD = _pcbnew.CTL_FOR_CLIPBOARD

CTL_FOR_LIBRARY = _pcbnew.CTL_FOR_LIBRARY

CTL_FOR_BOARD = _pcbnew.CTL_FOR_BOARD

class PCB_PLUGIN(PLUGIN):
    r"""Proxy of C++ PCB_PLUGIN class."""

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

    def PluginName(self) -> "wxString const":
        r"""PluginName(PCB_PLUGIN self) -> wxString"""
        return _pcbnew.PCB_PLUGIN_PluginName(self)

    def GetFileExtension(self) -> "wxString const":
        r"""GetFileExtension(PCB_PLUGIN self) -> wxString"""
        return _pcbnew.PCB_PLUGIN_GetFileExtension(self)

    def Save(self, aFileName: "wxString", aBoard: "BOARD", aProperties: "PROPERTIES const *"=None) -> "void":
        r"""Save(PCB_PLUGIN self, wxString aFileName, BOARD aBoard, PROPERTIES const * aProperties=None)"""
        return _pcbnew.PCB_PLUGIN_Save(self, aFileName, aBoard, aProperties)

    def Load(self, aFileName: "wxString", aAppendToMe: "BOARD", aProperties: "PROPERTIES const *"=None, aProject: "PROJECT *"=None, aProgressReporter: "PROGRESS_REPORTER *"=None) -> "BOARD *":
        r"""Load(PCB_PLUGIN self, wxString aFileName, BOARD aAppendToMe, PROPERTIES const * aProperties=None, PROJECT * aProject=None, PROGRESS_REPORTER * aProgressReporter=None) -> BOARD"""
        return _pcbnew.PCB_PLUGIN_Load(self, aFileName, aAppendToMe, aProperties, aProject, aProgressReporter)

    def DoLoad(self, aReader: "LINE_READER", aAppendToMe: "BOARD", aProperties: "PROPERTIES const *", aProgressReporter: "PROGRESS_REPORTER *", aLineCount: "unsigned int") -> "BOARD *":
        r"""DoLoad(PCB_PLUGIN self, LINE_READER aReader, BOARD aAppendToMe, PROPERTIES const * aProperties, PROGRESS_REPORTER * aProgressReporter, unsigned int aLineCount) -> BOARD"""
        return _pcbnew.PCB_PLUGIN_DoLoad(self, aReader, aAppendToMe, aProperties, aProgressReporter, aLineCount)

    def FootprintEnumerate(self, aFootprintNames: "wxArrayString &", aLibraryPath: "wxString", aBestEfforts: "bool", aProperties: "PROPERTIES const *"=None) -> "void":
        r"""FootprintEnumerate(PCB_PLUGIN self, wxArrayString & aFootprintNames, wxString aLibraryPath, bool aBestEfforts, PROPERTIES const * aProperties=None)"""
        return _pcbnew.PCB_PLUGIN_FootprintEnumerate(self, aFootprintNames, aLibraryPath, aBestEfforts, aProperties)

    def GetEnumeratedFootprint(self, aLibraryPath: "wxString", aFootprintName: "wxString", aProperties: "PROPERTIES const *"=None) -> "FOOTPRINT const *":
        r"""GetEnumeratedFootprint(PCB_PLUGIN self, wxString aLibraryPath, wxString aFootprintName, PROPERTIES const * aProperties=None) -> FOOTPRINT"""
        return _pcbnew.PCB_PLUGIN_GetEnumeratedFootprint(self, aLibraryPath, aFootprintName, aProperties)

    def FootprintExists(self, aLibraryPath: "wxString", aFootprintName: "wxString", aProperties: "PROPERTIES const *"=None) -> "bool":
        r"""FootprintExists(PCB_PLUGIN self, wxString aLibraryPath, wxString aFootprintName, PROPERTIES const * aProperties=None) -> bool"""
        return _pcbnew.PCB_PLUGIN_FootprintExists(self, aLibraryPath, aFootprintName, aProperties)

    def FootprintLoad(self, aLibraryPath: "wxString", aFootprintName: "wxString", aKeepUUID: "bool"=False, aProperties: "PROPERTIES const *"=None) -> "FOOTPRINT *":
        r"""FootprintLoad(PCB_PLUGIN self, wxString aLibraryPath, wxString aFootprintName, bool aKeepUUID=False, PROPERTIES const * aProperties=None) -> FOOTPRINT"""
        return _pcbnew.PCB_PLUGIN_FootprintLoad(self, aLibraryPath, aFootprintName, aKeepUUID, aProperties)

    def FootprintSave(self, aLibraryPath: "wxString", aFootprint: "FOOTPRINT", aProperties: "PROPERTIES const *"=None) -> "void":
        r"""FootprintSave(PCB_PLUGIN self, wxString aLibraryPath, FOOTPRINT aFootprint, PROPERTIES const * aProperties=None)"""
        return _pcbnew.PCB_PLUGIN_FootprintSave(self, aLibraryPath, aFootprint, aProperties)

    def FootprintDelete(self, aLibraryPath: "wxString", aFootprintName: "wxString", aProperties: "PROPERTIES const *"=None) -> "void":
        r"""FootprintDelete(PCB_PLUGIN self, wxString aLibraryPath, wxString aFootprintName, PROPERTIES const * aProperties=None)"""
        return _pcbnew.PCB_PLUGIN_FootprintDelete(self, aLibraryPath, aFootprintName, aProperties)

    def GetLibraryTimestamp(self, aLibraryPath: "wxString") -> "long long":
        r"""GetLibraryTimestamp(PCB_PLUGIN self, wxString aLibraryPath) -> long long"""
        return _pcbnew.PCB_PLUGIN_GetLibraryTimestamp(self, aLibraryPath)

    def FootprintLibCreate(self, aLibraryPath: "wxString", aProperties: "PROPERTIES const *"=None) -> "void":
        r"""FootprintLibCreate(PCB_PLUGIN self, wxString aLibraryPath, PROPERTIES const * aProperties=None)"""
        return _pcbnew.PCB_PLUGIN_FootprintLibCreate(self, aLibraryPath, aProperties)

    def FootprintLibDelete(self, aLibraryPath: "wxString", aProperties: "PROPERTIES const *"=None) -> "bool":
        r"""FootprintLibDelete(PCB_PLUGIN self, wxString aLibraryPath, PROPERTIES const * aProperties=None) -> bool"""
        return _pcbnew.PCB_PLUGIN_FootprintLibDelete(self, aLibraryPath, aProperties)

    def IsFootprintLibWritable(self, aLibraryPath: "wxString") -> "bool":
        r"""IsFootprintLibWritable(PCB_PLUGIN self, wxString aLibraryPath) -> bool"""
        return _pcbnew.PCB_PLUGIN_IsFootprintLibWritable(self, aLibraryPath)

    def __init__(self, *args):
        r"""__init__(PCB_PLUGIN self, int aControlFlags=((1 << 3)|(1 << 8))) -> PCB_PLUGIN"""
        _pcbnew.PCB_PLUGIN_swiginit(self, _pcbnew.new_PCB_PLUGIN(*args))
    __swig_destroy__ = _pcbnew.delete_PCB_PLUGIN

    def Format(self, aItem: "BOARD_ITEM", aNestLevel: "int"=0) -> "void":
        r"""Format(PCB_PLUGIN self, BOARD_ITEM aItem, int aNestLevel=0)"""
        return _pcbnew.PCB_PLUGIN_Format(self, aItem, aNestLevel)

    def GetStringOutput(self, doClear: "bool") -> "std::string":
        r"""GetStringOutput(PCB_PLUGIN self, bool doClear) -> string"""
        return _pcbnew.PCB_PLUGIN_GetStringOutput(self, doClear)

    def SetOutputFormatter(self, aFormatter: "OUTPUTFORMATTER") -> "void":
        r"""SetOutputFormatter(PCB_PLUGIN self, OUTPUTFORMATTER aFormatter)"""
        return _pcbnew.PCB_PLUGIN_SetOutputFormatter(self, aFormatter)

    def Parse(self, aClipboardSourceInput: "wxString") -> "BOARD_ITEM *":
        r"""Parse(PCB_PLUGIN self, wxString aClipboardSourceInput) -> BOARD_ITEM"""
        return _pcbnew.PCB_PLUGIN_Parse(self, aClipboardSourceInput)

# Register PCB_PLUGIN in _pcbnew:
_pcbnew.PCB_PLUGIN_swigregister(PCB_PLUGIN)

class PLOT_CONTROLLER(object):
    r"""Proxy of C++ PLOT_CONTROLLER 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, aBoard: "BOARD"):
        r"""__init__(PLOT_CONTROLLER self, BOARD aBoard) -> PLOT_CONTROLLER"""
        _pcbnew.PLOT_CONTROLLER_swiginit(self, _pcbnew.new_PLOT_CONTROLLER(aBoard))
    __swig_destroy__ = _pcbnew.delete_PLOT_CONTROLLER

    def GetPlotOptions(self) -> "PCB_PLOT_PARAMS &":
        r"""GetPlotOptions(PLOT_CONTROLLER self) -> PCB_PLOT_PARAMS"""
        return _pcbnew.PLOT_CONTROLLER_GetPlotOptions(self)

    def SetLayer(self, aLayer: "LAYER_NUM") -> "void":
        r"""SetLayer(PLOT_CONTROLLER self, LAYER_NUM aLayer)"""
        return _pcbnew.PLOT_CONTROLLER_SetLayer(self, aLayer)

    def GetLayer(self) -> "LAYER_NUM":
        r"""GetLayer(PLOT_CONTROLLER self) -> LAYER_NUM"""
        return _pcbnew.PLOT_CONTROLLER_GetLayer(self)

    def IsPlotOpen(self) -> "bool":
        r"""IsPlotOpen(PLOT_CONTROLLER self) -> bool"""
        return _pcbnew.PLOT_CONTROLLER_IsPlotOpen(self)

    def ClosePlot(self) -> "void":
        r"""ClosePlot(PLOT_CONTROLLER self)"""
        return _pcbnew.PLOT_CONTROLLER_ClosePlot(self)

    def OpenPlotfile(self, aSuffix: "wxString", aFormat: "PLOT_FORMAT", aSheetDesc: "wxString") -> "bool":
        r"""OpenPlotfile(PLOT_CONTROLLER self, wxString aSuffix, PLOT_FORMAT aFormat, wxString aSheetDesc) -> bool"""
        return _pcbnew.PLOT_CONTROLLER_OpenPlotfile(self, aSuffix, aFormat, aSheetDesc)

    def PlotLayer(self) -> "bool":
        r"""PlotLayer(PLOT_CONTROLLER self) -> bool"""
        return _pcbnew.PLOT_CONTROLLER_PlotLayer(self)

    def GetPlotFileName(self) -> "wxString const":
        r"""GetPlotFileName(PLOT_CONTROLLER self) -> wxString"""
        return _pcbnew.PLOT_CONTROLLER_GetPlotFileName(self)

    def GetPlotDirName(self) -> "wxString const":
        r"""GetPlotDirName(PLOT_CONTROLLER self) -> wxString"""
        return _pcbnew.PLOT_CONTROLLER_GetPlotDirName(self)

    def SetColorMode(self, aColorMode: "bool") -> "void":
        r"""SetColorMode(PLOT_CONTROLLER self, bool aColorMode)"""
        return _pcbnew.PLOT_CONTROLLER_SetColorMode(self, aColorMode)

    def GetColorMode(self) -> "bool":
        r"""GetColorMode(PLOT_CONTROLLER self) -> bool"""
        return _pcbnew.PLOT_CONTROLLER_GetColorMode(self)

# Register PLOT_CONTROLLER in _pcbnew:
_pcbnew.PLOT_CONTROLLER_swigregister(PLOT_CONTROLLER)

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    NO_DRILL_SHAPE = _pcbnew.PCB_PLOT_PARAMS_NO_DRILL_SHAPE
    
    SMALL_DRILL_SHAPE = _pcbnew.PCB_PLOT_PARAMS_SMALL_DRILL_SHAPE
    
    FULL_DRILL_SHAPE = _pcbnew.PCB_PLOT_PARAMS_FULL_DRILL_SHAPE
    

    def __init__(self):
        r"""__init__(PCB_PLOT_PARAMS self) -> PCB_PLOT_PARAMS"""
        _pcbnew.PCB_PLOT_PARAMS_swiginit(self, _pcbnew.new_PCB_PLOT_PARAMS())

    def SetSkipPlotNPTH_Pads(self, aSkip: "bool") -> "void":
        r"""SetSkipPlotNPTH_Pads(PCB_PLOT_PARAMS self, bool aSkip)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetSkipPlotNPTH_Pads(self, aSkip)

    def GetSkipPlotNPTH_Pads(self) -> "bool":
        r"""GetSkipPlotNPTH_Pads(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetSkipPlotNPTH_Pads(self)

    def Format(self, aFormatter: "OUTPUTFORMATTER", aNestLevel: "int", aControl: "int"=0) -> "void":
        r"""Format(PCB_PLOT_PARAMS self, OUTPUTFORMATTER aFormatter, int aNestLevel, int aControl=0)"""
        return _pcbnew.PCB_PLOT_PARAMS_Format(self, aFormatter, aNestLevel, aControl)

    def Parse(self, aParser: "PCB_PLOT_PARAMS_PARSER *") -> "void":
        r"""Parse(PCB_PLOT_PARAMS self, PCB_PLOT_PARAMS_PARSER * aParser)"""
        return _pcbnew.PCB_PLOT_PARAMS_Parse(self, aParser)

    def IsSameAs(self, aPcbPlotParams: "PCB_PLOT_PARAMS") -> "bool":
        r"""IsSameAs(PCB_PLOT_PARAMS self, PCB_PLOT_PARAMS aPcbPlotParams) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_IsSameAs(self, aPcbPlotParams)

    def SetColorSettings(self, aSettings: "COLOR_SETTINGS *") -> "void":
        r"""SetColorSettings(PCB_PLOT_PARAMS self, COLOR_SETTINGS * aSettings)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetColorSettings(self, aSettings)

    def ColorSettings(self) -> "COLOR_SETTINGS *":
        r"""ColorSettings(PCB_PLOT_PARAMS self) -> COLOR_SETTINGS *"""
        return _pcbnew.PCB_PLOT_PARAMS_ColorSettings(self)

    def SetTextMode(self, aVal: "PLOT_TEXT_MODE") -> "void":
        r"""SetTextMode(PCB_PLOT_PARAMS self, PLOT_TEXT_MODE aVal)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetTextMode(self, aVal)

    def GetTextMode(self) -> "PLOT_TEXT_MODE":
        r"""GetTextMode(PCB_PLOT_PARAMS self) -> PLOT_TEXT_MODE"""
        return _pcbnew.PCB_PLOT_PARAMS_GetTextMode(self)

    def SetPlotMode(self, aPlotMode: "OUTLINE_MODE") -> "void":
        r"""SetPlotMode(PCB_PLOT_PARAMS self, OUTLINE_MODE aPlotMode)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetPlotMode(self, aPlotMode)

    def GetPlotMode(self) -> "OUTLINE_MODE":
        r"""GetPlotMode(PCB_PLOT_PARAMS self) -> OUTLINE_MODE"""
        return _pcbnew.PCB_PLOT_PARAMS_GetPlotMode(self)

    def SetDXFPlotPolygonMode(self, aFlag: "bool") -> "void":
        r"""SetDXFPlotPolygonMode(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetDXFPlotPolygonMode(self, aFlag)

    def GetDXFPlotPolygonMode(self) -> "bool":
        r"""GetDXFPlotPolygonMode(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetDXFPlotPolygonMode(self)

    def SetDXFPlotUnits(self, aUnit: "DXF_UNITS") -> "void":
        r"""SetDXFPlotUnits(PCB_PLOT_PARAMS self, DXF_UNITS aUnit)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetDXFPlotUnits(self, aUnit)

    def GetDXFPlotUnits(self) -> "DXF_UNITS":
        r"""GetDXFPlotUnits(PCB_PLOT_PARAMS self) -> DXF_UNITS"""
        return _pcbnew.PCB_PLOT_PARAMS_GetDXFPlotUnits(self)

    def SetDrillMarksType(self, aVal: "PCB_PLOT_PARAMS::DrillMarksType") -> "void":
        r"""SetDrillMarksType(PCB_PLOT_PARAMS self, PCB_PLOT_PARAMS::DrillMarksType aVal)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetDrillMarksType(self, aVal)

    def GetDrillMarksType(self) -> "PCB_PLOT_PARAMS::DrillMarksType":
        r"""GetDrillMarksType(PCB_PLOT_PARAMS self) -> PCB_PLOT_PARAMS::DrillMarksType"""
        return _pcbnew.PCB_PLOT_PARAMS_GetDrillMarksType(self)

    def SetScale(self, aVal: "double") -> "void":
        r"""SetScale(PCB_PLOT_PARAMS self, double aVal)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetScale(self, aVal)

    def GetScale(self) -> "double":
        r"""GetScale(PCB_PLOT_PARAMS self) -> double"""
        return _pcbnew.PCB_PLOT_PARAMS_GetScale(self)

    def SetFineScaleAdjustX(self, aVal: "double") -> "void":
        r"""SetFineScaleAdjustX(PCB_PLOT_PARAMS self, double aVal)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetFineScaleAdjustX(self, aVal)

    def GetFineScaleAdjustX(self) -> "double":
        r"""GetFineScaleAdjustX(PCB_PLOT_PARAMS self) -> double"""
        return _pcbnew.PCB_PLOT_PARAMS_GetFineScaleAdjustX(self)

    def SetFineScaleAdjustY(self, aVal: "double") -> "void":
        r"""SetFineScaleAdjustY(PCB_PLOT_PARAMS self, double aVal)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetFineScaleAdjustY(self, aVal)

    def GetFineScaleAdjustY(self) -> "double":
        r"""GetFineScaleAdjustY(PCB_PLOT_PARAMS self) -> double"""
        return _pcbnew.PCB_PLOT_PARAMS_GetFineScaleAdjustY(self)

    def SetWidthAdjust(self, aVal: "int") -> "void":
        r"""SetWidthAdjust(PCB_PLOT_PARAMS self, int aVal)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetWidthAdjust(self, aVal)

    def GetWidthAdjust(self) -> "int":
        r"""GetWidthAdjust(PCB_PLOT_PARAMS self) -> int"""
        return _pcbnew.PCB_PLOT_PARAMS_GetWidthAdjust(self)

    def SetAutoScale(self, aFlag: "bool") -> "void":
        r"""SetAutoScale(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetAutoScale(self, aFlag)

    def GetAutoScale(self) -> "bool":
        r"""GetAutoScale(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetAutoScale(self)

    def SetMirror(self, aFlag: "bool") -> "void":
        r"""SetMirror(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetMirror(self, aFlag)

    def GetMirror(self) -> "bool":
        r"""GetMirror(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetMirror(self)

    def SetSketchPadsOnFabLayers(self, aFlag: "bool") -> "void":
        r"""SetSketchPadsOnFabLayers(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetSketchPadsOnFabLayers(self, aFlag)

    def GetSketchPadsOnFabLayers(self) -> "bool":
        r"""GetSketchPadsOnFabLayers(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetSketchPadsOnFabLayers(self)

    def SetSketchPadLineWidth(self, aWidth: "int") -> "void":
        r"""SetSketchPadLineWidth(PCB_PLOT_PARAMS self, int aWidth)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetSketchPadLineWidth(self, aWidth)

    def GetSketchPadLineWidth(self) -> "int":
        r"""GetSketchPadLineWidth(PCB_PLOT_PARAMS self) -> int"""
        return _pcbnew.PCB_PLOT_PARAMS_GetSketchPadLineWidth(self)

    def SetPlotInvisibleText(self, aFlag: "bool") -> "void":
        r"""SetPlotInvisibleText(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetPlotInvisibleText(self, aFlag)

    def GetPlotInvisibleText(self) -> "bool":
        r"""GetPlotInvisibleText(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetPlotInvisibleText(self)

    def SetPlotValue(self, aFlag: "bool") -> "void":
        r"""SetPlotValue(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetPlotValue(self, aFlag)

    def GetPlotValue(self) -> "bool":
        r"""GetPlotValue(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetPlotValue(self)

    def SetPlotReference(self, aFlag: "bool") -> "void":
        r"""SetPlotReference(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetPlotReference(self, aFlag)

    def GetPlotReference(self) -> "bool":
        r"""GetPlotReference(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetPlotReference(self)

    def SetNegative(self, aFlag: "bool") -> "void":
        r"""SetNegative(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetNegative(self, aFlag)

    def GetNegative(self) -> "bool":
        r"""GetNegative(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetNegative(self)

    def SetPlotViaOnMaskLayer(self, aFlag: "bool") -> "void":
        r"""SetPlotViaOnMaskLayer(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetPlotViaOnMaskLayer(self, aFlag)

    def GetPlotViaOnMaskLayer(self) -> "bool":
        r"""GetPlotViaOnMaskLayer(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetPlotViaOnMaskLayer(self)

    def SetPlotFrameRef(self, aFlag: "bool") -> "void":
        r"""SetPlotFrameRef(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetPlotFrameRef(self, aFlag)

    def GetPlotFrameRef(self) -> "bool":
        r"""GetPlotFrameRef(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetPlotFrameRef(self)

    def SetExcludeEdgeLayer(self, aFlag: "bool") -> "void":
        r"""SetExcludeEdgeLayer(PCB_PLOT_PARAMS self, bool aFlag)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetExcludeEdgeLayer(self, aFlag)

    def GetExcludeEdgeLayer(self) -> "bool":
        r"""GetExcludeEdgeLayer(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetExcludeEdgeLayer(self)

    def SetFormat(self, aFormat: "PLOT_FORMAT") -> "void":
        r"""SetFormat(PCB_PLOT_PARAMS self, PLOT_FORMAT aFormat)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetFormat(self, aFormat)

    def GetFormat(self) -> "PLOT_FORMAT":
        r"""GetFormat(PCB_PLOT_PARAMS self) -> PLOT_FORMAT"""
        return _pcbnew.PCB_PLOT_PARAMS_GetFormat(self)

    def SetOutputDirectory(self, aDir: "wxString") -> "void":
        r"""SetOutputDirectory(PCB_PLOT_PARAMS self, wxString aDir)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetOutputDirectory(self, aDir)

    def GetOutputDirectory(self) -> "wxString":
        r"""GetOutputDirectory(PCB_PLOT_PARAMS self) -> wxString"""
        return _pcbnew.PCB_PLOT_PARAMS_GetOutputDirectory(self)

    def SetDisableGerberMacros(self, aDisable: "bool") -> "void":
        r"""SetDisableGerberMacros(PCB_PLOT_PARAMS self, bool aDisable)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetDisableGerberMacros(self, aDisable)

    def GetDisableGerberMacros(self) -> "bool":
        r"""GetDisableGerberMacros(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetDisableGerberMacros(self)

    def SetUseGerberX2format(self, aUse: "bool") -> "void":
        r"""SetUseGerberX2format(PCB_PLOT_PARAMS self, bool aUse)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetUseGerberX2format(self, aUse)

    def GetUseGerberX2format(self) -> "bool":
        r"""GetUseGerberX2format(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetUseGerberX2format(self)

    def SetIncludeGerberNetlistInfo(self, aUse: "bool") -> "void":
        r"""SetIncludeGerberNetlistInfo(PCB_PLOT_PARAMS self, bool aUse)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetIncludeGerberNetlistInfo(self, aUse)

    def GetIncludeGerberNetlistInfo(self) -> "bool":
        r"""GetIncludeGerberNetlistInfo(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetIncludeGerberNetlistInfo(self)

    def SetCreateGerberJobFile(self, aCreate: "bool") -> "void":
        r"""SetCreateGerberJobFile(PCB_PLOT_PARAMS self, bool aCreate)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetCreateGerberJobFile(self, aCreate)

    def GetCreateGerberJobFile(self) -> "bool":
        r"""GetCreateGerberJobFile(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetCreateGerberJobFile(self)

    def SetUseGerberProtelExtensions(self, aUse: "bool") -> "void":
        r"""SetUseGerberProtelExtensions(PCB_PLOT_PARAMS self, bool aUse)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetUseGerberProtelExtensions(self, aUse)

    def GetUseGerberProtelExtensions(self) -> "bool":
        r"""GetUseGerberProtelExtensions(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetUseGerberProtelExtensions(self)

    def SetGerberPrecision(self, aPrecision: "int") -> "void":
        r"""SetGerberPrecision(PCB_PLOT_PARAMS self, int aPrecision)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetGerberPrecision(self, aPrecision)

    def GetGerberPrecision(self) -> "int":
        r"""GetGerberPrecision(PCB_PLOT_PARAMS self) -> int"""
        return _pcbnew.PCB_PLOT_PARAMS_GetGerberPrecision(self)

    def SetSvgPrecision(self, aPrecision: "unsigned int", aUseInch: "bool") -> "void":
        r"""SetSvgPrecision(PCB_PLOT_PARAMS self, unsigned int aPrecision, bool aUseInch)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetSvgPrecision(self, aPrecision, aUseInch)

    def GetSvgPrecision(self) -> "unsigned int":
        r"""GetSvgPrecision(PCB_PLOT_PARAMS self) -> unsigned int"""
        return _pcbnew.PCB_PLOT_PARAMS_GetSvgPrecision(self)

    def GetSvgUseInch(self) -> "bool":
        r"""GetSvgUseInch(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetSvgUseInch(self)

    @staticmethod
    def GetGerberDefaultPrecision() -> "int":
        r"""GetGerberDefaultPrecision() -> int"""
        return _pcbnew.PCB_PLOT_PARAMS_GetGerberDefaultPrecision()

    def SetSubtractMaskFromSilk(self, aSubtract: "bool") -> "void":
        r"""SetSubtractMaskFromSilk(PCB_PLOT_PARAMS self, bool aSubtract)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetSubtractMaskFromSilk(self, aSubtract)

    def GetSubtractMaskFromSilk(self) -> "bool":
        r"""GetSubtractMaskFromSilk(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetSubtractMaskFromSilk(self)

    def SetLayerSelection(self, aSelection: "LSET") -> "void":
        r"""SetLayerSelection(PCB_PLOT_PARAMS self, LSET aSelection)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetLayerSelection(self, aSelection)

    def GetLayerSelection(self) -> "LSET":
        r"""GetLayerSelection(PCB_PLOT_PARAMS self) -> LSET"""
        return _pcbnew.PCB_PLOT_PARAMS_GetLayerSelection(self)

    def SetUseAuxOrigin(self, aAux: "bool") -> "void":
        r"""SetUseAuxOrigin(PCB_PLOT_PARAMS self, bool aAux)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetUseAuxOrigin(self, aAux)

    def GetUseAuxOrigin(self) -> "bool":
        r"""GetUseAuxOrigin(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetUseAuxOrigin(self)

    def SetScaleSelection(self, aSelection: "int") -> "void":
        r"""SetScaleSelection(PCB_PLOT_PARAMS self, int aSelection)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetScaleSelection(self, aSelection)

    def GetScaleSelection(self) -> "int":
        r"""GetScaleSelection(PCB_PLOT_PARAMS self) -> int"""
        return _pcbnew.PCB_PLOT_PARAMS_GetScaleSelection(self)

    def SetA4Output(self, aForce: "int") -> "void":
        r"""SetA4Output(PCB_PLOT_PARAMS self, int aForce)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetA4Output(self, aForce)

    def GetA4Output(self) -> "bool":
        r"""GetA4Output(PCB_PLOT_PARAMS self) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_GetA4Output(self)

    def GetHPGLPenDiameter(self) -> "double":
        r"""GetHPGLPenDiameter(PCB_PLOT_PARAMS self) -> double"""
        return _pcbnew.PCB_PLOT_PARAMS_GetHPGLPenDiameter(self)

    def SetHPGLPenDiameter(self, aValue: "double") -> "bool":
        r"""SetHPGLPenDiameter(PCB_PLOT_PARAMS self, double aValue) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_SetHPGLPenDiameter(self, aValue)

    def GetHPGLPenSpeed(self) -> "int":
        r"""GetHPGLPenSpeed(PCB_PLOT_PARAMS self) -> int"""
        return _pcbnew.PCB_PLOT_PARAMS_GetHPGLPenSpeed(self)

    def SetHPGLPenSpeed(self, aValue: "int") -> "bool":
        r"""SetHPGLPenSpeed(PCB_PLOT_PARAMS self, int aValue) -> bool"""
        return _pcbnew.PCB_PLOT_PARAMS_SetHPGLPenSpeed(self, aValue)

    def SetHPGLPenNum(self, aVal: "int") -> "void":
        r"""SetHPGLPenNum(PCB_PLOT_PARAMS self, int aVal)"""
        return _pcbnew.PCB_PLOT_PARAMS_SetHPGLPenNum(self, aVal)

    def GetHPGLPenNum(self) -> "int":
        r"""GetHPGLPenNum(PCB_PLOT_PARAMS self) -> int"""
        return _pcbnew.PCB_PLOT_PARAMS_GetHPGLPenNum(self)

        # add SetUseGerberAttributes() for compatibility with old python scripts
        # after renaming it to SetUseGerberX2format()
    def SetUseGerberAttributes( self, aUse ):
        return self.SetUseGerberX2format( aUse )

    __swig_destroy__ = _pcbnew.delete_PCB_PLOT_PARAMS

# Register PCB_PLOT_PARAMS in _pcbnew:
_pcbnew.PCB_PLOT_PARAMS_swigregister(PCB_PLOT_PARAMS)

def PCB_PLOT_PARAMS_GetGerberDefaultPrecision() -> "int":
    r"""PCB_PLOT_PARAMS_GetGerberDefaultPrecision() -> int"""
    return _pcbnew.PCB_PLOT_PARAMS_GetGerberDefaultPrecision()

DXF_UNITS_INCHES = _pcbnew.DXF_UNITS_INCHES

DXF_UNITS_MILLIMETERS = _pcbnew.DXF_UNITS_MILLIMETERS

PLOT_FORMAT_UNDEFINED = _pcbnew.PLOT_FORMAT_UNDEFINED

PLOT_FORMAT_FIRST_FORMAT = _pcbnew.PLOT_FORMAT_FIRST_FORMAT

PLOT_FORMAT_HPGL = _pcbnew.PLOT_FORMAT_HPGL

PLOT_FORMAT_GERBER = _pcbnew.PLOT_FORMAT_GERBER

PLOT_FORMAT_POST = _pcbnew.PLOT_FORMAT_POST

PLOT_FORMAT_DXF = _pcbnew.PLOT_FORMAT_DXF

PLOT_FORMAT_PDF = _pcbnew.PLOT_FORMAT_PDF

PLOT_FORMAT_SVG = _pcbnew.PLOT_FORMAT_SVG

PLOT_FORMAT_LAST_FORMAT = _pcbnew.PLOT_FORMAT_LAST_FORMAT

PLOT_TEXT_MODE_STROKE = _pcbnew.PLOT_TEXT_MODE_STROKE

PLOT_TEXT_MODE_NATIVE = _pcbnew.PLOT_TEXT_MODE_NATIVE

PLOT_TEXT_MODE_PHANTOM = _pcbnew.PLOT_TEXT_MODE_PHANTOM

PLOT_TEXT_MODE_DEFAULT = _pcbnew.PLOT_TEXT_MODE_DEFAULT

PLOT_DASH_TYPE_DEFAULT = _pcbnew.PLOT_DASH_TYPE_DEFAULT

PLOT_DASH_TYPE_SOLID = _pcbnew.PLOT_DASH_TYPE_SOLID

PLOT_DASH_TYPE_FIRST_TYPE = _pcbnew.PLOT_DASH_TYPE_FIRST_TYPE

PLOT_DASH_TYPE_DASH = _pcbnew.PLOT_DASH_TYPE_DASH

PLOT_DASH_TYPE_DOT = _pcbnew.PLOT_DASH_TYPE_DOT

PLOT_DASH_TYPE_DASHDOT = _pcbnew.PLOT_DASH_TYPE_DASHDOT

PLOT_DASH_TYPE_LAST_TYPE = _pcbnew.PLOT_DASH_TYPE_LAST_TYPE

class PLOTTER(object):
    r"""Proxy of C++ PLOTTER 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
    DO_NOT_SET_LINE_WIDTH = _pcbnew.PLOTTER_DO_NOT_SET_LINE_WIDTH
    
    USE_DEFAULT_LINE_WIDTH = _pcbnew.PLOTTER_USE_DEFAULT_LINE_WIDTH
    
    __swig_destroy__ = _pcbnew.delete_PLOTTER

    def GetPlotterType(self) -> "PLOT_FORMAT":
        r"""GetPlotterType(PLOTTER self) -> PLOT_FORMAT"""
        return _pcbnew.PLOTTER_GetPlotterType(self)

    def StartPlot(self) -> "bool":
        r"""StartPlot(PLOTTER self) -> bool"""
        return _pcbnew.PLOTTER_StartPlot(self)

    def EndPlot(self) -> "bool":
        r"""EndPlot(PLOTTER self) -> bool"""
        return _pcbnew.PLOTTER_EndPlot(self)

    def SetNegative(self, aNegative: "bool") -> "void":
        r"""SetNegative(PLOTTER self, bool aNegative)"""
        return _pcbnew.PLOTTER_SetNegative(self, aNegative)

    def SetColorMode(self, aColorMode: "bool") -> "void":
        r"""SetColorMode(PLOTTER self, bool aColorMode)"""
        return _pcbnew.PLOTTER_SetColorMode(self, aColorMode)

    def GetColorMode(self) -> "bool":
        r"""GetColorMode(PLOTTER self) -> bool"""
        return _pcbnew.PLOTTER_GetColorMode(self)

    def SetRenderSettings(self, aSettings: "RENDER_SETTINGS *") -> "void":
        r"""SetRenderSettings(PLOTTER self, RENDER_SETTINGS * aSettings)"""
        return _pcbnew.PLOTTER_SetRenderSettings(self, aSettings)

    def RenderSettings(self) -> "RENDER_SETTINGS *":
        r"""RenderSettings(PLOTTER self) -> RENDER_SETTINGS *"""
        return _pcbnew.PLOTTER_RenderSettings(self)

    def SetPageSettings(self, aPageSettings: "PAGE_INFO const &") -> "void":
        r"""SetPageSettings(PLOTTER self, PAGE_INFO const & aPageSettings)"""
        return _pcbnew.PLOTTER_SetPageSettings(self, aPageSettings)

    def PageSettings(self) -> "PAGE_INFO &":
        r"""PageSettings(PLOTTER self) -> PAGE_INFO &"""
        return _pcbnew.PLOTTER_PageSettings(self)

    def SetCurrentLineWidth(self, width: "int", aData: "void *"=None) -> "void":
        r"""SetCurrentLineWidth(PLOTTER self, int width, void * aData=None)"""
        return _pcbnew.PLOTTER_SetCurrentLineWidth(self, width, aData)

    def GetCurrentLineWidth(self) -> "int":
        r"""GetCurrentLineWidth(PLOTTER self) -> int"""
        return _pcbnew.PLOTTER_GetCurrentLineWidth(self)

    def SetColor(self, color: "COLOR4D") -> "void":
        r"""SetColor(PLOTTER self, COLOR4D color)"""
        return _pcbnew.PLOTTER_SetColor(self, color)

    def SetDash(self, dashed: "PLOT_DASH_TYPE") -> "void":
        r"""SetDash(PLOTTER self, PLOT_DASH_TYPE dashed)"""
        return _pcbnew.PLOTTER_SetDash(self, dashed)

    def SetCreator(self, aCreator: "wxString") -> "void":
        r"""SetCreator(PLOTTER self, wxString aCreator)"""
        return _pcbnew.PLOTTER_SetCreator(self, aCreator)

    def SetTitle(self, aTitle: "wxString") -> "void":
        r"""SetTitle(PLOTTER self, wxString aTitle)"""
        return _pcbnew.PLOTTER_SetTitle(self, aTitle)

    def AddLineToHeader(self, aExtraString: "wxString") -> "void":
        r"""AddLineToHeader(PLOTTER self, wxString aExtraString)"""
        return _pcbnew.PLOTTER_AddLineToHeader(self, aExtraString)

    def ClearHeaderLinesList(self) -> "void":
        r"""ClearHeaderLinesList(PLOTTER self)"""
        return _pcbnew.PLOTTER_ClearHeaderLinesList(self)

    def SetViewport(self, aOffset: "wxPoint", aIusPerDecimil: "double", aScale: "double", aMirror: "bool") -> "void":
        r"""SetViewport(PLOTTER self, wxPoint aOffset, double aIusPerDecimil, double aScale, bool aMirror)"""
        return _pcbnew.PLOTTER_SetViewport(self, aOffset, aIusPerDecimil, aScale, aMirror)

    def OpenFile(self, aFullFilename: "wxString") -> "bool":
        r"""OpenFile(PLOTTER self, wxString aFullFilename) -> bool"""
        return _pcbnew.PLOTTER_OpenFile(self, aFullFilename)

    def GetIUsPerDecimil(self) -> "double":
        r"""GetIUsPerDecimil(PLOTTER self) -> double"""
        return _pcbnew.PLOTTER_GetIUsPerDecimil(self)

    def GetPlotterArcLowDef(self) -> "int":
        r"""GetPlotterArcLowDef(PLOTTER self) -> int"""
        return _pcbnew.PLOTTER_GetPlotterArcLowDef(self)

    def GetPlotterArcHighDef(self) -> "int":
        r"""GetPlotterArcHighDef(PLOTTER self) -> int"""
        return _pcbnew.PLOTTER_GetPlotterArcHighDef(self)

    def Rect(self, *args) -> "void":
        r"""Rect(PLOTTER self, wxPoint p1, wxPoint p2, FILL_T fill, int width=USE_DEFAULT_LINE_WIDTH)"""
        return _pcbnew.PLOTTER_Rect(self, *args)

    def Circle(self, *args) -> "void":
        r"""Circle(PLOTTER self, wxPoint pos, int diametre, FILL_T fill, int width=USE_DEFAULT_LINE_WIDTH)"""
        return _pcbnew.PLOTTER_Circle(self, *args)

    def Arc(self, *args) -> "void":
        r"""
        Arc(PLOTTER self, wxPoint centre, double StAngle, double EndAngle, int rayon, FILL_T fill, int width=USE_DEFAULT_LINE_WIDTH)
        Arc(PLOTTER self, SHAPE_ARC const & aArc)
        """
        return _pcbnew.PLOTTER_Arc(self, *args)

    def BezierCurve(self, *args) -> "void":
        r"""BezierCurve(PLOTTER self, wxPoint aStart, wxPoint aControl1, wxPoint aControl2, wxPoint aEnd, int aTolerance, int aLineThickness=USE_DEFAULT_LINE_WIDTH)"""
        return _pcbnew.PLOTTER_BezierCurve(self, *args)

    def PenTo(self, pos: "wxPoint", plume: "char") -> "void":
        r"""PenTo(PLOTTER self, wxPoint pos, char plume)"""
        return _pcbnew.PLOTTER_PenTo(self, pos, plume)

    def MoveTo(self, pos: "wxPoint") -> "void":
        r"""MoveTo(PLOTTER self, wxPoint pos)"""
        return _pcbnew.PLOTTER_MoveTo(self, pos)

    def LineTo(self, pos: "wxPoint") -> "void":
        r"""LineTo(PLOTTER self, wxPoint pos)"""
        return _pcbnew.PLOTTER_LineTo(self, pos)

    def FinishTo(self, pos: "wxPoint") -> "void":
        r"""FinishTo(PLOTTER self, wxPoint pos)"""
        return _pcbnew.PLOTTER_FinishTo(self, pos)

    def PenFinish(self) -> "void":
        r"""PenFinish(PLOTTER self)"""
        return _pcbnew.PLOTTER_PenFinish(self)

    def PlotPoly(self, *args) -> "void":
        r"""
        PlotPoly(PLOTTER self, wxPoint_Vector aCornerList, FILL_T aFill, int aWidth=USE_DEFAULT_LINE_WIDTH, void * aData=None)
        PlotPoly(PLOTTER self, SHAPE_LINE_CHAIN aCornerList, FILL_T aFill, int aWidth=USE_DEFAULT_LINE_WIDTH, void * aData=None)
        """
        return _pcbnew.PLOTTER_PlotPoly(self, *args)

    def PlotImage(self, aImage: "wxImage const &", aPos: "wxPoint", aScaleFactor: "double") -> "void":
        r"""PlotImage(PLOTTER self, wxImage const & aImage, wxPoint aPos, double aScaleFactor)"""
        return _pcbnew.PLOTTER_PlotImage(self, aImage, aPos, aScaleFactor)

    def ThickSegment(self, start: "wxPoint", end: "wxPoint", width: "int", tracemode: "OUTLINE_MODE", aData: "void *") -> "void":
        r"""ThickSegment(PLOTTER self, wxPoint start, wxPoint end, int width, OUTLINE_MODE tracemode, void * aData)"""
        return _pcbnew.PLOTTER_ThickSegment(self, start, end, width, tracemode, aData)

    def ThickArc(self, centre: "wxPoint", StAngle: "double", EndAngle: "double", rayon: "int", width: "int", tracemode: "OUTLINE_MODE", aData: "void *") -> "void":
        r"""ThickArc(PLOTTER self, wxPoint centre, double StAngle, double EndAngle, int rayon, int width, OUTLINE_MODE tracemode, void * aData)"""
        return _pcbnew.PLOTTER_ThickArc(self, centre, StAngle, EndAngle, rayon, width, tracemode, aData)

    def ThickRect(self, p1: "wxPoint", p2: "wxPoint", width: "int", tracemode: "OUTLINE_MODE", aData: "void *") -> "void":
        r"""ThickRect(PLOTTER self, wxPoint p1, wxPoint p2, int width, OUTLINE_MODE tracemode, void * aData)"""
        return _pcbnew.PLOTTER_ThickRect(self, p1, p2, width, tracemode, aData)

    def ThickCircle(self, pos: "wxPoint", diametre: "int", width: "int", tracemode: "OUTLINE_MODE", aData: "void *") -> "void":
        r"""ThickCircle(PLOTTER self, wxPoint pos, int diametre, int width, OUTLINE_MODE tracemode, void * aData)"""
        return _pcbnew.PLOTTER_ThickCircle(self, pos, diametre, width, tracemode, aData)

    def FilledCircle(self, pos: "wxPoint", diametre: "int", tracemode: "OUTLINE_MODE", aData: "void *") -> "void":
        r"""FilledCircle(PLOTTER self, wxPoint pos, int diametre, OUTLINE_MODE tracemode, void * aData)"""
        return _pcbnew.PLOTTER_FilledCircle(self, pos, diametre, tracemode, aData)

    def FlashPadCircle(self, aPadPos: "wxPoint", aDiameter: "int", aTraceMode: "OUTLINE_MODE", aData: "void *") -> "void":
        r"""FlashPadCircle(PLOTTER self, wxPoint aPadPos, int aDiameter, OUTLINE_MODE aTraceMode, void * aData)"""
        return _pcbnew.PLOTTER_FlashPadCircle(self, aPadPos, aDiameter, aTraceMode, aData)

    def FlashPadOval(self, aPadPos: "wxPoint", aSize: "wxSize", aPadOrient: "double", aTraceMode: "OUTLINE_MODE", aData: "void *") -> "void":
        r"""FlashPadOval(PLOTTER self, wxPoint aPadPos, wxSize aSize, double aPadOrient, OUTLINE_MODE aTraceMode, void * aData)"""
        return _pcbnew.PLOTTER_FlashPadOval(self, aPadPos, aSize, aPadOrient, aTraceMode, aData)

    def FlashPadRect(self, aPadPos: "wxPoint", aSize: "wxSize", aPadOrient: "double", aTraceMode: "OUTLINE_MODE", aData: "void *") -> "void":
        r"""FlashPadRect(PLOTTER self, wxPoint aPadPos, wxSize aSize, double aPadOrient, OUTLINE_MODE aTraceMode, void * aData)"""
        return _pcbnew.PLOTTER_FlashPadRect(self, aPadPos, aSize, aPadOrient, aTraceMode, aData)

    def FlashPadRoundRect(self, aPadPos: "wxPoint", aSize: "wxSize", aCornerRadius: "int", aOrient: "double", aTraceMode: "OUTLINE_MODE", aData: "void *") -> "void":
        r"""FlashPadRoundRect(PLOTTER self, wxPoint aPadPos, wxSize aSize, int aCornerRadius, double aOrient, OUTLINE_MODE aTraceMode, void * aData)"""
        return _pcbnew.PLOTTER_FlashPadRoundRect(self, aPadPos, aSize, aCornerRadius, aOrient, aTraceMode, aData)

    def FlashPadCustom(self, aPadPos: "wxPoint", aSize: "wxSize", aPadOrient: "double", aPolygons: "SHAPE_POLY_SET", aTraceMode: "OUTLINE_MODE", aData: "void *") -> "void":
        r"""FlashPadCustom(PLOTTER self, wxPoint aPadPos, wxSize aSize, double aPadOrient, SHAPE_POLY_SET aPolygons, OUTLINE_MODE aTraceMode, void * aData)"""
        return _pcbnew.PLOTTER_FlashPadCustom(self, aPadPos, aSize, aPadOrient, aPolygons, aTraceMode, aData)

    def FlashPadTrapez(self, aPadPos: "wxPoint", aCorners: "wxPoint", aPadOrient: "double", aTraceMode: "OUTLINE_MODE", aData: "void *") -> "void":
        r"""FlashPadTrapez(PLOTTER self, wxPoint aPadPos, wxPoint aCorners, double aPadOrient, OUTLINE_MODE aTraceMode, void * aData)"""
        return _pcbnew.PLOTTER_FlashPadTrapez(self, aPadPos, aCorners, aPadOrient, aTraceMode, aData)

    def FlashRegularPolygon(self, aShapePos: "wxPoint", aDiameter: "int", aCornerCount: "int", aOrient: "double", aTraceMode: "OUTLINE_MODE", aData: "void *") -> "void":
        r"""FlashRegularPolygon(PLOTTER self, wxPoint aShapePos, int aDiameter, int aCornerCount, double aOrient, OUTLINE_MODE aTraceMode, void * aData)"""
        return _pcbnew.PLOTTER_FlashRegularPolygon(self, aShapePos, aDiameter, aCornerCount, aOrient, aTraceMode, aData)

    def Text(self, aPos: "wxPoint", aColor: "COLOR4D", aText: "wxString", aOrient: "double", aSize: "wxSize", aH_justify: "enum EDA_TEXT_HJUSTIFY_T", aV_justify: "enum EDA_TEXT_VJUSTIFY_T", aWidth: "int", aItalic: "bool", aBold: "bool", aMultilineAllowed: "bool"=False, aData: "void *"=None) -> "void":
        r"""Text(PLOTTER self, wxPoint aPos, COLOR4D aColor, wxString aText, double aOrient, wxSize aSize, enum EDA_TEXT_HJUSTIFY_T aH_justify, enum EDA_TEXT_VJUSTIFY_T aV_justify, int aWidth, bool aItalic, bool aBold, bool aMultilineAllowed=False, void * aData=None)"""
        return _pcbnew.PLOTTER_Text(self, aPos, aColor, aText, aOrient, aSize, aH_justify, aV_justify, aWidth, aItalic, aBold, aMultilineAllowed, aData)
    MARKER_COUNT = _pcbnew.PLOTTER_MARKER_COUNT
    

    def Marker(self, position: "wxPoint", diametre: "int", aShapeId: "unsigned int") -> "void":
        r"""Marker(PLOTTER self, wxPoint position, int diametre, unsigned int aShapeId)"""
        return _pcbnew.PLOTTER_Marker(self, position, diametre, aShapeId)

    def SetLayerPolarity(self, aPositive: "bool") -> "void":
        r"""SetLayerPolarity(PLOTTER self, bool aPositive)"""
        return _pcbnew.PLOTTER_SetLayerPolarity(self, aPositive)

    def SetTextMode(self, mode: "PLOT_TEXT_MODE") -> "void":
        r"""SetTextMode(PLOTTER self, PLOT_TEXT_MODE mode)"""
        return _pcbnew.PLOTTER_SetTextMode(self, mode)

    def SetGerberCoordinatesFormat(self, aResolution: "int", aUseInches: "bool"=False) -> "void":
        r"""SetGerberCoordinatesFormat(PLOTTER self, int aResolution, bool aUseInches=False)"""
        return _pcbnew.PLOTTER_SetGerberCoordinatesFormat(self, aResolution, aUseInches)

    def SetSvgCoordinatesFormat(self, aResolution: "unsigned int", aUseInches: "bool"=False) -> "void":
        r"""SetSvgCoordinatesFormat(PLOTTER self, unsigned int aResolution, bool aUseInches=False)"""
        return _pcbnew.PLOTTER_SetSvgCoordinatesFormat(self, aResolution, aUseInches)

    def StartBlock(self, aData: "void *") -> "void":
        r"""StartBlock(PLOTTER self, void * aData)"""
        return _pcbnew.PLOTTER_StartBlock(self, aData)

    def EndBlock(self, aData: "void *") -> "void":
        r"""EndBlock(PLOTTER self, void * aData)"""
        return _pcbnew.PLOTTER_EndBlock(self, aData)

# Register PLOTTER in _pcbnew:
_pcbnew.PLOTTER_swigregister(PLOTTER)


def PlotDrawingSheet(*args) -> "void":
    r"""PlotDrawingSheet(PLOTTER plotter, PROJECT const * aProject, TITLE_BLOCK aTitleBlock, PAGE_INFO const & aPageInfo, wxString aSheetNumber, int aSheetCount, wxString aSheetDesc, wxString aFilename, COLOR4D aColor=COLOR4D::UNSPECIFIED, bool aIsFirstPage=True)"""
    return _pcbnew.PlotDrawingSheet(*args)

def GetDefaultPlotExtension(aFormat: "PLOT_FORMAT") -> "wxString":
    r"""GetDefaultPlotExtension(PLOT_FORMAT aFormat) -> wxString"""
    return _pcbnew.GetDefaultPlotExtension(aFormat)
class D356_RECORD(object):
    r"""Proxy of C++ D356_RECORD class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    smd = property(_pcbnew.D356_RECORD_smd_get, _pcbnew.D356_RECORD_smd_set, doc=r"""smd : bool""")
    hole = property(_pcbnew.D356_RECORD_hole_get, _pcbnew.D356_RECORD_hole_set, doc=r"""hole : bool""")
    netname = property(_pcbnew.D356_RECORD_netname_get, _pcbnew.D356_RECORD_netname_set, doc=r"""netname : wxString""")
    refdes = property(_pcbnew.D356_RECORD_refdes_get, _pcbnew.D356_RECORD_refdes_set, doc=r"""refdes : wxString""")
    pin = property(_pcbnew.D356_RECORD_pin_get, _pcbnew.D356_RECORD_pin_set, doc=r"""pin : wxString""")
    midpoint = property(_pcbnew.D356_RECORD_midpoint_get, _pcbnew.D356_RECORD_midpoint_set, doc=r"""midpoint : bool""")
    drill = property(_pcbnew.D356_RECORD_drill_get, _pcbnew.D356_RECORD_drill_set, doc=r"""drill : int""")
    mechanical = property(_pcbnew.D356_RECORD_mechanical_get, _pcbnew.D356_RECORD_mechanical_set, doc=r"""mechanical : bool""")
    access = property(_pcbnew.D356_RECORD_access_get, _pcbnew.D356_RECORD_access_set, doc=r"""access : int""")
    soldermask = property(_pcbnew.D356_RECORD_soldermask_get, _pcbnew.D356_RECORD_soldermask_set, doc=r"""soldermask : int""")
    x_location = property(_pcbnew.D356_RECORD_x_location_get, _pcbnew.D356_RECORD_x_location_set, doc=r"""x_location : int""")
    y_location = property(_pcbnew.D356_RECORD_y_location_get, _pcbnew.D356_RECORD_y_location_set, doc=r"""y_location : int""")
    x_size = property(_pcbnew.D356_RECORD_x_size_get, _pcbnew.D356_RECORD_x_size_set, doc=r"""x_size : int""")
    y_size = property(_pcbnew.D356_RECORD_y_size_get, _pcbnew.D356_RECORD_y_size_set, doc=r"""y_size : int""")
    rotation = property(_pcbnew.D356_RECORD_rotation_get, _pcbnew.D356_RECORD_rotation_set, doc=r"""rotation : int""")

    def __init__(self):
        r"""__init__(D356_RECORD self) -> D356_RECORD"""
        _pcbnew.D356_RECORD_swiginit(self, _pcbnew.new_D356_RECORD())
    __swig_destroy__ = _pcbnew.delete_D356_RECORD

# Register D356_RECORD in _pcbnew:
_pcbnew.D356_RECORD_swigregister(D356_RECORD)

class IPC356D_WRITER(object):
    r"""Proxy of C++ IPC356D_WRITER 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, aPcb: "BOARD", aParent: "wxWindow *"=None):
        r"""__init__(IPC356D_WRITER self, BOARD aPcb, wxWindow * aParent=None) -> IPC356D_WRITER"""
        _pcbnew.IPC356D_WRITER_swiginit(self, _pcbnew.new_IPC356D_WRITER(aPcb, aParent))
    __swig_destroy__ = _pcbnew.delete_IPC356D_WRITER

    def Write(self, aFilename: "wxString") -> "void":
        r"""Write(IPC356D_WRITER self, wxString aFilename)"""
        return _pcbnew.IPC356D_WRITER_Write(self, aFilename)

# Register IPC356D_WRITER in _pcbnew:
_pcbnew.IPC356D_WRITER_swigregister(IPC356D_WRITER)

class PLACE_FILE_EXPORTER(object):
    r"""Proxy of C++ PLACE_FILE_EXPORTER 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, aBoard: "BOARD", aUnitsMM: "bool", aOnlySMD: "bool", aExcludeAllTH: "bool", aTopSide: "bool", aBottomSide: "bool", aFormatCSV: "bool", aUseAuxOrigin: "bool"):
        r"""__init__(PLACE_FILE_EXPORTER self, BOARD aBoard, bool aUnitsMM, bool aOnlySMD, bool aExcludeAllTH, bool aTopSide, bool aBottomSide, bool aFormatCSV, bool aUseAuxOrigin) -> PLACE_FILE_EXPORTER"""
        _pcbnew.PLACE_FILE_EXPORTER_swiginit(self, _pcbnew.new_PLACE_FILE_EXPORTER(aBoard, aUnitsMM, aOnlySMD, aExcludeAllTH, aTopSide, aBottomSide, aFormatCSV, aUseAuxOrigin))

    def GenPositionData(self) -> "std::string":
        r"""GenPositionData(PLACE_FILE_EXPORTER self) -> string"""
        return _pcbnew.PLACE_FILE_EXPORTER_GenPositionData(self)

    def GenReportData(self) -> "std::string":
        r"""GenReportData(PLACE_FILE_EXPORTER self) -> string"""
        return _pcbnew.PLACE_FILE_EXPORTER_GenReportData(self)

    def GetFootprintCount(self) -> "int":
        r"""GetFootprintCount(PLACE_FILE_EXPORTER self) -> int"""
        return _pcbnew.PLACE_FILE_EXPORTER_GetFootprintCount(self)

    @staticmethod
    def GetFrontSideName() -> "std::string":
        r"""GetFrontSideName() -> string"""
        return _pcbnew.PLACE_FILE_EXPORTER_GetFrontSideName()

    @staticmethod
    def GetBackSideName() -> "std::string":
        r"""GetBackSideName() -> string"""
        return _pcbnew.PLACE_FILE_EXPORTER_GetBackSideName()
    __swig_destroy__ = _pcbnew.delete_PLACE_FILE_EXPORTER

# Register PLACE_FILE_EXPORTER in _pcbnew:
_pcbnew.PLACE_FILE_EXPORTER_swigregister(PLACE_FILE_EXPORTER)

def PLACE_FILE_EXPORTER_GetFrontSideName() -> "std::string":
    r"""PLACE_FILE_EXPORTER_GetFrontSideName() -> string"""
    return _pcbnew.PLACE_FILE_EXPORTER_GetFrontSideName()

def PLACE_FILE_EXPORTER_GetBackSideName() -> "std::string":
    r"""PLACE_FILE_EXPORTER_GetBackSideName() -> string"""
    return _pcbnew.PLACE_FILE_EXPORTER_GetBackSideName()

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

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

    def ExportVRML_File(self, aFullFileName: "wxString", aMMtoWRMLunit: "double", aExport3DFiles: "bool", aUseRelativePaths: "bool", a3D_Subdir: "wxString", aXRef: "double", aYRef: "double") -> "bool":
        r"""ExportVRML_File(VRML_WRITER self, wxString aFullFileName, double aMMtoWRMLunit, bool aExport3DFiles, bool aUseRelativePaths, wxString a3D_Subdir, double aXRef, double aYRef) -> bool"""
        return _pcbnew.VRML_WRITER_ExportVRML_File(self, aFullFileName, aMMtoWRMLunit, aExport3DFiles, aUseRelativePaths, a3D_Subdir, aXRef, aYRef)

    def __init__(self):
        r"""__init__(VRML_WRITER self) -> VRML_WRITER"""
        _pcbnew.VRML_WRITER_swiginit(self, _pcbnew.new_VRML_WRITER())
    __swig_destroy__ = _pcbnew.delete_VRML_WRITER

# Register VRML_WRITER in _pcbnew:
_pcbnew.VRML_WRITER_swigregister(VRML_WRITER)

USE_ATTRIB_FOR_HOLES = _pcbnew.USE_ATTRIB_FOR_HOLES

HOLE_ATTRIBUTE_HOLE_UNKNOWN = _pcbnew.HOLE_ATTRIBUTE_HOLE_UNKNOWN

HOLE_ATTRIBUTE_HOLE_VIA_THROUGH = _pcbnew.HOLE_ATTRIBUTE_HOLE_VIA_THROUGH

HOLE_ATTRIBUTE_HOLE_VIA_BURIED = _pcbnew.HOLE_ATTRIBUTE_HOLE_VIA_BURIED

HOLE_ATTRIBUTE_HOLE_PAD = _pcbnew.HOLE_ATTRIBUTE_HOLE_PAD

HOLE_ATTRIBUTE_HOLE_MECHANICAL = _pcbnew.HOLE_ATTRIBUTE_HOLE_MECHANICAL

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    m_Diameter = property(_pcbnew.DRILL_TOOL_m_Diameter_get, _pcbnew.DRILL_TOOL_m_Diameter_set, doc=r"""m_Diameter : int""")
    m_TotalCount = property(_pcbnew.DRILL_TOOL_m_TotalCount_get, _pcbnew.DRILL_TOOL_m_TotalCount_set, doc=r"""m_TotalCount : int""")
    m_OvalCount = property(_pcbnew.DRILL_TOOL_m_OvalCount_get, _pcbnew.DRILL_TOOL_m_OvalCount_set, doc=r"""m_OvalCount : int""")
    m_Hole_NotPlated = property(_pcbnew.DRILL_TOOL_m_Hole_NotPlated_get, _pcbnew.DRILL_TOOL_m_Hole_NotPlated_set, doc=r"""m_Hole_NotPlated : bool""")
    m_HoleAttribute = property(_pcbnew.DRILL_TOOL_m_HoleAttribute_get, _pcbnew.DRILL_TOOL_m_HoleAttribute_set, doc=r"""m_HoleAttribute : HOLE_ATTRIBUTE""")

    def __init__(self, aDiameter: "int", a_NotPlated: "bool"):
        r"""__init__(DRILL_TOOL self, int aDiameter, bool a_NotPlated) -> DRILL_TOOL"""
        _pcbnew.DRILL_TOOL_swiginit(self, _pcbnew.new_DRILL_TOOL(aDiameter, a_NotPlated))
    __swig_destroy__ = _pcbnew.delete_DRILL_TOOL

# Register DRILL_TOOL in _pcbnew:
_pcbnew.DRILL_TOOL_swigregister(DRILL_TOOL)

class HOLE_INFO(object):
    r"""Proxy of C++ HOLE_INFO 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__(HOLE_INFO self) -> HOLE_INFO"""
        _pcbnew.HOLE_INFO_swiginit(self, _pcbnew.new_HOLE_INFO())
    m_ItemParent = property(_pcbnew.HOLE_INFO_m_ItemParent_get, _pcbnew.HOLE_INFO_m_ItemParent_set, doc=r"""m_ItemParent : p.BOARD_ITEM""")
    m_Hole_Diameter = property(_pcbnew.HOLE_INFO_m_Hole_Diameter_get, _pcbnew.HOLE_INFO_m_Hole_Diameter_set, doc=r"""m_Hole_Diameter : int""")
    m_Tool_Reference = property(_pcbnew.HOLE_INFO_m_Tool_Reference_get, _pcbnew.HOLE_INFO_m_Tool_Reference_set, doc=r"""m_Tool_Reference : int""")
    m_Hole_Size = property(_pcbnew.HOLE_INFO_m_Hole_Size_get, _pcbnew.HOLE_INFO_m_Hole_Size_set, doc=r"""m_Hole_Size : wxSize""")
    m_Hole_Orient = property(_pcbnew.HOLE_INFO_m_Hole_Orient_get, _pcbnew.HOLE_INFO_m_Hole_Orient_set, doc=r"""m_Hole_Orient : double""")
    m_Hole_Shape = property(_pcbnew.HOLE_INFO_m_Hole_Shape_get, _pcbnew.HOLE_INFO_m_Hole_Shape_set, doc=r"""m_Hole_Shape : int""")
    m_Hole_Pos = property(_pcbnew.HOLE_INFO_m_Hole_Pos_get, _pcbnew.HOLE_INFO_m_Hole_Pos_set, doc=r"""m_Hole_Pos : wxPoint""")
    m_Hole_Bottom_Layer = property(_pcbnew.HOLE_INFO_m_Hole_Bottom_Layer_get, _pcbnew.HOLE_INFO_m_Hole_Bottom_Layer_set, doc=r"""m_Hole_Bottom_Layer : PCB_LAYER_ID""")
    m_Hole_Top_Layer = property(_pcbnew.HOLE_INFO_m_Hole_Top_Layer_get, _pcbnew.HOLE_INFO_m_Hole_Top_Layer_set, doc=r"""m_Hole_Top_Layer : PCB_LAYER_ID""")
    m_Hole_NotPlated = property(_pcbnew.HOLE_INFO_m_Hole_NotPlated_get, _pcbnew.HOLE_INFO_m_Hole_NotPlated_set, doc=r"""m_Hole_NotPlated : bool""")
    m_HoleAttribute = property(_pcbnew.HOLE_INFO_m_HoleAttribute_get, _pcbnew.HOLE_INFO_m_HoleAttribute_set, doc=r"""m_HoleAttribute : HOLE_ATTRIBUTE""")
    __swig_destroy__ = _pcbnew.delete_HOLE_INFO

# Register HOLE_INFO in _pcbnew:
_pcbnew.HOLE_INFO_swigregister(HOLE_INFO)

class DRILL_PRECISION(object):
    r"""Proxy of C++ DRILL_PRECISION 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, l: "int"=2, r: "int"=4):
        r"""__init__(DRILL_PRECISION self, int l=2, int r=4) -> DRILL_PRECISION"""
        _pcbnew.DRILL_PRECISION_swiginit(self, _pcbnew.new_DRILL_PRECISION(l, r))

    def GetPrecisionString(self) -> "wxString":
        r"""GetPrecisionString(DRILL_PRECISION self) -> wxString"""
        return _pcbnew.DRILL_PRECISION_GetPrecisionString(self)
    m_Lhs = property(_pcbnew.DRILL_PRECISION_m_Lhs_get, _pcbnew.DRILL_PRECISION_m_Lhs_set, doc=r"""m_Lhs : int""")
    m_Rhs = property(_pcbnew.DRILL_PRECISION_m_Rhs_get, _pcbnew.DRILL_PRECISION_m_Rhs_set, doc=r"""m_Rhs : int""")
    __swig_destroy__ = _pcbnew.delete_DRILL_PRECISION

# Register DRILL_PRECISION in _pcbnew:
_pcbnew.DRILL_PRECISION_swigregister(DRILL_PRECISION)

class GENDRILL_WRITER_BASE(object):
    r"""Proxy of C++ GENDRILL_WRITER_BASE 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
    DECIMAL_FORMAT = _pcbnew.GENDRILL_WRITER_BASE_DECIMAL_FORMAT
    
    SUPPRESS_LEADING = _pcbnew.GENDRILL_WRITER_BASE_SUPPRESS_LEADING
    
    SUPPRESS_TRAILING = _pcbnew.GENDRILL_WRITER_BASE_SUPPRESS_TRAILING
    
    KEEP_ZEROS = _pcbnew.GENDRILL_WRITER_BASE_KEEP_ZEROS
    
    PTH_FILE = _pcbnew.GENDRILL_WRITER_BASE_PTH_FILE
    
    NPTH_FILE = _pcbnew.GENDRILL_WRITER_BASE_NPTH_FILE
    
    MIXED_FILE = _pcbnew.GENDRILL_WRITER_BASE_MIXED_FILE
    
    __swig_destroy__ = _pcbnew.delete_GENDRILL_WRITER_BASE

    def SetMergeOption(self, aMerge: "bool") -> "void":
        r"""SetMergeOption(GENDRILL_WRITER_BASE self, bool aMerge)"""
        return _pcbnew.GENDRILL_WRITER_BASE_SetMergeOption(self, aMerge)

    def GetOffset(self) -> "wxPoint":
        r"""GetOffset(GENDRILL_WRITER_BASE self) -> wxPoint"""
        return _pcbnew.GENDRILL_WRITER_BASE_GetOffset(self)

    def SetPageInfo(self, aPageInfo: "PAGE_INFO const *") -> "void":
        r"""SetPageInfo(GENDRILL_WRITER_BASE self, PAGE_INFO const * aPageInfo)"""
        return _pcbnew.GENDRILL_WRITER_BASE_SetPageInfo(self, aPageInfo)

    def SetMapFileFormat(self, aMapFmt: "PLOT_FORMAT") -> "void":
        r"""SetMapFileFormat(GENDRILL_WRITER_BASE self, PLOT_FORMAT aMapFmt)"""
        return _pcbnew.GENDRILL_WRITER_BASE_SetMapFileFormat(self, aMapFmt)

    def CreateMapFilesSet(self, aPlotDirectory: "wxString", aReporter: "REPORTER *"=None) -> "void":
        r"""CreateMapFilesSet(GENDRILL_WRITER_BASE self, wxString aPlotDirectory, REPORTER * aReporter=None)"""
        return _pcbnew.GENDRILL_WRITER_BASE_CreateMapFilesSet(self, aPlotDirectory, aReporter)

    def GenDrillReportFile(self, aFullFileName: "wxString") -> "bool":
        r"""GenDrillReportFile(GENDRILL_WRITER_BASE self, wxString aFullFileName) -> bool"""
        return _pcbnew.GENDRILL_WRITER_BASE_GenDrillReportFile(self, aFullFileName)

# Register GENDRILL_WRITER_BASE in _pcbnew:
_pcbnew.GENDRILL_WRITER_BASE_swigregister(GENDRILL_WRITER_BASE)

class EXCELLON_WRITER(GENDRILL_WRITER_BASE):
    r"""Proxy of C++ EXCELLON_WRITER 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, aPcb: "BOARD"):
        r"""__init__(EXCELLON_WRITER self, BOARD aPcb) -> EXCELLON_WRITER"""
        _pcbnew.EXCELLON_WRITER_swiginit(self, _pcbnew.new_EXCELLON_WRITER(aPcb))
    __swig_destroy__ = _pcbnew.delete_EXCELLON_WRITER

    def GetOffset(self) -> "wxPoint":
        r"""GetOffset(EXCELLON_WRITER self) -> wxPoint"""
        return _pcbnew.EXCELLON_WRITER_GetOffset(self)

    def SetRouteModeForOvalHoles(self, aUseRouteModeForOvalHoles: "bool") -> "void":
        r"""SetRouteModeForOvalHoles(EXCELLON_WRITER self, bool aUseRouteModeForOvalHoles)"""
        return _pcbnew.EXCELLON_WRITER_SetRouteModeForOvalHoles(self, aUseRouteModeForOvalHoles)

    def SetFormat(self, *args) -> "void":
        r"""SetFormat(EXCELLON_WRITER self, bool aMetric, GENDRILL_WRITER_BASE::ZEROS_FMT aZerosFmt=DECIMAL_FORMAT, int aLeftDigits=0, int aRightDigits=0)"""
        return _pcbnew.EXCELLON_WRITER_SetFormat(self, *args)

    def SetOptions(self, aMirror: "bool", aMinimalHeader: "bool", aOffset: "wxPoint", aMerge_PTH_NPTH: "bool") -> "void":
        r"""SetOptions(EXCELLON_WRITER self, bool aMirror, bool aMinimalHeader, wxPoint aOffset, bool aMerge_PTH_NPTH)"""
        return _pcbnew.EXCELLON_WRITER_SetOptions(self, aMirror, aMinimalHeader, aOffset, aMerge_PTH_NPTH)

    def CreateDrillandMapFilesSet(self, aPlotDirectory: "wxString", aGenDrill: "bool", aGenMap: "bool", aReporter: "REPORTER *"=None) -> "void":
        r"""CreateDrillandMapFilesSet(EXCELLON_WRITER self, wxString aPlotDirectory, bool aGenDrill, bool aGenMap, REPORTER * aReporter=None)"""
        return _pcbnew.EXCELLON_WRITER_CreateDrillandMapFilesSet(self, aPlotDirectory, aGenDrill, aGenMap, aReporter)

# Register EXCELLON_WRITER in _pcbnew:
_pcbnew.EXCELLON_WRITER_swigregister(EXCELLON_WRITER)

class GERBER_WRITER(GENDRILL_WRITER_BASE):
    r"""Proxy of C++ GERBER_WRITER 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, aPcb: "BOARD"):
        r"""__init__(GERBER_WRITER self, BOARD aPcb) -> GERBER_WRITER"""
        _pcbnew.GERBER_WRITER_swiginit(self, _pcbnew.new_GERBER_WRITER(aPcb))
    __swig_destroy__ = _pcbnew.delete_GERBER_WRITER

    def SetFormat(self, aRightDigits: "int"=6) -> "void":
        r"""SetFormat(GERBER_WRITER self, int aRightDigits=6)"""
        return _pcbnew.GERBER_WRITER_SetFormat(self, aRightDigits)

    def SetOptions(self, aOffset: "wxPoint") -> "void":
        r"""SetOptions(GERBER_WRITER self, wxPoint aOffset)"""
        return _pcbnew.GERBER_WRITER_SetOptions(self, aOffset)

    def CreateDrillandMapFilesSet(self, aPlotDirectory: "wxString", aGenDrill: "bool", aGenMap: "bool", aReporter: "REPORTER *"=None) -> "void":
        r"""CreateDrillandMapFilesSet(GERBER_WRITER self, wxString aPlotDirectory, bool aGenDrill, bool aGenMap, REPORTER * aReporter=None)"""
        return _pcbnew.GERBER_WRITER_CreateDrillandMapFilesSet(self, aPlotDirectory, aGenDrill, aGenMap, aReporter)

# Register GERBER_WRITER in _pcbnew:
_pcbnew.GERBER_WRITER_swigregister(GERBER_WRITER)

SIDE_NONE = _pcbnew.SIDE_NONE

SIDE_TOP = _pcbnew.SIDE_TOP

SIDE_BOTTOM = _pcbnew.SIDE_BOTTOM

SIDE_BOTH = _pcbnew.SIDE_BOTH

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    m_GerberFileList = property(_pcbnew.JOBFILE_PARAMS_m_GerberFileList_get, _pcbnew.JOBFILE_PARAMS_m_GerberFileList_set, doc=r"""m_GerberFileList : wxArrayString""")
    m_LayerId = property(_pcbnew.JOBFILE_PARAMS_m_LayerId_get, _pcbnew.JOBFILE_PARAMS_m_LayerId_set, doc=r"""m_LayerId : std::vector<(PCB_LAYER_ID,std::allocator<(PCB_LAYER_ID)>)>""")

    def __init__(self):
        r"""__init__(JOBFILE_PARAMS self) -> JOBFILE_PARAMS"""
        _pcbnew.JOBFILE_PARAMS_swiginit(self, _pcbnew.new_JOBFILE_PARAMS())
    __swig_destroy__ = _pcbnew.delete_JOBFILE_PARAMS

# Register JOBFILE_PARAMS in _pcbnew:
_pcbnew.JOBFILE_PARAMS_swigregister(JOBFILE_PARAMS)

class GERBER_JOBFILE_WRITER(object):
    r"""Proxy of C++ GERBER_JOBFILE_WRITER 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, aPcb: "BOARD", aReporter: "REPORTER *"=None):
        r"""__init__(GERBER_JOBFILE_WRITER self, BOARD aPcb, REPORTER * aReporter=None) -> GERBER_JOBFILE_WRITER"""
        _pcbnew.GERBER_JOBFILE_WRITER_swiginit(self, _pcbnew.new_GERBER_JOBFILE_WRITER(aPcb, aReporter))
    __swig_destroy__ = _pcbnew.delete_GERBER_JOBFILE_WRITER

    def AddGbrFile(self, aLayer: "PCB_LAYER_ID", aFilename: "wxString") -> "void":
        r"""AddGbrFile(GERBER_JOBFILE_WRITER self, PCB_LAYER_ID aLayer, wxString aFilename)"""
        return _pcbnew.GERBER_JOBFILE_WRITER_AddGbrFile(self, aLayer, aFilename)

    def CreateJobFile(self, aFullFilename: "wxString") -> "bool":
        r"""CreateJobFile(GERBER_JOBFILE_WRITER self, wxString aFullFilename) -> bool"""
        return _pcbnew.GERBER_JOBFILE_WRITER_CreateJobFile(self, aFullFilename)

    def WriteJSONJobFile(self, aFullFilename: "wxString") -> "bool":
        r"""WriteJSONJobFile(GERBER_JOBFILE_WRITER self, wxString aFullFilename) -> bool"""
        return _pcbnew.GERBER_JOBFILE_WRITER_WriteJSONJobFile(self, aFullFilename)

# Register GERBER_JOBFILE_WRITER in _pcbnew:
_pcbnew.GERBER_JOBFILE_WRITER_swigregister(GERBER_JOBFILE_WRITER)

ROOM_FOR_KICADMANAGER = _pcbnew.ROOM_FOR_KICADMANAGER

ROOM_FOR_3D_VIEWER = _pcbnew.ROOM_FOR_3D_VIEWER

ROOM_FOR_PANEL_PREV_MODEL = _pcbnew.ROOM_FOR_PANEL_PREV_MODEL

DEFAULT_FILE_HISTORY_SIZE = _pcbnew.DEFAULT_FILE_HISTORY_SIZE

MAX_FILE_HISTORY_SIZE = _pcbnew.MAX_FILE_HISTORY_SIZE

ID_RUN_PCB = _pcbnew.ID_RUN_PCB

ID_APPEND_PROJECT = _pcbnew.ID_APPEND_PROJECT

ID_LOAD_FILE = _pcbnew.ID_LOAD_FILE

ID_NEW_BOARD = _pcbnew.ID_NEW_BOARD

ID_SAVE_BOARD = _pcbnew.ID_SAVE_BOARD

ID_SAVE_BOARD_AS = _pcbnew.ID_SAVE_BOARD_AS

ID_AUTO_SAVE_TIMER = _pcbnew.ID_AUTO_SAVE_TIMER

ID_FILE = _pcbnew.ID_FILE

ID_FILE1 = _pcbnew.ID_FILE1

ID_FILEMAX = _pcbnew.ID_FILEMAX

ID_FILE_LIST_EMPTY = _pcbnew.ID_FILE_LIST_EMPTY

ID_FILE_LIST_CLEAR = _pcbnew.ID_FILE_LIST_CLEAR

ID_PREFERENCES_HOTKEY_SHOW_CURRENT_LIST = _pcbnew.ID_PREFERENCES_HOTKEY_SHOW_CURRENT_LIST

ID_PREFERENCES_CONFIGURE_PATHS = _pcbnew.ID_PREFERENCES_CONFIGURE_PATHS

ID_EDIT_SYMBOL_LIBRARY_TABLE = _pcbnew.ID_EDIT_SYMBOL_LIBRARY_TABLE

ID_EDIT_FOOTPRINT_LIBRARY_TABLE = _pcbnew.ID_EDIT_FOOTPRINT_LIBRARY_TABLE

ID_GEN_PLOT = _pcbnew.ID_GEN_PLOT

ID_GEN_PLOT_PS = _pcbnew.ID_GEN_PLOT_PS

ID_GEN_PLOT_HPGL = _pcbnew.ID_GEN_PLOT_HPGL

ID_GEN_PLOT_GERBER = _pcbnew.ID_GEN_PLOT_GERBER

ID_GEN_PLOT_SVG = _pcbnew.ID_GEN_PLOT_SVG

ID_GEN_PLOT_DXF = _pcbnew.ID_GEN_PLOT_DXF

ID_GEN_PLOT_PDF = _pcbnew.ID_GEN_PLOT_PDF

ID_GEN_EXPORT_FILE = _pcbnew.ID_GEN_EXPORT_FILE

ID_GEN_IMPORT_FILE = _pcbnew.ID_GEN_IMPORT_FILE

ID_H_TOOLBAR = _pcbnew.ID_H_TOOLBAR

ID_V_TOOLBAR = _pcbnew.ID_V_TOOLBAR

ID_OPT_TOOLBAR = _pcbnew.ID_OPT_TOOLBAR

ID_AUX_TOOLBAR = _pcbnew.ID_AUX_TOOLBAR

ID_EDIT_HOTKEY = _pcbnew.ID_EDIT_HOTKEY

ID_NO_TOOL_SELECTED = _pcbnew.ID_NO_TOOL_SELECTED

ID_LANGUAGE_CHOICE = _pcbnew.ID_LANGUAGE_CHOICE

ID_LANGUAGE_DANISH = _pcbnew.ID_LANGUAGE_DANISH

ID_LANGUAGE_DEFAULT = _pcbnew.ID_LANGUAGE_DEFAULT

ID_LANGUAGE_ENGLISH = _pcbnew.ID_LANGUAGE_ENGLISH

ID_LANGUAGE_FRENCH = _pcbnew.ID_LANGUAGE_FRENCH

ID_LANGUAGE_FINNISH = _pcbnew.ID_LANGUAGE_FINNISH

ID_LANGUAGE_SPANISH = _pcbnew.ID_LANGUAGE_SPANISH

ID_LANGUAGE_SPANISH_MEXICAN = _pcbnew.ID_LANGUAGE_SPANISH_MEXICAN

ID_LANGUAGE_GERMAN = _pcbnew.ID_LANGUAGE_GERMAN

ID_LANGUAGE_GREEK = _pcbnew.ID_LANGUAGE_GREEK

ID_LANGUAGE_NORWEGIAN = _pcbnew.ID_LANGUAGE_NORWEGIAN

ID_LANGUAGE_RUSSIAN = _pcbnew.ID_LANGUAGE_RUSSIAN

ID_LANGUAGE_PORTUGUESE = _pcbnew.ID_LANGUAGE_PORTUGUESE

ID_LANGUAGE_PORTUGUESE_BRAZILIAN = _pcbnew.ID_LANGUAGE_PORTUGUESE_BRAZILIAN

ID_LANGUAGE_TURKISH = _pcbnew.ID_LANGUAGE_TURKISH

ID_LANGUAGE_INDONESIAN = _pcbnew.ID_LANGUAGE_INDONESIAN

ID_LANGUAGE_ITALIAN = _pcbnew.ID_LANGUAGE_ITALIAN

ID_LANGUAGE_SLOVENIAN = _pcbnew.ID_LANGUAGE_SLOVENIAN

ID_LANGUAGE_SLOVAK = _pcbnew.ID_LANGUAGE_SLOVAK

ID_LANGUAGE_HUNGARIAN = _pcbnew.ID_LANGUAGE_HUNGARIAN

ID_LANGUAGE_POLISH = _pcbnew.ID_LANGUAGE_POLISH

ID_LANGUAGE_CZECH = _pcbnew.ID_LANGUAGE_CZECH

ID_LANGUAGE_KOREAN = _pcbnew.ID_LANGUAGE_KOREAN

ID_LANGUAGE_CATALAN = _pcbnew.ID_LANGUAGE_CATALAN

ID_LANGUAGE_CHINESE_SIMPLIFIED = _pcbnew.ID_LANGUAGE_CHINESE_SIMPLIFIED

ID_LANGUAGE_CHINESE_TRADITIONAL = _pcbnew.ID_LANGUAGE_CHINESE_TRADITIONAL

ID_LANGUAGE_DUTCH = _pcbnew.ID_LANGUAGE_DUTCH

ID_LANGUAGE_JAPANESE = _pcbnew.ID_LANGUAGE_JAPANESE

ID_LANGUAGE_BULGARIAN = _pcbnew.ID_LANGUAGE_BULGARIAN

ID_LANGUAGE_LATVIAN = _pcbnew.ID_LANGUAGE_LATVIAN

ID_LANGUAGE_LITHUANIAN = _pcbnew.ID_LANGUAGE_LITHUANIAN

ID_LANGUAGE_VIETNAMESE = _pcbnew.ID_LANGUAGE_VIETNAMESE

ID_LANGUAGE_SERBIAN = _pcbnew.ID_LANGUAGE_SERBIAN

ID_LANGUAGE_THAI = _pcbnew.ID_LANGUAGE_THAI

ID_LANGUAGE_SWEDISH = _pcbnew.ID_LANGUAGE_SWEDISH

ID_LANGUAGE_CHOICE_END = _pcbnew.ID_LANGUAGE_CHOICE_END

ID_ON_ZOOM_SELECT = _pcbnew.ID_ON_ZOOM_SELECT

ID_POPUP_ZOOM_START_RANGE = _pcbnew.ID_POPUP_ZOOM_START_RANGE

ID_POPUP_CANCEL = _pcbnew.ID_POPUP_CANCEL

ID_POPUP_ZOOM_IN = _pcbnew.ID_POPUP_ZOOM_IN

ID_POPUP_ZOOM_OUT = _pcbnew.ID_POPUP_ZOOM_OUT

ID_POPUP_ZOOM_SELECT = _pcbnew.ID_POPUP_ZOOM_SELECT

ID_POPUP_ZOOM_CENTER = _pcbnew.ID_POPUP_ZOOM_CENTER

ID_POPUP_ZOOM_PAGE = _pcbnew.ID_POPUP_ZOOM_PAGE

ID_POPUP_ZOOM_REDRAW = _pcbnew.ID_POPUP_ZOOM_REDRAW

ID_POPUP_ZOOM_LEVEL_START = _pcbnew.ID_POPUP_ZOOM_LEVEL_START

ID_POPUP_ZOOM_LEVEL_END = _pcbnew.ID_POPUP_ZOOM_LEVEL_END

ID_POPUP_GRID_START = _pcbnew.ID_POPUP_GRID_START

ID_POPUP_GRID_END = _pcbnew.ID_POPUP_GRID_END

ID_ON_GRID_SELECT = _pcbnew.ID_ON_GRID_SELECT

ID_GRID_SETTINGS = _pcbnew.ID_GRID_SETTINGS

ID_ZOOM_BEGIN = _pcbnew.ID_ZOOM_BEGIN

ID_VIEWER_ZOOM_IN = _pcbnew.ID_VIEWER_ZOOM_IN

ID_VIEWER_ZOOM_OUT = _pcbnew.ID_VIEWER_ZOOM_OUT

ID_VIEWER_ZOOM_PAGE = _pcbnew.ID_VIEWER_ZOOM_PAGE

ID_VIEWER_ZOOM_REDRAW = _pcbnew.ID_VIEWER_ZOOM_REDRAW

ID_OFFCENTER_ZOOM_IN = _pcbnew.ID_OFFCENTER_ZOOM_IN

ID_OFFCENTER_ZOOM_OUT = _pcbnew.ID_OFFCENTER_ZOOM_OUT

ID_ZOOM_END = _pcbnew.ID_ZOOM_END

ID_EDA_SOCKET_EVENT_SERV = _pcbnew.ID_EDA_SOCKET_EVENT_SERV

ID_EDA_SOCKET_EVENT = _pcbnew.ID_EDA_SOCKET_EVENT

ID_KICAD_MANAGER_START = _pcbnew.ID_KICAD_MANAGER_START

ID_KICAD_MANAGER_END = _pcbnew.ID_KICAD_MANAGER_END

ID_KICAD_3D_VIEWER_START = _pcbnew.ID_KICAD_3D_VIEWER_START

ID_KICAD_3D_VIEWER_END = _pcbnew.ID_KICAD_3D_VIEWER_END

ID_KICAD_PANEL_PREV_MODEL_START = _pcbnew.ID_KICAD_PANEL_PREV_MODEL_START

ID_KICAD_PANEL_PREV_MODEL_END = _pcbnew.ID_KICAD_PANEL_PREV_MODEL_END

ID_POPUP_MENU_START = _pcbnew.ID_POPUP_MENU_START

ID_POPUP_MENU_END = _pcbnew.ID_POPUP_MENU_END

ID_END_LIST = _pcbnew.ID_END_LIST


def GetBoard() -> "BOARD *":
    r"""GetBoard() -> BOARD"""
    return _pcbnew.GetBoard()

def LoadBoard(*args) -> "BOARD *":
    r"""
    LoadBoard(wxString aFileName, IO_MGR::PCB_FILE_T aFormat) -> BOARD
    LoadBoard(wxString aFileName) -> BOARD
    """
    return _pcbnew.LoadBoard(*args)

def NewBoard(aFileName: "wxString") -> "BOARD *":
    r"""NewBoard(wxString aFileName) -> BOARD"""
    return _pcbnew.NewBoard(aFileName)

def GetSettingsManager() -> "SETTINGS_MANAGER *":
    r"""GetSettingsManager() -> SETTINGS_MANAGER"""
    return _pcbnew.GetSettingsManager()

def CreateEmptyBoard() -> "BOARD *":
    r"""CreateEmptyBoard() -> BOARD"""
    return _pcbnew.CreateEmptyBoard()

def SaveBoard(aFileName: "wxString", aBoard: "BOARD") -> "bool":
    r"""SaveBoard(wxString aFileName, BOARD aBoard) -> bool"""
    return _pcbnew.SaveBoard(aFileName, aBoard)

def GetFootprintLibraries() -> "wxArrayString":
    r"""GetFootprintLibraries() -> wxArrayString"""
    return _pcbnew.GetFootprintLibraries()

def GetFootprints(aNickName: "wxString") -> "wxArrayString":
    r"""GetFootprints(wxString aNickName) -> wxArrayString"""
    return _pcbnew.GetFootprints(aNickName)

def ExportSpecctraDSN(*args) -> "bool":
    r"""
    ExportSpecctraDSN(wxString aFullFilename) -> bool
    ExportSpecctraDSN(BOARD aBoard, wxString aFullFilename) -> bool
    """
    return _pcbnew.ExportSpecctraDSN(*args)

def ExportVRML(aFullFileName: "wxString", aMMtoWRMLunit: "double", aExport3DFiles: "bool", aUseRelativePaths: "bool", a3D_Subdir: "wxString", aXRef: "double", aYRef: "double") -> "bool":
    r"""ExportVRML(wxString aFullFileName, double aMMtoWRMLunit, bool aExport3DFiles, bool aUseRelativePaths, wxString a3D_Subdir, double aXRef, double aYRef) -> bool"""
    return _pcbnew.ExportVRML(aFullFileName, aMMtoWRMLunit, aExport3DFiles, aUseRelativePaths, a3D_Subdir, aXRef, aYRef)

def ImportSpecctraSES(aFullFilename: "wxString") -> "bool":
    r"""ImportSpecctraSES(wxString aFullFilename) -> bool"""
    return _pcbnew.ImportSpecctraSES(aFullFilename)

def ExportFootprintsToLibrary(*args) -> "bool":
    r"""ExportFootprintsToLibrary(bool aStoreInNewLib, wxString aLibName=wxEmptyString, wxString aLibPath=None) -> bool"""
    return _pcbnew.ExportFootprintsToLibrary(*args)

def Refresh() -> "void":
    r"""Refresh()"""
    return _pcbnew.Refresh()

def UpdateUserInterface() -> "void":
    r"""UpdateUserInterface()"""
    return _pcbnew.UpdateUserInterface()

def GetUserUnits() -> "int":
    r"""GetUserUnits() -> int"""
    return _pcbnew.GetUserUnits()

def IsActionRunning() -> "bool":
    r"""IsActionRunning() -> bool"""
    return _pcbnew.IsActionRunning()

def WriteDRCReport(aBoard: "BOARD", aFileName: "wxString", aUnits: "EDA_UNITS", aReportAllTrackErrors: "bool") -> "bool":
    r"""WriteDRCReport(BOARD aBoard, wxString aFileName, EDA_UNITS aUnits, bool aReportAllTrackErrors) -> bool"""
    return _pcbnew.WriteDRCReport(aBoard, aFileName, aUnits, aReportAllTrackErrors)
UNDEFINED_LAYER = _pcbnew.UNDEFINED_LAYER

UNSELECTED_LAYER = _pcbnew.UNSELECTED_LAYER

PCBNEW_LAYER_ID_START = _pcbnew.PCBNEW_LAYER_ID_START

F_Cu = _pcbnew.F_Cu

In1_Cu = _pcbnew.In1_Cu

In2_Cu = _pcbnew.In2_Cu

In3_Cu = _pcbnew.In3_Cu

In4_Cu = _pcbnew.In4_Cu

In5_Cu = _pcbnew.In5_Cu

In6_Cu = _pcbnew.In6_Cu

In7_Cu = _pcbnew.In7_Cu

In8_Cu = _pcbnew.In8_Cu

In9_Cu = _pcbnew.In9_Cu

In10_Cu = _pcbnew.In10_Cu

In11_Cu = _pcbnew.In11_Cu

In12_Cu = _pcbnew.In12_Cu

In13_Cu = _pcbnew.In13_Cu

In14_Cu = _pcbnew.In14_Cu

In15_Cu = _pcbnew.In15_Cu

In16_Cu = _pcbnew.In16_Cu

In17_Cu = _pcbnew.In17_Cu

In18_Cu = _pcbnew.In18_Cu

In19_Cu = _pcbnew.In19_Cu

In20_Cu = _pcbnew.In20_Cu

In21_Cu = _pcbnew.In21_Cu

In22_Cu = _pcbnew.In22_Cu

In23_Cu = _pcbnew.In23_Cu

In24_Cu = _pcbnew.In24_Cu

In25_Cu = _pcbnew.In25_Cu

In26_Cu = _pcbnew.In26_Cu

In27_Cu = _pcbnew.In27_Cu

In28_Cu = _pcbnew.In28_Cu

In29_Cu = _pcbnew.In29_Cu

In30_Cu = _pcbnew.In30_Cu

B_Cu = _pcbnew.B_Cu

B_Adhes = _pcbnew.B_Adhes

F_Adhes = _pcbnew.F_Adhes

B_Paste = _pcbnew.B_Paste

F_Paste = _pcbnew.F_Paste

B_SilkS = _pcbnew.B_SilkS

F_SilkS = _pcbnew.F_SilkS

B_Mask = _pcbnew.B_Mask

F_Mask = _pcbnew.F_Mask

Dwgs_User = _pcbnew.Dwgs_User

Cmts_User = _pcbnew.Cmts_User

Eco1_User = _pcbnew.Eco1_User

Eco2_User = _pcbnew.Eco2_User

Edge_Cuts = _pcbnew.Edge_Cuts

Margin = _pcbnew.Margin

B_CrtYd = _pcbnew.B_CrtYd

F_CrtYd = _pcbnew.F_CrtYd

B_Fab = _pcbnew.B_Fab

F_Fab = _pcbnew.F_Fab

User_1 = _pcbnew.User_1

User_2 = _pcbnew.User_2

User_3 = _pcbnew.User_3

User_4 = _pcbnew.User_4

User_5 = _pcbnew.User_5

User_6 = _pcbnew.User_6

User_7 = _pcbnew.User_7

User_8 = _pcbnew.User_8

User_9 = _pcbnew.User_9

Rescue = _pcbnew.Rescue

PCB_LAYER_ID_COUNT = _pcbnew.PCB_LAYER_ID_COUNT

FLASHING_DEFAULT = _pcbnew.FLASHING_DEFAULT

FLASHING_ALWAYS_FLASHED = _pcbnew.FLASHING_ALWAYS_FLASHED

FLASHING_NEVER_FLASHED = _pcbnew.FLASHING_NEVER_FLASHED

NETNAMES_LAYER_ID_START = _pcbnew.NETNAMES_LAYER_ID_START

NETNAMES_LAYER_ID_RESERVED = _pcbnew.NETNAMES_LAYER_ID_RESERVED

LAYER_PAD_FR_NETNAMES = _pcbnew.LAYER_PAD_FR_NETNAMES

LAYER_PAD_BK_NETNAMES = _pcbnew.LAYER_PAD_BK_NETNAMES

LAYER_PAD_NETNAMES = _pcbnew.LAYER_PAD_NETNAMES

LAYER_VIA_NETNAMES = _pcbnew.LAYER_VIA_NETNAMES

NETNAMES_LAYER_ID_END = _pcbnew.NETNAMES_LAYER_ID_END

GAL_LAYER_ID_START = _pcbnew.GAL_LAYER_ID_START

LAYER_VIAS = _pcbnew.LAYER_VIAS

LAYER_VIA_MICROVIA = _pcbnew.LAYER_VIA_MICROVIA

LAYER_VIA_BBLIND = _pcbnew.LAYER_VIA_BBLIND

LAYER_VIA_THROUGH = _pcbnew.LAYER_VIA_THROUGH

LAYER_NON_PLATEDHOLES = _pcbnew.LAYER_NON_PLATEDHOLES

LAYER_MOD_TEXT = _pcbnew.LAYER_MOD_TEXT

LAYER_MOD_TEXT_INVISIBLE = _pcbnew.LAYER_MOD_TEXT_INVISIBLE

LAYER_ANCHOR = _pcbnew.LAYER_ANCHOR

LAYER_PAD_FR = _pcbnew.LAYER_PAD_FR

LAYER_PAD_BK = _pcbnew.LAYER_PAD_BK

LAYER_RATSNEST = _pcbnew.LAYER_RATSNEST

LAYER_GRID = _pcbnew.LAYER_GRID

LAYER_GRID_AXES = _pcbnew.LAYER_GRID_AXES

LAYER_NO_CONNECTS = _pcbnew.LAYER_NO_CONNECTS

LAYER_MOD_FR = _pcbnew.LAYER_MOD_FR

LAYER_MOD_BK = _pcbnew.LAYER_MOD_BK

LAYER_MOD_VALUES = _pcbnew.LAYER_MOD_VALUES

LAYER_MOD_REFERENCES = _pcbnew.LAYER_MOD_REFERENCES

LAYER_TRACKS = _pcbnew.LAYER_TRACKS

LAYER_PADS_TH = _pcbnew.LAYER_PADS_TH

LAYER_PAD_PLATEDHOLES = _pcbnew.LAYER_PAD_PLATEDHOLES

LAYER_VIA_HOLES = _pcbnew.LAYER_VIA_HOLES

LAYER_DRC_ERROR = _pcbnew.LAYER_DRC_ERROR

LAYER_DRAWINGSHEET = _pcbnew.LAYER_DRAWINGSHEET

LAYER_GP_OVERLAY = _pcbnew.LAYER_GP_OVERLAY

LAYER_SELECT_OVERLAY = _pcbnew.LAYER_SELECT_OVERLAY

LAYER_PCB_BACKGROUND = _pcbnew.LAYER_PCB_BACKGROUND

LAYER_CURSOR = _pcbnew.LAYER_CURSOR

LAYER_AUX_ITEMS = _pcbnew.LAYER_AUX_ITEMS

LAYER_DRAW_BITMAPS = _pcbnew.LAYER_DRAW_BITMAPS

GAL_LAYER_ID_BITMASK_END = _pcbnew.GAL_LAYER_ID_BITMASK_END

LAYER_PADS = _pcbnew.LAYER_PADS

LAYER_ZONES = _pcbnew.LAYER_ZONES

LAYER_PAD_HOLEWALLS = _pcbnew.LAYER_PAD_HOLEWALLS

LAYER_VIA_HOLEWALLS = _pcbnew.LAYER_VIA_HOLEWALLS

LAYER_DRC_WARNING = _pcbnew.LAYER_DRC_WARNING

LAYER_DRC_EXCLUSION = _pcbnew.LAYER_DRC_EXCLUSION

LAYER_MARKER_SHADOWS = _pcbnew.LAYER_MARKER_SHADOWS

LAYER_DRAWINGSHEET_PAGE1 = _pcbnew.LAYER_DRAWINGSHEET_PAGE1

LAYER_DRAWINGSHEET_PAGEn = _pcbnew.LAYER_DRAWINGSHEET_PAGEn

LAYER_ZONE_START = _pcbnew.LAYER_ZONE_START

LAYER_ZONE_END = _pcbnew.LAYER_ZONE_END

GAL_LAYER_ID_END = _pcbnew.GAL_LAYER_ID_END


def ToGalLayer(aInteger: "int") -> "GAL_LAYER_ID":
    r"""ToGalLayer(int aInteger) -> GAL_LAYER_ID"""
    return _pcbnew.ToGalLayer(aInteger)
class GAL_SET(object):
    r"""Proxy of C++ GAL_SET 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__(GAL_SET self) -> GAL_SET
        __init__(GAL_SET self, GAL_SET aOther) -> GAL_SET
        __init__(GAL_SET self, GAL_LAYER_ID const * aArray, unsigned int aCount) -> GAL_SET
        """
        _pcbnew.GAL_SET_swiginit(self, _pcbnew.new_GAL_SET(*args))

    def set(self, *args) -> "GAL_SET &":
        r"""
        set(GAL_SET self) -> GAL_SET
        set(GAL_SET self, GAL_LAYER_ID aPos, bool aVal=True) -> GAL_SET
        """
        return _pcbnew.GAL_SET_set(self, *args)

    def Contains(self, aPos: "GAL_LAYER_ID") -> "bool":
        r"""Contains(GAL_SET self, GAL_LAYER_ID aPos) -> bool"""
        return _pcbnew.GAL_SET_Contains(self, aPos)

    def Seq(self) -> "std::vector< GAL_LAYER_ID,std::allocator< GAL_LAYER_ID > >":
        r"""Seq(GAL_SET self) -> std::vector< GAL_LAYER_ID,std::allocator< GAL_LAYER_ID > >"""
        return _pcbnew.GAL_SET_Seq(self)

    @staticmethod
    def DefaultVisible() -> "GAL_SET":
        r"""DefaultVisible() -> GAL_SET"""
        return _pcbnew.GAL_SET_DefaultVisible()
    __swig_destroy__ = _pcbnew.delete_GAL_SET

# Register GAL_SET in _pcbnew:
_pcbnew.GAL_SET_swigregister(GAL_SET)
GAL_LAYER_ID_COUNT = cvar.GAL_LAYER_ID_COUNT

def GAL_SET_DefaultVisible() -> "GAL_SET":
    r"""GAL_SET_DefaultVisible() -> GAL_SET"""
    return _pcbnew.GAL_SET_DefaultVisible()

SCH_LAYER_ID_START = _pcbnew.SCH_LAYER_ID_START

LAYER_WIRE = _pcbnew.LAYER_WIRE

LAYER_BUS = _pcbnew.LAYER_BUS

LAYER_JUNCTION = _pcbnew.LAYER_JUNCTION

LAYER_LOCLABEL = _pcbnew.LAYER_LOCLABEL

LAYER_GLOBLABEL = _pcbnew.LAYER_GLOBLABEL

LAYER_HIERLABEL = _pcbnew.LAYER_HIERLABEL

LAYER_PINNUM = _pcbnew.LAYER_PINNUM

LAYER_PINNAM = _pcbnew.LAYER_PINNAM

LAYER_REFERENCEPART = _pcbnew.LAYER_REFERENCEPART

LAYER_VALUEPART = _pcbnew.LAYER_VALUEPART

LAYER_FIELDS = _pcbnew.LAYER_FIELDS

LAYER_DEVICE = _pcbnew.LAYER_DEVICE

LAYER_NOTES = _pcbnew.LAYER_NOTES

LAYER_PIN = _pcbnew.LAYER_PIN

LAYER_SHEET = _pcbnew.LAYER_SHEET

LAYER_SHEETNAME = _pcbnew.LAYER_SHEETNAME

LAYER_SHEETFILENAME = _pcbnew.LAYER_SHEETFILENAME

LAYER_SHEETFIELDS = _pcbnew.LAYER_SHEETFIELDS

LAYER_SHEETLABEL = _pcbnew.LAYER_SHEETLABEL

LAYER_NOCONNECT = _pcbnew.LAYER_NOCONNECT

LAYER_DANGLING = _pcbnew.LAYER_DANGLING

LAYER_ERC_WARN = _pcbnew.LAYER_ERC_WARN

LAYER_ERC_ERR = _pcbnew.LAYER_ERC_ERR

LAYER_DEVICE_BACKGROUND = _pcbnew.LAYER_DEVICE_BACKGROUND

LAYER_SHEET_BACKGROUND = _pcbnew.LAYER_SHEET_BACKGROUND

LAYER_SCHEMATIC_GRID = _pcbnew.LAYER_SCHEMATIC_GRID

LAYER_SCHEMATIC_GRID_AXES = _pcbnew.LAYER_SCHEMATIC_GRID_AXES

LAYER_SCHEMATIC_BACKGROUND = _pcbnew.LAYER_SCHEMATIC_BACKGROUND

LAYER_SCHEMATIC_CURSOR = _pcbnew.LAYER_SCHEMATIC_CURSOR

LAYER_BRIGHTENED = _pcbnew.LAYER_BRIGHTENED

LAYER_HIDDEN = _pcbnew.LAYER_HIDDEN

LAYER_SELECTION_SHADOWS = _pcbnew.LAYER_SELECTION_SHADOWS

LAYER_SCHEMATIC_DRAWINGSHEET = _pcbnew.LAYER_SCHEMATIC_DRAWINGSHEET

LAYER_BUS_JUNCTION = _pcbnew.LAYER_BUS_JUNCTION

LAYER_SCHEMATIC_AUX_ITEMS = _pcbnew.LAYER_SCHEMATIC_AUX_ITEMS

LAYER_SCHEMATIC_ANCHOR = _pcbnew.LAYER_SCHEMATIC_ANCHOR

SCH_LAYER_ID_END = _pcbnew.SCH_LAYER_ID_END

GERBVIEW_LAYER_ID_START = _pcbnew.GERBVIEW_LAYER_ID_START

GERBVIEW_LAYER_ID_RESERVED = _pcbnew.GERBVIEW_LAYER_ID_RESERVED

LAYER_DCODES = _pcbnew.LAYER_DCODES

LAYER_NEGATIVE_OBJECTS = _pcbnew.LAYER_NEGATIVE_OBJECTS

LAYER_GERBVIEW_GRID = _pcbnew.LAYER_GERBVIEW_GRID

LAYER_GERBVIEW_AXES = _pcbnew.LAYER_GERBVIEW_AXES

LAYER_GERBVIEW_BACKGROUND = _pcbnew.LAYER_GERBVIEW_BACKGROUND

LAYER_GERBVIEW_DRAWINGSHEET = _pcbnew.LAYER_GERBVIEW_DRAWINGSHEET

GERBVIEW_LAYER_ID_END = _pcbnew.GERBVIEW_LAYER_ID_END

LAYER_3D_START = _pcbnew.LAYER_3D_START

LAYER_3D_BACKGROUND_BOTTOM = _pcbnew.LAYER_3D_BACKGROUND_BOTTOM

LAYER_3D_BACKGROUND_TOP = _pcbnew.LAYER_3D_BACKGROUND_TOP

LAYER_3D_BOARD = _pcbnew.LAYER_3D_BOARD

LAYER_3D_COPPER = _pcbnew.LAYER_3D_COPPER

LAYER_3D_SILKSCREEN_BOTTOM = _pcbnew.LAYER_3D_SILKSCREEN_BOTTOM

LAYER_3D_SILKSCREEN_TOP = _pcbnew.LAYER_3D_SILKSCREEN_TOP

LAYER_3D_SOLDERMASK_BOTTOM = _pcbnew.LAYER_3D_SOLDERMASK_BOTTOM

LAYER_3D_SOLDERMASK_TOP = _pcbnew.LAYER_3D_SOLDERMASK_TOP

LAYER_3D_SOLDERPASTE = _pcbnew.LAYER_3D_SOLDERPASTE

LAYER_3D_END = _pcbnew.LAYER_3D_END


def LayerName(aLayer: "int") -> "wxString":
    r"""LayerName(int aLayer) -> wxString"""
    return _pcbnew.LayerName(aLayer)
class LSEQ(base_seqVect):
    r"""Proxy of C++ LSEQ 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__(LSEQ self) -> LSEQ"""
        _pcbnew.LSEQ_swiginit(self, _pcbnew.new_LSEQ())

    def Rewind(self) -> "void":
        r"""Rewind(LSEQ self)"""
        return _pcbnew.LSEQ_Rewind(self)

    def __nonzero__(self):
        return _pcbnew.LSEQ___nonzero__(self)
    __bool__ = __nonzero__



    def __ref__(self) -> "PCB_LAYER_ID":
        r"""__ref__(LSEQ self) -> PCB_LAYER_ID"""
        return _pcbnew.LSEQ___ref__(self)
    __swig_destroy__ = _pcbnew.delete_LSEQ

# Register LSEQ in _pcbnew:
_pcbnew.LSEQ_swigregister(LSEQ)

class LSET(BASE_SET):
    r"""Proxy of C++ LSET 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__(LSET self) -> LSET
        __init__(LSET self, BASE_SET aOther) -> LSET
        __init__(LSET self, PCB_LAYER_ID aLayer) -> LSET
        __init__(LSET self, PCB_LAYER_ID const * aArray, unsigned int aCount) -> LSET
        __init__(LSET self, unsigned int aIdCount, int aFirst) -> LSET
        """
        _pcbnew.LSET_swiginit(self, _pcbnew.new_LSET(*args))

    def Contains(self, aLayer: "PCB_LAYER_ID") -> "bool":
        r"""Contains(LSET self, PCB_LAYER_ID aLayer) -> bool"""
        return _pcbnew.LSET_Contains(self, aLayer)

    @staticmethod
    def Name(aLayerId: "PCB_LAYER_ID") -> "wxChar const *":
        r"""Name(PCB_LAYER_ID aLayerId) -> wxChar const *"""
        return _pcbnew.LSET_Name(aLayerId)

    @staticmethod
    def InternalCuMask() -> "LSET":
        r"""InternalCuMask() -> LSET"""
        return _pcbnew.LSET_InternalCuMask()

    @staticmethod
    def FrontAssembly() -> "LSET":
        r"""FrontAssembly() -> LSET"""
        return _pcbnew.LSET_FrontAssembly()

    @staticmethod
    def BackAssembly() -> "LSET":
        r"""BackAssembly() -> LSET"""
        return _pcbnew.LSET_BackAssembly()

    @staticmethod
    def AllCuMask(*args) -> "LSET":
        r"""AllCuMask(int aCuLayerCount=(B_Cu-F_Cu+1)) -> LSET"""
        return _pcbnew.LSET_AllCuMask(*args)

    @staticmethod
    def ExternalCuMask() -> "LSET":
        r"""ExternalCuMask() -> LSET"""
        return _pcbnew.LSET_ExternalCuMask()

    @staticmethod
    def AllNonCuMask() -> "LSET":
        r"""AllNonCuMask() -> LSET"""
        return _pcbnew.LSET_AllNonCuMask()

    @staticmethod
    def AllLayersMask() -> "LSET":
        r"""AllLayersMask() -> LSET"""
        return _pcbnew.LSET_AllLayersMask()

    @staticmethod
    def FrontTechMask() -> "LSET":
        r"""FrontTechMask() -> LSET"""
        return _pcbnew.LSET_FrontTechMask()

    @staticmethod
    def FrontBoardTechMask() -> "LSET":
        r"""FrontBoardTechMask() -> LSET"""
        return _pcbnew.LSET_FrontBoardTechMask()

    @staticmethod
    def BackTechMask() -> "LSET":
        r"""BackTechMask() -> LSET"""
        return _pcbnew.LSET_BackTechMask()

    @staticmethod
    def BackBoardTechMask() -> "LSET":
        r"""BackBoardTechMask() -> LSET"""
        return _pcbnew.LSET_BackBoardTechMask()

    @staticmethod
    def AllTechMask() -> "LSET":
        r"""AllTechMask() -> LSET"""
        return _pcbnew.LSET_AllTechMask()

    @staticmethod
    def AllBoardTechMask() -> "LSET":
        r"""AllBoardTechMask() -> LSET"""
        return _pcbnew.LSET_AllBoardTechMask()

    @staticmethod
    def FrontMask() -> "LSET":
        r"""FrontMask() -> LSET"""
        return _pcbnew.LSET_FrontMask()

    @staticmethod
    def BackMask() -> "LSET":
        r"""BackMask() -> LSET"""
        return _pcbnew.LSET_BackMask()

    @staticmethod
    def UserMask() -> "LSET":
        r"""UserMask() -> LSET"""
        return _pcbnew.LSET_UserMask()

    @staticmethod
    def PhysicalLayersMask() -> "LSET":
        r"""PhysicalLayersMask() -> LSET"""
        return _pcbnew.LSET_PhysicalLayersMask()

    @staticmethod
    def UserDefinedLayers() -> "LSET":
        r"""UserDefinedLayers() -> LSET"""
        return _pcbnew.LSET_UserDefinedLayers()

    @staticmethod
    def ForbiddenFootprintLayers() -> "LSET":
        r"""ForbiddenFootprintLayers() -> LSET"""
        return _pcbnew.LSET_ForbiddenFootprintLayers()

    def CuStack(self) -> "LSEQ":
        r"""CuStack(LSET self) -> LSEQ"""
        return _pcbnew.LSET_CuStack(self)

    def Technicals(self, *args) -> "LSEQ":
        r"""Technicals(LSET self, LSET aSubToOmit=LSET()) -> LSEQ"""
        return _pcbnew.LSET_Technicals(self, *args)

    def Users(self) -> "LSEQ":
        r"""Users(LSET self) -> LSEQ"""
        return _pcbnew.LSET_Users(self)

    def TechAndUserUIOrder(self) -> "LSEQ":
        r"""TechAndUserUIOrder(LSET self) -> LSEQ"""
        return _pcbnew.LSET_TechAndUserUIOrder(self)

    def UIOrder(self) -> "LSEQ":
        r"""UIOrder(LSET self) -> LSEQ"""
        return _pcbnew.LSET_UIOrder(self)

    def Seq(self, *args) -> "LSEQ":
        r"""
        Seq(LSET self, PCB_LAYER_ID const * aWishListSequence, unsigned int aCount) -> LSEQ
        Seq(LSET self) -> LSEQ
        """
        return _pcbnew.LSET_Seq(self, *args)

    def SeqStackupBottom2Top(self) -> "LSEQ":
        r"""SeqStackupBottom2Top(LSET self) -> LSEQ"""
        return _pcbnew.LSET_SeqStackupBottom2Top(self)

    def FmtHex(self) -> "std::string":
        r"""FmtHex(LSET self) -> string"""
        return _pcbnew.LSET_FmtHex(self)

    def ParseHex(self, aStart: "char const *", aCount: "int") -> "int":
        r"""ParseHex(LSET self, char const * aStart, int aCount) -> int"""
        return _pcbnew.LSET_ParseHex(self, aStart, aCount)

    def FmtBin(self) -> "std::string":
        r"""FmtBin(LSET self) -> string"""
        return _pcbnew.LSET_FmtBin(self)

    def ExtractLayer(self) -> "PCB_LAYER_ID":
        r"""ExtractLayer(LSET self) -> PCB_LAYER_ID"""
        return _pcbnew.LSET_ExtractLayer(self)

    def addLayer(self, aLayer: "PCB_LAYER_ID") -> "LSET":
        r"""addLayer(LSET self, PCB_LAYER_ID aLayer) -> LSET"""
        return _pcbnew.LSET_addLayer(self, aLayer)

    def removeLayer(self, aLayer: "PCB_LAYER_ID") -> "LSET":
        r"""removeLayer(LSET self, PCB_LAYER_ID aLayer) -> LSET"""
        return _pcbnew.LSET_removeLayer(self, aLayer)

    def addLayerSet(self, aLayerSet: "LSET") -> "LSET":
        r"""addLayerSet(LSET self, LSET aLayerSet) -> LSET"""
        return _pcbnew.LSET_addLayerSet(self, aLayerSet)

    def removeLayerSet(self, aLayerSet: "LSET") -> "LSET":
        r"""removeLayerSet(LSET self, LSET aLayerSet) -> LSET"""
        return _pcbnew.LSET_removeLayerSet(self, aLayerSet)

    def AddLayer(self, layer):
        return self.addLayer( layer )

    def AddLayerSet(self, layers):
        return self.addLayerSet( layers )

    def RemoveLayer(self, layer):
        return self.removeLayer( layer )

    def RemoveLayerSet(self, layers):
        return self.removeLayerSet( layers )

    __swig_destroy__ = _pcbnew.delete_LSET

# Register LSET in _pcbnew:
_pcbnew.LSET_swigregister(LSET)

def LSET_Name(aLayerId: "PCB_LAYER_ID") -> "wxChar const *":
    r"""LSET_Name(PCB_LAYER_ID aLayerId) -> wxChar const *"""
    return _pcbnew.LSET_Name(aLayerId)

def LSET_InternalCuMask() -> "LSET":
    r"""LSET_InternalCuMask() -> LSET"""
    return _pcbnew.LSET_InternalCuMask()

def LSET_FrontAssembly() -> "LSET":
    r"""LSET_FrontAssembly() -> LSET"""
    return _pcbnew.LSET_FrontAssembly()

def LSET_BackAssembly() -> "LSET":
    r"""LSET_BackAssembly() -> LSET"""
    return _pcbnew.LSET_BackAssembly()

def LSET_AllCuMask(*args) -> "LSET":
    r"""LSET_AllCuMask(int aCuLayerCount=(B_Cu-F_Cu+1)) -> LSET"""
    return _pcbnew.LSET_AllCuMask(*args)

def LSET_ExternalCuMask() -> "LSET":
    r"""LSET_ExternalCuMask() -> LSET"""
    return _pcbnew.LSET_ExternalCuMask()

def LSET_AllNonCuMask() -> "LSET":
    r"""LSET_AllNonCuMask() -> LSET"""
    return _pcbnew.LSET_AllNonCuMask()

def LSET_AllLayersMask() -> "LSET":
    r"""LSET_AllLayersMask() -> LSET"""
    return _pcbnew.LSET_AllLayersMask()

def LSET_FrontTechMask() -> "LSET":
    r"""LSET_FrontTechMask() -> LSET"""
    return _pcbnew.LSET_FrontTechMask()

def LSET_FrontBoardTechMask() -> "LSET":
    r"""LSET_FrontBoardTechMask() -> LSET"""
    return _pcbnew.LSET_FrontBoardTechMask()

def LSET_BackTechMask() -> "LSET":
    r"""LSET_BackTechMask() -> LSET"""
    return _pcbnew.LSET_BackTechMask()

def LSET_BackBoardTechMask() -> "LSET":
    r"""LSET_BackBoardTechMask() -> LSET"""
    return _pcbnew.LSET_BackBoardTechMask()

def LSET_AllTechMask() -> "LSET":
    r"""LSET_AllTechMask() -> LSET"""
    return _pcbnew.LSET_AllTechMask()

def LSET_AllBoardTechMask() -> "LSET":
    r"""LSET_AllBoardTechMask() -> LSET"""
    return _pcbnew.LSET_AllBoardTechMask()

def LSET_FrontMask() -> "LSET":
    r"""LSET_FrontMask() -> LSET"""
    return _pcbnew.LSET_FrontMask()

def LSET_BackMask() -> "LSET":
    r"""LSET_BackMask() -> LSET"""
    return _pcbnew.LSET_BackMask()

def LSET_UserMask() -> "LSET":
    r"""LSET_UserMask() -> LSET"""
    return _pcbnew.LSET_UserMask()

def LSET_PhysicalLayersMask() -> "LSET":
    r"""LSET_PhysicalLayersMask() -> LSET"""
    return _pcbnew.LSET_PhysicalLayersMask()

def LSET_UserDefinedLayers() -> "LSET":
    r"""LSET_UserDefinedLayers() -> LSET"""
    return _pcbnew.LSET_UserDefinedLayers()

def LSET_ForbiddenFootprintLayers() -> "LSET":
    r"""LSET_ForbiddenFootprintLayers() -> LSET"""
    return _pcbnew.LSET_ForbiddenFootprintLayers()


def IsValidLayer(aLayerId: "LAYER_NUM") -> "bool":
    r"""IsValidLayer(LAYER_NUM aLayerId) -> bool"""
    return _pcbnew.IsValidLayer(aLayerId)

def IsPcbLayer(aLayer: "LAYER_NUM") -> "bool":
    r"""IsPcbLayer(LAYER_NUM aLayer) -> bool"""
    return _pcbnew.IsPcbLayer(aLayer)

def IsNonCopperLayer(aLayerId: "LAYER_NUM") -> "bool":
    r"""IsNonCopperLayer(LAYER_NUM aLayerId) -> bool"""
    return _pcbnew.IsNonCopperLayer(aLayerId)

def IsCopperLayer(*args) -> "bool":
    r"""
    IsCopperLayer(LAYER_NUM aLayerId) -> bool
    IsCopperLayer(LAYER_NUM aLayerId, bool aIncludeSyntheticCopperLayers) -> bool
    """
    return _pcbnew.IsCopperLayer(*args)

def IsViaPadLayer(aLayer: "LAYER_NUM") -> "bool":
    r"""IsViaPadLayer(LAYER_NUM aLayer) -> bool"""
    return _pcbnew.IsViaPadLayer(aLayer)

def IsHoleLayer(aLayer: "LAYER_NUM") -> "bool":
    r"""IsHoleLayer(LAYER_NUM aLayer) -> bool"""
    return _pcbnew.IsHoleLayer(aLayer)

def IsUserLayer(aLayerId: "PCB_LAYER_ID") -> "bool":
    r"""IsUserLayer(PCB_LAYER_ID aLayerId) -> bool"""
    return _pcbnew.IsUserLayer(aLayerId)

def IsFrontLayer(aLayerId: "PCB_LAYER_ID") -> "bool":
    r"""IsFrontLayer(PCB_LAYER_ID aLayerId) -> bool"""
    return _pcbnew.IsFrontLayer(aLayerId)

def IsBackLayer(aLayerId: "PCB_LAYER_ID") -> "bool":
    r"""IsBackLayer(PCB_LAYER_ID aLayerId) -> bool"""
    return _pcbnew.IsBackLayer(aLayerId)

def FlipLayer(aLayerId: "PCB_LAYER_ID", aCopperLayersCount: "int"=0) -> "PCB_LAYER_ID":
    r"""FlipLayer(PCB_LAYER_ID aLayerId, int aCopperLayersCount=0) -> PCB_LAYER_ID"""
    return _pcbnew.FlipLayer(aLayerId, aCopperLayersCount)

def FlipLayerMask(aMask: "LSET", aCopperLayersCount: "int"=0) -> "LSET":
    r"""FlipLayerMask(LSET aMask, int aCopperLayersCount=0) -> LSET"""
    return _pcbnew.FlipLayerMask(aMask, aCopperLayersCount)

def GetNetnameLayer(aLayer: "int") -> "int":
    r"""GetNetnameLayer(int aLayer) -> int"""
    return _pcbnew.GetNetnameLayer(aLayer)

def IsNetnameLayer(aLayer: "LAYER_NUM") -> "bool":
    r"""IsNetnameLayer(LAYER_NUM aLayer) -> bool"""
    return _pcbnew.IsNetnameLayer(aLayer)

def IsZoneLayer(aLayer: "LAYER_NUM") -> "bool":
    r"""IsZoneLayer(LAYER_NUM aLayer) -> bool"""
    return _pcbnew.IsZoneLayer(aLayer)

def IsDCodeLayer(aLayer: "int") -> "bool":
    r"""IsDCodeLayer(int aLayer) -> bool"""
    return _pcbnew.IsDCodeLayer(aLayer)

def IsNetCopperLayer(aLayer: "LAYER_NUM") -> "bool":
    r"""IsNetCopperLayer(LAYER_NUM aLayer) -> bool"""
    return _pcbnew.IsNetCopperLayer(aLayer)

def ToLAYER_ID(aLayer: "int") -> "PCB_LAYER_ID":
    r"""ToLAYER_ID(int aLayer) -> PCB_LAYER_ID"""
    return _pcbnew.ToLAYER_ID(aLayer)
class BOARD_ITEM(EDA_ITEM):
    r"""Proxy of C++ BOARD_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

    def SetParentGroup(self, aGroup: "PCB_GROUP") -> "void":
        r"""SetParentGroup(BOARD_ITEM self, PCB_GROUP aGroup)"""
        return _pcbnew.BOARD_ITEM_SetParentGroup(self, aGroup)

    def GetParentGroup(self) -> "PCB_GROUP *":
        r"""GetParentGroup(BOARD_ITEM self) -> PCB_GROUP"""
        return _pcbnew.BOARD_ITEM_GetParentGroup(self)

    def GetX(self) -> "int":
        r"""GetX(BOARD_ITEM self) -> int"""
        return _pcbnew.BOARD_ITEM_GetX(self)

    def GetY(self) -> "int":
        r"""GetY(BOARD_ITEM self) -> int"""
        return _pcbnew.BOARD_ITEM_GetY(self)

    def GetCenter(self) -> "wxPoint":
        r"""GetCenter(BOARD_ITEM self) -> wxPoint"""
        return _pcbnew.BOARD_ITEM_GetCenter(self)

    def SetX(self, aX: "int") -> "void":
        r"""SetX(BOARD_ITEM self, int aX)"""
        return _pcbnew.BOARD_ITEM_SetX(self, aX)

    def SetY(self, aY: "int") -> "void":
        r"""SetY(BOARD_ITEM self, int aY)"""
        return _pcbnew.BOARD_ITEM_SetY(self, aY)

    def IsConnected(self) -> "bool":
        r"""IsConnected(BOARD_ITEM self) -> bool"""
        return _pcbnew.BOARD_ITEM_IsConnected(self)

    def IsOnCopperLayer(self) -> "bool":
        r"""IsOnCopperLayer(BOARD_ITEM self) -> bool"""
        return _pcbnew.BOARD_ITEM_IsOnCopperLayer(self)

    def GetEffectiveShape(self, *args) -> "std::shared_ptr< SHAPE >":
        r"""GetEffectiveShape(BOARD_ITEM self, PCB_LAYER_ID aLayer=UNDEFINED_LAYER, FLASHING aFlash=DEFAULT) -> std::shared_ptr< SHAPE >"""
        return _pcbnew.BOARD_ITEM_GetEffectiveShape(self, *args)

    def GetParent(self) -> "BOARD_ITEM_CONTAINER *":
        r"""GetParent(BOARD_ITEM self) -> BOARD_ITEM_CONTAINER"""
        return _pcbnew.BOARD_ITEM_GetParent(self)

    def GetParentFootprint(self) -> "BOARD_ITEM_CONTAINER *":
        r"""GetParentFootprint(BOARD_ITEM self) -> BOARD_ITEM_CONTAINER"""
        return _pcbnew.BOARD_ITEM_GetParentFootprint(self)

    def GetLayer(self) -> "PCB_LAYER_ID":
        r"""GetLayer(BOARD_ITEM self) -> PCB_LAYER_ID"""
        return _pcbnew.BOARD_ITEM_GetLayer(self)

    def GetLayerSet(self) -> "LSET":
        r"""GetLayerSet(BOARD_ITEM self) -> LSET"""
        return _pcbnew.BOARD_ITEM_GetLayerSet(self)

    def SetLayerSet(self, aLayers: "LSET") -> "void":
        r"""SetLayerSet(BOARD_ITEM self, LSET aLayers)"""
        return _pcbnew.BOARD_ITEM_SetLayerSet(self, aLayers)

    def SetLayer(self, aLayer: "PCB_LAYER_ID") -> "void":
        r"""SetLayer(BOARD_ITEM self, PCB_LAYER_ID aLayer)"""
        return _pcbnew.BOARD_ITEM_SetLayer(self, aLayer)

    def Duplicate(self) -> "BOARD_ITEM *":
        r"""Duplicate(BOARD_ITEM self) -> BOARD_ITEM"""
        return _pcbnew.BOARD_ITEM_Duplicate(self)

    def SwapData(self, aImage: "BOARD_ITEM") -> "void":
        r"""SwapData(BOARD_ITEM self, BOARD_ITEM aImage)"""
        return _pcbnew.BOARD_ITEM_SwapData(self, aImage)

    def IsOnLayer(self, aLayer: "PCB_LAYER_ID") -> "bool":
        r"""IsOnLayer(BOARD_ITEM self, PCB_LAYER_ID aLayer) -> bool"""
        return _pcbnew.BOARD_ITEM_IsOnLayer(self, aLayer)

    def IsTrack(self) -> "bool":
        r"""IsTrack(BOARD_ITEM self) -> bool"""
        return _pcbnew.BOARD_ITEM_IsTrack(self)

    def IsLocked(self) -> "bool":
        r"""IsLocked(BOARD_ITEM self) -> bool"""
        return _pcbnew.BOARD_ITEM_IsLocked(self)

    def SetLocked(self, aLocked: "bool") -> "void":
        r"""SetLocked(BOARD_ITEM self, bool aLocked)"""
        return _pcbnew.BOARD_ITEM_SetLocked(self, aLocked)

    def DeleteStructure(self) -> "void":
        r"""DeleteStructure(BOARD_ITEM self)"""
        return _pcbnew.BOARD_ITEM_DeleteStructure(self)

    def Move(self, *args) -> "void":
        r"""
        Move(BOARD_ITEM self, wxPoint aMoveVector)
        Move(BOARD_ITEM self, VECTOR2I aMoveVector)
        """
        return _pcbnew.BOARD_ITEM_Move(self, *args)

    def Rotate(self, *args) -> "void":
        r"""
        Rotate(BOARD_ITEM self, wxPoint aRotCentre, double aAngle)
        Rotate(BOARD_ITEM self, VECTOR2I aRotCentre, double aAngle)
        """
        return _pcbnew.BOARD_ITEM_Rotate(self, *args)

    def Flip(self, *args) -> "void":
        r"""
        Flip(BOARD_ITEM self, wxPoint aCentre, bool aFlipLeftRight)
        Flip(BOARD_ITEM self, VECTOR2I aCentre, bool aFlipLeftRight)
        """
        return _pcbnew.BOARD_ITEM_Flip(self, *args)

    def GetBoard(self, *args) -> "BOARD *":
        r"""
        GetBoard(BOARD_ITEM self) -> BOARD
        GetBoard(BOARD_ITEM self) -> BOARD
        """
        return _pcbnew.BOARD_ITEM_GetBoard(self, *args)

    def GetLayerName(self) -> "wxString":
        r"""GetLayerName(BOARD_ITEM self) -> wxString"""
        return _pcbnew.BOARD_ITEM_GetLayerName(self)

    def ViewGetLayers(self, aLayers: "int []", aCount: "int &") -> "void":
        r"""ViewGetLayers(BOARD_ITEM self, int [] aLayers, int & aCount)"""
        return _pcbnew.BOARD_ITEM_ViewGetLayers(self, aLayers, aCount)

    def TransformShapeWithClearanceToPolygon(self, aCornerBuffer: "SHAPE_POLY_SET", aLayer: "PCB_LAYER_ID", aClearanceValue: "int", aError: "int", aErrorLoc: "ERROR_LOC", ignoreLineWidth: "bool"=False) -> "void":
        r"""TransformShapeWithClearanceToPolygon(BOARD_ITEM self, SHAPE_POLY_SET aCornerBuffer, PCB_LAYER_ID aLayer, int aClearanceValue, int aError, ERROR_LOC aErrorLoc, bool ignoreLineWidth=False)"""
        return _pcbnew.BOARD_ITEM_TransformShapeWithClearanceToPolygon(self, aCornerBuffer, aLayer, aClearanceValue, aError, aErrorLoc, ignoreLineWidth)

    def Cast(self):

        ct = self.GetClass()

        if ct=="PTEXT":
            return Cast_to_PCB_TEXT(self)
        elif ct=="BOARD":
            return Cast_to_BOARD(self)
        elif ct=="PCB_DIM_ALIGNED":
            return Cast_to_PCB_DIM_ALIGNED(self)
        elif ct=="PCB_DIM_LEADER":
            return Cast_to_PCB_DIM_LEADER(self)
        elif ct=="PCB_DIM_CENTER":
            return Cast_to_PCB_DIM_CENTER(self)
        elif ct=="PCB_DIM_ORTHOGONAL":
            return Cast_to_PCB_DIM_ORTHOGONAL(self)
        elif ct=="PCB_SHAPE":
            return Cast_to_PCB_SHAPE(self)
        elif ct=="MGRAPHIC":
            return Cast_to_FP_SHAPE(self)
        elif ct=="FOOTPRINT":
            return Cast_to_FOOTPRINT(self)
        elif ct=="PCB_GROUP":
            return Cast_to_PCB_GROUP(self)
        elif ct=="PAD":
            return Cast_to_PAD(self)
        elif ct=="MTEXT":
            return Cast_to_FP_TEXT(self)
        elif ct=="PCB_VIA":
            return Cast_to_PCB_VIA(self)
        elif ct=="PCB_TRACK":
            return Cast_to_PCB_TRACK(self)
        elif ct=="PCB_ARC":
            return Cast_to_PCB_ARC(self)
        elif ct=="PCB_TARGET":
            return Cast_to_PCB_TARGET(self)
        elif ct=="ZONE":
            return Cast_to_ZONE(self)
        else:
            raise TypeError("Unsupported drawing class: %s" % ct)

    def Duplicate(self):
        ct = self.GetClass()
        if ct=="BOARD":
            return None
        else:
            return Cast_to_BOARD_ITEM(self.Clone()).Cast()

    def SetPos(self,p):
        self.SetPosition(p)
        self.SetPos0(p)

    def SetStartEnd(self,start,end):
        self.SetStart(start)
        self.SetStart0(start)
        self.SetEnd(end)
        self.SetEnd0(end)

    __swig_destroy__ = _pcbnew.delete_BOARD_ITEM

# Register BOARD_ITEM in _pcbnew:
_pcbnew.BOARD_ITEM_swigregister(BOARD_ITEM)

class DELETED_BOARD_ITEM(BOARD_ITEM):
    r"""Proxy of C++ DELETED_BOARD_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):
        r"""__init__(DELETED_BOARD_ITEM self) -> DELETED_BOARD_ITEM"""
        _pcbnew.DELETED_BOARD_ITEM_swiginit(self, _pcbnew.new_DELETED_BOARD_ITEM())

    def GetSelectMenuText(self, aUnits: "EDA_UNITS") -> "wxString":
        r"""GetSelectMenuText(DELETED_BOARD_ITEM self, EDA_UNITS aUnits) -> wxString"""
        return _pcbnew.DELETED_BOARD_ITEM_GetSelectMenuText(self, aUnits)

    def GetClass(self) -> "wxString":
        r"""GetClass(DELETED_BOARD_ITEM self) -> wxString"""
        return _pcbnew.DELETED_BOARD_ITEM_GetClass(self)

    def SetPosition(self, arg2: "wxPoint") -> "void":
        r"""SetPosition(DELETED_BOARD_ITEM self, wxPoint arg2)"""
        return _pcbnew.DELETED_BOARD_ITEM_SetPosition(self, arg2)

    def GetPosition(self) -> "wxPoint":
        r"""GetPosition(DELETED_BOARD_ITEM self) -> wxPoint"""
        return _pcbnew.DELETED_BOARD_ITEM_GetPosition(self)

    @staticmethod
    def GetInstance() -> "DELETED_BOARD_ITEM *":
        r"""GetInstance() -> DELETED_BOARD_ITEM"""
        return _pcbnew.DELETED_BOARD_ITEM_GetInstance()
    __swig_destroy__ = _pcbnew.delete_DELETED_BOARD_ITEM

# Register DELETED_BOARD_ITEM in _pcbnew:
_pcbnew.DELETED_BOARD_ITEM_swigregister(DELETED_BOARD_ITEM)

def DELETED_BOARD_ITEM_GetInstance() -> "DELETED_BOARD_ITEM *":
    r"""DELETED_BOARD_ITEM_GetInstance() -> DELETED_BOARD_ITEM"""
    return _pcbnew.DELETED_BOARD_ITEM_GetInstance()

IS_CHANGED = _pcbnew.IS_CHANGED

IS_LINKED = _pcbnew.IS_LINKED

IN_EDIT = _pcbnew.IN_EDIT

IS_MOVING = _pcbnew.IS_MOVING

IS_NEW = _pcbnew.IS_NEW

IS_RESIZING = _pcbnew.IS_RESIZING

IS_DRAGGING = _pcbnew.IS_DRAGGING

IS_DELETED = _pcbnew.IS_DELETED

IS_WIRE_IMAGE = _pcbnew.IS_WIRE_IMAGE

STARTPOINT = _pcbnew.STARTPOINT

ENDPOINT = _pcbnew.ENDPOINT

SELECTED = _pcbnew.SELECTED

TEMP_SELECTED = _pcbnew.TEMP_SELECTED

STRUCT_DELETED = _pcbnew.STRUCT_DELETED

CANDIDATE = _pcbnew.CANDIDATE

SKIP_STRUCT = _pcbnew.SKIP_STRUCT

DO_NOT_DRAW = _pcbnew.DO_NOT_DRAW

IS_PASTED = _pcbnew.IS_PASTED

LOCKED = _pcbnew.LOCKED

UNUSED = _pcbnew.UNUSED

MALFORMED_F_COURTYARD = _pcbnew.MALFORMED_F_COURTYARD

MALFORMED_B_COURTYARD = _pcbnew.MALFORMED_B_COURTYARD

MALFORMED_COURTYARDS = _pcbnew.MALFORMED_COURTYARDS

BEGIN_ONPAD = _pcbnew.BEGIN_ONPAD

END_ONPAD = _pcbnew.END_ONPAD

HOLE_PROXY = _pcbnew.HOLE_PROXY

IS_ROLLOVER = _pcbnew.IS_ROLLOVER

BRIGHTENED = _pcbnew.BRIGHTENED

DP_COUPLED = _pcbnew.DP_COUPLED

UR_TRANSIENT = _pcbnew.UR_TRANSIENT

IS_DANGLING = _pcbnew.IS_DANGLING

ENTERED = _pcbnew.ENTERED


def Cast_to_BOARD_ITEM(base: "EDA_ITEM") -> "BOARD_ITEM *":
    r"""Cast_to_BOARD_ITEM(EDA_ITEM base) -> BOARD_ITEM"""
    return _pcbnew.Cast_to_BOARD_ITEM(base)

def Cast_to_PCB_TEXT(arg1: "BOARD_ITEM") -> "PCB_TEXT *":
    r"""Cast_to_PCB_TEXT(BOARD_ITEM arg1) -> PCB_TEXT"""
    return _pcbnew.Cast_to_PCB_TEXT(arg1)

def Cast_to_PCB_DIM_ALIGNED(arg1: "BOARD_ITEM") -> "PCB_DIM_ALIGNED *":
    r"""Cast_to_PCB_DIM_ALIGNED(BOARD_ITEM arg1) -> PCB_DIM_ALIGNED"""
    return _pcbnew.Cast_to_PCB_DIM_ALIGNED(arg1)

def Cast_to_PCB_DIM_ORTHOGONAL(arg1: "BOARD_ITEM") -> "PCB_DIM_ORTHOGONAL *":
    r"""Cast_to_PCB_DIM_ORTHOGONAL(BOARD_ITEM arg1) -> PCB_DIM_ORTHOGONAL"""
    return _pcbnew.Cast_to_PCB_DIM_ORTHOGONAL(arg1)

def Cast_to_PCB_DIM_LEADER(arg1: "BOARD_ITEM") -> "PCB_DIM_LEADER *":
    r"""Cast_to_PCB_DIM_LEADER(BOARD_ITEM arg1) -> PCB_DIM_LEADER"""
    return _pcbnew.Cast_to_PCB_DIM_LEADER(arg1)

def Cast_to_PCB_DIM_CENTER(arg1: "BOARD_ITEM") -> "PCB_DIM_CENTER *":
    r"""Cast_to_PCB_DIM_CENTER(BOARD_ITEM arg1) -> PCB_DIM_CENTER"""
    return _pcbnew.Cast_to_PCB_DIM_CENTER(arg1)

def Cast_to_FOOTPRINT(arg1: "BOARD_ITEM") -> "FOOTPRINT *":
    r"""Cast_to_FOOTPRINT(BOARD_ITEM arg1) -> FOOTPRINT"""
    return _pcbnew.Cast_to_FOOTPRINT(arg1)

def Cast_to_PCB_GROUP(arg1: "BOARD_ITEM") -> "PCB_GROUP *":
    r"""Cast_to_PCB_GROUP(BOARD_ITEM arg1) -> PCB_GROUP"""
    return _pcbnew.Cast_to_PCB_GROUP(arg1)

def Cast_to_FP_TEXT(arg1: "BOARD_ITEM") -> "FP_TEXT *":
    r"""Cast_to_FP_TEXT(BOARD_ITEM arg1) -> FP_TEXT"""
    return _pcbnew.Cast_to_FP_TEXT(arg1)

def Cast_to_PCB_SHAPE(arg1: "BOARD_ITEM") -> "PCB_SHAPE *":
    r"""Cast_to_PCB_SHAPE(BOARD_ITEM arg1) -> PCB_SHAPE"""
    return _pcbnew.Cast_to_PCB_SHAPE(arg1)

def Cast_to_PCB_MARKER(arg1: "BOARD_ITEM") -> "PCB_MARKER *":
    r"""Cast_to_PCB_MARKER(BOARD_ITEM arg1) -> PCB_MARKER"""
    return _pcbnew.Cast_to_PCB_MARKER(arg1)

def Cast_to_BOARD(arg1: "BOARD_ITEM") -> "BOARD *":
    r"""Cast_to_BOARD(BOARD_ITEM arg1) -> BOARD"""
    return _pcbnew.Cast_to_BOARD(arg1)

def Cast_to_FP_SHAPE(arg1: "BOARD_ITEM") -> "FP_SHAPE *":
    r"""Cast_to_FP_SHAPE(BOARD_ITEM arg1) -> FP_SHAPE"""
    return _pcbnew.Cast_to_FP_SHAPE(arg1)

def Cast_to_PAD(arg1: "BOARD_ITEM") -> "PAD *":
    r"""Cast_to_PAD(BOARD_ITEM arg1) -> PAD"""
    return _pcbnew.Cast_to_PAD(arg1)

def Cast_to_PCB_TRACK(arg1: "BOARD_ITEM") -> "PCB_TRACK *":
    r"""Cast_to_PCB_TRACK(BOARD_ITEM arg1) -> PCB_TRACK"""
    return _pcbnew.Cast_to_PCB_TRACK(arg1)

def Cast_to_PCB_VIA(arg1: "BOARD_ITEM") -> "PCB_VIA *":
    r"""Cast_to_PCB_VIA(BOARD_ITEM arg1) -> PCB_VIA"""
    return _pcbnew.Cast_to_PCB_VIA(arg1)

def Cast_to_PCB_ARC(arg1: "BOARD_ITEM") -> "PCB_ARC *":
    r"""Cast_to_PCB_ARC(BOARD_ITEM arg1) -> PCB_ARC"""
    return _pcbnew.Cast_to_PCB_ARC(arg1)

def Cast_to_ZONE(arg1: "BOARD_ITEM") -> "ZONE *":
    r"""Cast_to_ZONE(BOARD_ITEM arg1) -> ZONE"""
    return _pcbnew.Cast_to_ZONE(arg1)

def Cast_to_FP_ZONE(arg1: "BOARD_ITEM") -> "FP_ZONE *":
    r"""Cast_to_FP_ZONE(BOARD_ITEM arg1) -> FP_ZONE"""
    return _pcbnew.Cast_to_FP_ZONE(arg1)

def Cast_to_PCB_TARGET(arg1: "BOARD_ITEM") -> "PCB_TARGET *":
    r"""Cast_to_PCB_TARGET(BOARD_ITEM arg1) -> PCB_TARGET"""
    return _pcbnew.Cast_to_PCB_TARGET(arg1)
ADD_MODE_INSERT = _pcbnew.ADD_MODE_INSERT

ADD_MODE_APPEND = _pcbnew.ADD_MODE_APPEND

ADD_MODE_BULK_APPEND = _pcbnew.ADD_MODE_BULK_APPEND

ADD_MODE_BULK_INSERT = _pcbnew.ADD_MODE_BULK_INSERT

REMOVE_MODE_NORMAL = _pcbnew.REMOVE_MODE_NORMAL

REMOVE_MODE_BULK = _pcbnew.REMOVE_MODE_BULK

class BOARD_ITEM_CONTAINER(BOARD_ITEM):
    r"""Proxy of C++ BOARD_ITEM_CONTAINER 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 AddNative(self, *args) -> "void":
        r"""AddNative(BOARD_ITEM_CONTAINER self, BOARD_ITEM aItem, ADD_MODE aMode=INSERT)"""
        return _pcbnew.BOARD_ITEM_CONTAINER_AddNative(self, *args)

    def RemoveNative(self, *args) -> "void":
        r"""RemoveNative(BOARD_ITEM_CONTAINER self, BOARD_ITEM aItem, REMOVE_MODE aMode=NORMAL)"""
        return _pcbnew.BOARD_ITEM_CONTAINER_RemoveNative(self, *args)

    def DeleteNative(self, aItem: "BOARD_ITEM") -> "void":
        r"""DeleteNative(BOARD_ITEM_CONTAINER self, BOARD_ITEM aItem)"""
        return _pcbnew.BOARD_ITEM_CONTAINER_DeleteNative(self, aItem)

    def GetZoneSettings(self) -> "ZONE_SETTINGS const &":
        r"""GetZoneSettings(BOARD_ITEM_CONTAINER self) -> ZONE_SETTINGS"""
        return _pcbnew.BOARD_ITEM_CONTAINER_GetZoneSettings(self)

    def SetZoneSettings(self, aSettings: "ZONE_SETTINGS") -> "void":
        r"""SetZoneSettings(BOARD_ITEM_CONTAINER self, ZONE_SETTINGS aSettings)"""
        return _pcbnew.BOARD_ITEM_CONTAINER_SetZoneSettings(self, aSettings)

    def Add(self,item):
        """
        Add a BOARD_ITEM to this BOARD_ITEM_CONTAINER, clear the thisown to prevent
        python from deleting the object in the garbage collector
        Add(BOARD_ITEM_CONTAINER self, BOARD_ITEM aItem, BOARD_ADD_MODE aMode=BOARD_ADD_MODE::INSERT)
        Add(BOARD_ITEM_CONTAINER self, BOARD_ITEM aItem)
        """
        item.thisown=0
        self.AddNative(item)

    def Remove(self,item):
        """
        Remove a BOARD_ITEM from this BOARD_ITEM_CONTAINER, set the thisdown flag so that
        the python wrapper owns the C++ BOARD_ITEM
        Remove(self, BOARD_ITEM)
        """
        self.RemoveNative(item)
        if (not IsActionRunning()):
            item.thisown=1

    def Delete(self,item):
        """
        Remove a BOARD_ITEM from this BOARD_ITEM_CONTAINER, set the thisdown flag so that
        the python wrapper does not owns the C++ BOARD_ITEM
        Delete(self, BOARD_ITEM)
        """
        item.thisown=0          # C++'s BOARD_ITEM_CONTAINER::Delete() will delete
        self.DeleteNative(item)
        item.this = None

    __swig_destroy__ = _pcbnew.delete_BOARD_ITEM_CONTAINER

# Register BOARD_ITEM_CONTAINER in _pcbnew:
_pcbnew.BOARD_ITEM_CONTAINER_swigregister(BOARD_ITEM_CONTAINER)

class BOARD_CONNECTED_ITEM(BOARD_ITEM):
    r"""Proxy of C++ BOARD_CONNECTED_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

    @staticmethod
    def ClassOf(aItem: "EDA_ITEM") -> "bool":
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.BOARD_CONNECTED_ITEM_ClassOf(aItem)

    def IsConnected(self) -> "bool":
        r"""IsConnected(BOARD_CONNECTED_ITEM self) -> bool"""
        return _pcbnew.BOARD_CONNECTED_ITEM_IsConnected(self)

    def GetNet(self) -> "NETINFO_ITEM *":
        r"""GetNet(BOARD_CONNECTED_ITEM self) -> NETINFO_ITEM"""
        return _pcbnew.BOARD_CONNECTED_ITEM_GetNet(self)

    def SetNet(self, aNetInfo: "NETINFO_ITEM") -> "void":
        r"""SetNet(BOARD_CONNECTED_ITEM self, NETINFO_ITEM aNetInfo)"""
        return _pcbnew.BOARD_CONNECTED_ITEM_SetNet(self, aNetInfo)

    def GetNetCode(self) -> "int":
        r"""GetNetCode(BOARD_CONNECTED_ITEM self) -> int"""
        return _pcbnew.BOARD_CONNECTED_ITEM_GetNetCode(self)

    def SetNetCode(self, *args) -> "void":
        r"""
        SetNetCode(BOARD_CONNECTED_ITEM self, int aNetCode, bool aNoAssert) -> bool
        SetNetCode(BOARD_CONNECTED_ITEM self, int aNetCode)
        """
        return _pcbnew.BOARD_CONNECTED_ITEM_SetNetCode(self, *args)

    def GetNetname(self) -> "wxString":
        r"""GetNetname(BOARD_CONNECTED_ITEM self) -> wxString"""
        return _pcbnew.BOARD_CONNECTED_ITEM_GetNetname(self)

    def GetNetnameMsg(self) -> "wxString":
        r"""GetNetnameMsg(BOARD_CONNECTED_ITEM self) -> wxString"""
        return _pcbnew.BOARD_CONNECTED_ITEM_GetNetnameMsg(self)

    def GetShortNetname(self) -> "wxString":
        r"""GetShortNetname(BOARD_CONNECTED_ITEM self) -> wxString"""
        return _pcbnew.BOARD_CONNECTED_ITEM_GetShortNetname(self)

    def GetOwnClearance(self, aLayer: "PCB_LAYER_ID", aSource: "wxString"=None) -> "int":
        r"""GetOwnClearance(BOARD_CONNECTED_ITEM self, PCB_LAYER_ID aLayer, wxString aSource=None) -> int"""
        return _pcbnew.BOARD_CONNECTED_ITEM_GetOwnClearance(self, aLayer, aSource)

    def GetLocalClearanceOverrides(self, aSource: "wxString") -> "int":
        r"""GetLocalClearanceOverrides(BOARD_CONNECTED_ITEM self, wxString aSource) -> int"""
        return _pcbnew.BOARD_CONNECTED_ITEM_GetLocalClearanceOverrides(self, aSource)

    def GetLocalClearance(self, aSource: "wxString") -> "int":
        r"""GetLocalClearance(BOARD_CONNECTED_ITEM self, wxString aSource) -> int"""
        return _pcbnew.BOARD_CONNECTED_ITEM_GetLocalClearance(self, aSource)

    def GetNetClass(self) -> "NETCLASS *":
        r"""GetNetClass(BOARD_CONNECTED_ITEM self) -> NETCLASS *"""
        return _pcbnew.BOARD_CONNECTED_ITEM_GetNetClass(self)

    def GetEffectiveNetclass(self) -> "NETCLASS *":
        r"""GetEffectiveNetclass(BOARD_CONNECTED_ITEM self) -> NETCLASS *"""
        return _pcbnew.BOARD_CONNECTED_ITEM_GetEffectiveNetclass(self)

    def GetNetClassName(self) -> "wxString":
        r"""GetNetClassName(BOARD_CONNECTED_ITEM self) -> wxString"""
        return _pcbnew.BOARD_CONNECTED_ITEM_GetNetClassName(self)

    def SetLocalRatsnestVisible(self, aVisible: "bool") -> "void":
        r"""SetLocalRatsnestVisible(BOARD_CONNECTED_ITEM self, bool aVisible)"""
        return _pcbnew.BOARD_CONNECTED_ITEM_SetLocalRatsnestVisible(self, aVisible)

    def GetLocalRatsnestVisible(self) -> "bool":
        r"""GetLocalRatsnestVisible(BOARD_CONNECTED_ITEM self) -> bool"""
        return _pcbnew.BOARD_CONNECTED_ITEM_GetLocalRatsnestVisible(self)
    __swig_destroy__ = _pcbnew.delete_BOARD_CONNECTED_ITEM

# Register BOARD_CONNECTED_ITEM in _pcbnew:
_pcbnew.BOARD_CONNECTED_ITEM_swigregister(BOARD_CONNECTED_ITEM)

def BOARD_CONNECTED_ITEM_ClassOf(aItem: "EDA_ITEM") -> "bool":
    r"""BOARD_CONNECTED_ITEM_ClassOf(EDA_ITEM aItem) -> bool"""
    return _pcbnew.BOARD_CONNECTED_ITEM_ClassOf(aItem)

DEFAULT_SILK_LINE_WIDTH = _pcbnew.DEFAULT_SILK_LINE_WIDTH

DEFAULT_COPPER_LINE_WIDTH = _pcbnew.DEFAULT_COPPER_LINE_WIDTH

DEFAULT_EDGE_WIDTH = _pcbnew.DEFAULT_EDGE_WIDTH

DEFAULT_COURTYARD_WIDTH = _pcbnew.DEFAULT_COURTYARD_WIDTH

DEFAULT_LINE_WIDTH = _pcbnew.DEFAULT_LINE_WIDTH

DEFAULT_SILK_TEXT_SIZE = _pcbnew.DEFAULT_SILK_TEXT_SIZE

DEFAULT_COPPER_TEXT_SIZE = _pcbnew.DEFAULT_COPPER_TEXT_SIZE

DEFAULT_TEXT_SIZE = _pcbnew.DEFAULT_TEXT_SIZE

DEFAULT_SILK_TEXT_WIDTH = _pcbnew.DEFAULT_SILK_TEXT_WIDTH

DEFAULT_COPPER_TEXT_WIDTH = _pcbnew.DEFAULT_COPPER_TEXT_WIDTH

DEFAULT_TEXT_WIDTH = _pcbnew.DEFAULT_TEXT_WIDTH

DEFAULT_DIMENSION_ARROW_LENGTH = _pcbnew.DEFAULT_DIMENSION_ARROW_LENGTH

DEFAULT_DIMENSION_EXTENSION_OFFSET = _pcbnew.DEFAULT_DIMENSION_EXTENSION_OFFSET

DEFAULT_BOARD_THICKNESS_MM = _pcbnew.DEFAULT_BOARD_THICKNESS_MM

DEFAULT_PCB_EDGE_THICKNESS = _pcbnew.DEFAULT_PCB_EDGE_THICKNESS

DEFAULT_SOLDERMASK_CLEARANCE = _pcbnew.DEFAULT_SOLDERMASK_CLEARANCE

DEFAULT_SOLDERMASK_MIN_WIDTH = _pcbnew.DEFAULT_SOLDERMASK_MIN_WIDTH

DEFAULT_SOLDERPASTE_CLEARANCE = _pcbnew.DEFAULT_SOLDERPASTE_CLEARANCE

DEFAULT_SOLDERPASTE_RATIO = _pcbnew.DEFAULT_SOLDERPASTE_RATIO

DEFAULT_CUSTOMTRACKWIDTH = _pcbnew.DEFAULT_CUSTOMTRACKWIDTH

DEFAULT_CUSTOMDPAIRWIDTH = _pcbnew.DEFAULT_CUSTOMDPAIRWIDTH

DEFAULT_CUSTOMDPAIRGAP = _pcbnew.DEFAULT_CUSTOMDPAIRGAP

DEFAULT_CUSTOMDPAIRVIAGAP = _pcbnew.DEFAULT_CUSTOMDPAIRVIAGAP

DEFAULT_MINCLEARANCE = _pcbnew.DEFAULT_MINCLEARANCE

DEFAULT_TRACKMINWIDTH = _pcbnew.DEFAULT_TRACKMINWIDTH

DEFAULT_VIASMINSIZE = _pcbnew.DEFAULT_VIASMINSIZE

DEFAULT_MINTHROUGHDRILL = _pcbnew.DEFAULT_MINTHROUGHDRILL

DEFAULT_MICROVIASMINSIZE = _pcbnew.DEFAULT_MICROVIASMINSIZE

DEFAULT_MICROVIASMINDRILL = _pcbnew.DEFAULT_MICROVIASMINDRILL

DEFAULT_HOLETOHOLEMIN = _pcbnew.DEFAULT_HOLETOHOLEMIN

DEFAULT_HOLECLEARANCE = _pcbnew.DEFAULT_HOLECLEARANCE

DEFAULT_COPPEREDGECLEARANCE = _pcbnew.DEFAULT_COPPEREDGECLEARANCE

LEGACY_COPPEREDGECLEARANCE = _pcbnew.LEGACY_COPPEREDGECLEARANCE

DEFAULT_SILKCLEARANCE = _pcbnew.DEFAULT_SILKCLEARANCE

MINIMUM_ERROR_SIZE_MM = _pcbnew.MINIMUM_ERROR_SIZE_MM

MAXIMUM_ERROR_SIZE_MM = _pcbnew.MAXIMUM_ERROR_SIZE_MM

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    m_Diameter = property(_pcbnew.VIA_DIMENSION_m_Diameter_get, _pcbnew.VIA_DIMENSION_m_Diameter_set, doc=r"""m_Diameter : int""")
    m_Drill = property(_pcbnew.VIA_DIMENSION_m_Drill_get, _pcbnew.VIA_DIMENSION_m_Drill_set, doc=r"""m_Drill : int""")

    def __init__(self, *args):
        r"""
        __init__(VIA_DIMENSION self) -> VIA_DIMENSION
        __init__(VIA_DIMENSION self, int aDiameter, int aDrill) -> VIA_DIMENSION
        """
        _pcbnew.VIA_DIMENSION_swiginit(self, _pcbnew.new_VIA_DIMENSION(*args))

    def __eq__(self, aOther: "VIA_DIMENSION") -> "bool":
        r"""__eq__(VIA_DIMENSION self, VIA_DIMENSION aOther) -> bool"""
        return _pcbnew.VIA_DIMENSION___eq__(self, aOther)

    def __lt__(self, aOther: "VIA_DIMENSION") -> "bool":
        r"""__lt__(VIA_DIMENSION self, VIA_DIMENSION aOther) -> bool"""
        return _pcbnew.VIA_DIMENSION___lt__(self, aOther)
    __swig_destroy__ = _pcbnew.delete_VIA_DIMENSION

# Register VIA_DIMENSION in _pcbnew:
_pcbnew.VIA_DIMENSION_swigregister(VIA_DIMENSION)

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    m_Width = property(_pcbnew.DIFF_PAIR_DIMENSION_m_Width_get, _pcbnew.DIFF_PAIR_DIMENSION_m_Width_set, doc=r"""m_Width : int""")
    m_Gap = property(_pcbnew.DIFF_PAIR_DIMENSION_m_Gap_get, _pcbnew.DIFF_PAIR_DIMENSION_m_Gap_set, doc=r"""m_Gap : int""")
    m_ViaGap = property(_pcbnew.DIFF_PAIR_DIMENSION_m_ViaGap_get, _pcbnew.DIFF_PAIR_DIMENSION_m_ViaGap_set, doc=r"""m_ViaGap : int""")

    def __init__(self, *args):
        r"""
        __init__(DIFF_PAIR_DIMENSION self) -> DIFF_PAIR_DIMENSION
        __init__(DIFF_PAIR_DIMENSION self, int aWidth, int aGap, int aViaGap) -> DIFF_PAIR_DIMENSION
        """
        _pcbnew.DIFF_PAIR_DIMENSION_swiginit(self, _pcbnew.new_DIFF_PAIR_DIMENSION(*args))

    def __eq__(self, aOther: "DIFF_PAIR_DIMENSION") -> "bool":
        r"""__eq__(DIFF_PAIR_DIMENSION self, DIFF_PAIR_DIMENSION aOther) -> bool"""
        return _pcbnew.DIFF_PAIR_DIMENSION___eq__(self, aOther)

    def __lt__(self, aOther: "DIFF_PAIR_DIMENSION") -> "bool":
        r"""__lt__(DIFF_PAIR_DIMENSION self, DIFF_PAIR_DIMENSION aOther) -> bool"""
        return _pcbnew.DIFF_PAIR_DIMENSION___lt__(self, aOther)
    __swig_destroy__ = _pcbnew.delete_DIFF_PAIR_DIMENSION

# Register DIFF_PAIR_DIMENSION in _pcbnew:
_pcbnew.DIFF_PAIR_DIMENSION_swigregister(DIFF_PAIR_DIMENSION)

LAYER_CLASS_SILK = _pcbnew.LAYER_CLASS_SILK

LAYER_CLASS_COPPER = _pcbnew.LAYER_CLASS_COPPER

LAYER_CLASS_EDGES = _pcbnew.LAYER_CLASS_EDGES

LAYER_CLASS_COURTYARD = _pcbnew.LAYER_CLASS_COURTYARD

LAYER_CLASS_FAB = _pcbnew.LAYER_CLASS_FAB

LAYER_CLASS_OTHERS = _pcbnew.LAYER_CLASS_OTHERS

LAYER_CLASS_COUNT = _pcbnew.LAYER_CLASS_COUNT

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    m_Text = property(_pcbnew.TEXT_ITEM_INFO_m_Text_get, _pcbnew.TEXT_ITEM_INFO_m_Text_set, doc=r"""m_Text : wxString""")
    m_Visible = property(_pcbnew.TEXT_ITEM_INFO_m_Visible_get, _pcbnew.TEXT_ITEM_INFO_m_Visible_set, doc=r"""m_Visible : bool""")
    m_Layer = property(_pcbnew.TEXT_ITEM_INFO_m_Layer_get, _pcbnew.TEXT_ITEM_INFO_m_Layer_set, doc=r"""m_Layer : int""")

    def __init__(self, aText: "wxString", aVisible: "bool", aLayer: "int"):
        r"""__init__(TEXT_ITEM_INFO self, wxString aText, bool aVisible, int aLayer) -> TEXT_ITEM_INFO"""
        _pcbnew.TEXT_ITEM_INFO_swiginit(self, _pcbnew.new_TEXT_ITEM_INFO(aText, aVisible, aLayer))
    __swig_destroy__ = _pcbnew.delete_TEXT_ITEM_INFO

# Register TEXT_ITEM_INFO in _pcbnew:
_pcbnew.TEXT_ITEM_INFO_swigregister(TEXT_ITEM_INFO)

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

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

    def __init__(self, *args):
        r"""
        __init__(BOARD_DESIGN_SETTINGS self, JSON_SETTINGS * aParent, string aPath) -> BOARD_DESIGN_SETTINGS
        __init__(BOARD_DESIGN_SETTINGS self, BOARD_DESIGN_SETTINGS aOther) -> BOARD_DESIGN_SETTINGS
        """
        _pcbnew.BOARD_DESIGN_SETTINGS_swiginit(self, _pcbnew.new_BOARD_DESIGN_SETTINGS(*args))

    def LoadFromFile(self, *args) -> "bool":
        r"""LoadFromFile(BOARD_DESIGN_SETTINGS self, wxString aDirectory="") -> bool"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_LoadFromFile(self, *args)

    def GetStackupDescriptor(self, *args) -> "BOARD_STACKUP const &":
        r"""
        GetStackupDescriptor(BOARD_DESIGN_SETTINGS self) -> BOARD_STACKUP
        GetStackupDescriptor(BOARD_DESIGN_SETTINGS self) -> BOARD_STACKUP const &
        """
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetStackupDescriptor(self, *args)

    def GetSeverity(self, aDRCErrorCode: "int") -> "SEVERITY":
        r"""GetSeverity(BOARD_DESIGN_SETTINGS self, int aDRCErrorCode) -> SEVERITY"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetSeverity(self, aDRCErrorCode)

    def Ignore(self, aDRCErrorCode: "int") -> "bool":
        r"""Ignore(BOARD_DESIGN_SETTINGS self, int aDRCErrorCode) -> bool"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_Ignore(self, aDRCErrorCode)

    def GetNetClasses(self) -> "NETCLASSES &":
        r"""GetNetClasses(BOARD_DESIGN_SETTINGS self) -> NETCLASSES"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetNetClasses(self)

    def SetNetClasses(self, aNetClasses: "NETCLASSES") -> "void":
        r"""SetNetClasses(BOARD_DESIGN_SETTINGS self, NETCLASSES aNetClasses)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetNetClasses(self, aNetClasses)

    def GetDefaultZoneSettings(self) -> "ZONE_SETTINGS &":
        r"""GetDefaultZoneSettings(BOARD_DESIGN_SETTINGS self) -> ZONE_SETTINGS"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetDefaultZoneSettings(self)

    def SetDefaultZoneSettings(self, aSettings: "ZONE_SETTINGS") -> "void":
        r"""SetDefaultZoneSettings(BOARD_DESIGN_SETTINGS self, ZONE_SETTINGS aSettings)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetDefaultZoneSettings(self, aSettings)

    def GetDefault(self) -> "NETCLASS *":
        r"""GetDefault(BOARD_DESIGN_SETTINGS self) -> NETCLASS *"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetDefault(self)

    def GetCurrentNetClassName(self) -> "wxString const &":
        r"""GetCurrentNetClassName(BOARD_DESIGN_SETTINGS self) -> wxString"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetCurrentNetClassName(self)

    def UseNetClassTrack(self) -> "bool":
        r"""UseNetClassTrack(BOARD_DESIGN_SETTINGS self) -> bool"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_UseNetClassTrack(self)

    def UseNetClassVia(self) -> "bool":
        r"""UseNetClassVia(BOARD_DESIGN_SETTINGS self) -> bool"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_UseNetClassVia(self)

    def UseNetClassDiffPair(self) -> "bool":
        r"""UseNetClassDiffPair(BOARD_DESIGN_SETTINGS self) -> bool"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_UseNetClassDiffPair(self)

    def GetBiggestClearanceValue(self) -> "int":
        r"""GetBiggestClearanceValue(BOARD_DESIGN_SETTINGS self) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetBiggestClearanceValue(self)

    def GetSmallestClearanceValue(self) -> "int":
        r"""GetSmallestClearanceValue(BOARD_DESIGN_SETTINGS self) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetSmallestClearanceValue(self)

    def GetCurrentMicroViaSize(self) -> "int":
        r"""GetCurrentMicroViaSize(BOARD_DESIGN_SETTINGS self) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetCurrentMicroViaSize(self)

    def GetCurrentMicroViaDrill(self) -> "int":
        r"""GetCurrentMicroViaDrill(BOARD_DESIGN_SETTINGS self) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetCurrentMicroViaDrill(self)

    def GetTrackWidthIndex(self) -> "unsigned int":
        r"""GetTrackWidthIndex(BOARD_DESIGN_SETTINGS self) -> unsigned int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetTrackWidthIndex(self)

    def SetTrackWidthIndex(self, aIndex: "unsigned int") -> "void":
        r"""SetTrackWidthIndex(BOARD_DESIGN_SETTINGS self, unsigned int aIndex)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetTrackWidthIndex(self, aIndex)

    def GetCurrentTrackWidth(self) -> "int":
        r"""GetCurrentTrackWidth(BOARD_DESIGN_SETTINGS self) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetCurrentTrackWidth(self)

    def SetCustomTrackWidth(self, aWidth: "int") -> "void":
        r"""SetCustomTrackWidth(BOARD_DESIGN_SETTINGS self, int aWidth)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetCustomTrackWidth(self, aWidth)

    def GetCustomTrackWidth(self) -> "int":
        r"""GetCustomTrackWidth(BOARD_DESIGN_SETTINGS self) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetCustomTrackWidth(self)

    def GetViaSizeIndex(self) -> "unsigned int":
        r"""GetViaSizeIndex(BOARD_DESIGN_SETTINGS self) -> unsigned int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetViaSizeIndex(self)

    def SetViaSizeIndex(self, aIndex: "unsigned int") -> "void":
        r"""SetViaSizeIndex(BOARD_DESIGN_SETTINGS self, unsigned int aIndex)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetViaSizeIndex(self, aIndex)

    def GetCurrentViaSize(self) -> "int":
        r"""GetCurrentViaSize(BOARD_DESIGN_SETTINGS self) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetCurrentViaSize(self)

    def SetCustomViaSize(self, aSize: "int") -> "void":
        r"""SetCustomViaSize(BOARD_DESIGN_SETTINGS self, int aSize)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetCustomViaSize(self, aSize)

    def GetCustomViaSize(self) -> "int":
        r"""GetCustomViaSize(BOARD_DESIGN_SETTINGS self) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetCustomViaSize(self)

    def GetCurrentViaDrill(self) -> "int":
        r"""GetCurrentViaDrill(BOARD_DESIGN_SETTINGS self) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetCurrentViaDrill(self)

    def SetCustomViaDrill(self, aDrill: "int") -> "void":
        r"""SetCustomViaDrill(BOARD_DESIGN_SETTINGS self, int aDrill)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetCustomViaDrill(self, aDrill)

    def GetCustomViaDrill(self) -> "int":
        r"""GetCustomViaDrill(BOARD_DESIGN_SETTINGS self) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetCustomViaDrill(self)

    def UseCustomTrackViaSize(self, *args) -> "bool":
        r"""
        UseCustomTrackViaSize(BOARD_DESIGN_SETTINGS self, bool aEnabled)
        UseCustomTrackViaSize(BOARD_DESIGN_SETTINGS self) -> bool
        """
        return _pcbnew.BOARD_DESIGN_SETTINGS_UseCustomTrackViaSize(self, *args)

    def GetDiffPairIndex(self) -> "unsigned int":
        r"""GetDiffPairIndex(BOARD_DESIGN_SETTINGS self) -> unsigned int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetDiffPairIndex(self)

    def SetDiffPairIndex(self, aIndex: "unsigned int") -> "void":
        r"""SetDiffPairIndex(BOARD_DESIGN_SETTINGS self, unsigned int aIndex)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetDiffPairIndex(self, aIndex)

    def SetCustomDiffPairWidth(self, aWidth: "int") -> "void":
        r"""SetCustomDiffPairWidth(BOARD_DESIGN_SETTINGS self, int aWidth)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetCustomDiffPairWidth(self, aWidth)

    def GetCustomDiffPairWidth(self) -> "int":
        r"""GetCustomDiffPairWidth(BOARD_DESIGN_SETTINGS self) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetCustomDiffPairWidth(self)

    def SetCustomDiffPairGap(self, aGap: "int") -> "void":
        r"""SetCustomDiffPairGap(BOARD_DESIGN_SETTINGS self, int aGap)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetCustomDiffPairGap(self, aGap)

    def GetCustomDiffPairGap(self) -> "int":
        r"""GetCustomDiffPairGap(BOARD_DESIGN_SETTINGS self) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetCustomDiffPairGap(self)

    def SetCustomDiffPairViaGap(self, aGap: "int") -> "void":
        r"""SetCustomDiffPairViaGap(BOARD_DESIGN_SETTINGS self, int aGap)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetCustomDiffPairViaGap(self, aGap)

    def GetCustomDiffPairViaGap(self) -> "int":
        r"""GetCustomDiffPairViaGap(BOARD_DESIGN_SETTINGS self) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetCustomDiffPairViaGap(self)

    def UseCustomDiffPairDimensions(self, *args) -> "bool":
        r"""
        UseCustomDiffPairDimensions(BOARD_DESIGN_SETTINGS self, bool aEnabled)
        UseCustomDiffPairDimensions(BOARD_DESIGN_SETTINGS self) -> bool
        """
        return _pcbnew.BOARD_DESIGN_SETTINGS_UseCustomDiffPairDimensions(self, *args)

    def GetCurrentDiffPairWidth(self) -> "int":
        r"""GetCurrentDiffPairWidth(BOARD_DESIGN_SETTINGS self) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetCurrentDiffPairWidth(self)

    def GetCurrentDiffPairGap(self) -> "int":
        r"""GetCurrentDiffPairGap(BOARD_DESIGN_SETTINGS self) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetCurrentDiffPairGap(self)

    def GetCurrentDiffPairViaGap(self) -> "int":
        r"""GetCurrentDiffPairViaGap(BOARD_DESIGN_SETTINGS self) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetCurrentDiffPairViaGap(self)

    def SetMinHoleSeparation(self, aDistance: "int") -> "void":
        r"""SetMinHoleSeparation(BOARD_DESIGN_SETTINGS self, int aDistance)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetMinHoleSeparation(self, aDistance)

    def SetCopperEdgeClearance(self, aDistance: "int") -> "void":
        r"""SetCopperEdgeClearance(BOARD_DESIGN_SETTINGS self, int aDistance)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetCopperEdgeClearance(self, aDistance)

    def SetSilkClearance(self, aDistance: "int") -> "void":
        r"""SetSilkClearance(BOARD_DESIGN_SETTINGS self, int aDistance)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetSilkClearance(self, aDistance)

    def GetEnabledLayers(self) -> "LSET":
        r"""GetEnabledLayers(BOARD_DESIGN_SETTINGS self) -> LSET"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetEnabledLayers(self)

    def SetEnabledLayers(self, aMask: "LSET") -> "void":
        r"""SetEnabledLayers(BOARD_DESIGN_SETTINGS self, LSET aMask)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetEnabledLayers(self, aMask)

    def IsLayerEnabled(self, aLayerId: "PCB_LAYER_ID") -> "bool":
        r"""IsLayerEnabled(BOARD_DESIGN_SETTINGS self, PCB_LAYER_ID aLayerId) -> bool"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_IsLayerEnabled(self, aLayerId)

    def GetCopperLayerCount(self) -> "int":
        r"""GetCopperLayerCount(BOARD_DESIGN_SETTINGS self) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetCopperLayerCount(self)

    def SetCopperLayerCount(self, aNewLayerCount: "int") -> "void":
        r"""SetCopperLayerCount(BOARD_DESIGN_SETTINGS self, int aNewLayerCount)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetCopperLayerCount(self, aNewLayerCount)

    def GetBoardThickness(self) -> "int":
        r"""GetBoardThickness(BOARD_DESIGN_SETTINGS self) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetBoardThickness(self)

    def SetBoardThickness(self, aThickness: "int") -> "void":
        r"""SetBoardThickness(BOARD_DESIGN_SETTINGS self, int aThickness)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetBoardThickness(self, aThickness)

    def GetDRCEpsilon(self) -> "int":
        r"""GetDRCEpsilon(BOARD_DESIGN_SETTINGS self) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetDRCEpsilon(self)

    def GetHolePlatingThickness(self) -> "int":
        r"""GetHolePlatingThickness(BOARD_DESIGN_SETTINGS self) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetHolePlatingThickness(self)

    def GetLineThickness(self, aLayer: "PCB_LAYER_ID") -> "int":
        r"""GetLineThickness(BOARD_DESIGN_SETTINGS self, PCB_LAYER_ID aLayer) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetLineThickness(self, aLayer)

    def GetTextSize(self, aLayer: "PCB_LAYER_ID") -> "wxSize":
        r"""GetTextSize(BOARD_DESIGN_SETTINGS self, PCB_LAYER_ID aLayer) -> wxSize"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetTextSize(self, aLayer)

    def GetTextThickness(self, aLayer: "PCB_LAYER_ID") -> "int":
        r"""GetTextThickness(BOARD_DESIGN_SETTINGS self, PCB_LAYER_ID aLayer) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetTextThickness(self, aLayer)

    def GetTextItalic(self, aLayer: "PCB_LAYER_ID") -> "bool":
        r"""GetTextItalic(BOARD_DESIGN_SETTINGS self, PCB_LAYER_ID aLayer) -> bool"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetTextItalic(self, aLayer)

    def GetTextUpright(self, aLayer: "PCB_LAYER_ID") -> "bool":
        r"""GetTextUpright(BOARD_DESIGN_SETTINGS self, PCB_LAYER_ID aLayer) -> bool"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetTextUpright(self, aLayer)

    def GetLayerClass(self, aLayer: "PCB_LAYER_ID") -> "int":
        r"""GetLayerClass(BOARD_DESIGN_SETTINGS self, PCB_LAYER_ID aLayer) -> int"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetLayerClass(self, aLayer)

    def SetAuxOrigin(self, aOrigin: "wxPoint") -> "void":
        r"""SetAuxOrigin(BOARD_DESIGN_SETTINGS self, wxPoint aOrigin)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetAuxOrigin(self, aOrigin)

    def GetAuxOrigin(self) -> "wxPoint const &":
        r"""GetAuxOrigin(BOARD_DESIGN_SETTINGS self) -> wxPoint"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetAuxOrigin(self)

    def SetGridOrigin(self, aOrigin: "wxPoint") -> "void":
        r"""SetGridOrigin(BOARD_DESIGN_SETTINGS self, wxPoint aOrigin)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_SetGridOrigin(self, aOrigin)

    def GetGridOrigin(self) -> "wxPoint const &":
        r"""GetGridOrigin(BOARD_DESIGN_SETTINGS self) -> wxPoint"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_GetGridOrigin(self)
    m_TrackWidthList = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_TrackWidthList_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_TrackWidthList_set, doc=r"""m_TrackWidthList : std::vector<(int,std::allocator<(int)>)>""")
    m_ViasDimensionsList = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_ViasDimensionsList_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_ViasDimensionsList_set, doc=r"""m_ViasDimensionsList : std::vector<(VIA_DIMENSION,std::allocator<(VIA_DIMENSION)>)>""")
    m_DiffPairDimensionsList = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_DiffPairDimensionsList_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_DiffPairDimensionsList_set, doc=r"""m_DiffPairDimensionsList : std::vector<(DIFF_PAIR_DIMENSION,std::allocator<(DIFF_PAIR_DIMENSION)>)>""")
    m_MicroViasAllowed = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_MicroViasAllowed_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_MicroViasAllowed_set, doc=r"""m_MicroViasAllowed : bool""")
    m_BlindBuriedViaAllowed = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_BlindBuriedViaAllowed_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_BlindBuriedViaAllowed_set, doc=r"""m_BlindBuriedViaAllowed : bool""")
    m_CurrentViaType = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_CurrentViaType_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_CurrentViaType_set, doc=r"""m_CurrentViaType : VIATYPE""")
    m_UseConnectedTrackWidth = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_UseConnectedTrackWidth_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_UseConnectedTrackWidth_set, doc=r"""m_UseConnectedTrackWidth : bool""")
    m_TempOverrideTrackWidth = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_TempOverrideTrackWidth_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_TempOverrideTrackWidth_set, doc=r"""m_TempOverrideTrackWidth : bool""")
    m_MinClearance = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_MinClearance_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_MinClearance_set, doc=r"""m_MinClearance : int""")
    m_TrackMinWidth = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_TrackMinWidth_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_TrackMinWidth_set, doc=r"""m_TrackMinWidth : int""")
    m_ViasMinAnnularWidth = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_ViasMinAnnularWidth_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_ViasMinAnnularWidth_set, doc=r"""m_ViasMinAnnularWidth : int""")
    m_ViasMinSize = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_ViasMinSize_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_ViasMinSize_set, doc=r"""m_ViasMinSize : int""")
    m_MinThroughDrill = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_MinThroughDrill_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_MinThroughDrill_set, doc=r"""m_MinThroughDrill : int""")
    m_MicroViasMinSize = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_MicroViasMinSize_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_MicroViasMinSize_set, doc=r"""m_MicroViasMinSize : int""")
    m_MicroViasMinDrill = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_MicroViasMinDrill_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_MicroViasMinDrill_set, doc=r"""m_MicroViasMinDrill : int""")
    m_CopperEdgeClearance = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_CopperEdgeClearance_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_CopperEdgeClearance_set, doc=r"""m_CopperEdgeClearance : int""")
    m_HoleClearance = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_HoleClearance_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_HoleClearance_set, doc=r"""m_HoleClearance : int""")
    m_HoleToHoleMin = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_HoleToHoleMin_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_HoleToHoleMin_set, doc=r"""m_HoleToHoleMin : int""")
    m_SilkClearance = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_SilkClearance_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_SilkClearance_set, doc=r"""m_SilkClearance : int""")
    m_DRCSeverities = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_DRCSeverities_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_DRCSeverities_set, doc=r"""m_DRCSeverities : std::map<(int,SEVERITY,std::less<(int)>,std::allocator<(std::pair<(q(const).int,SEVERITY)>)>)>""")
    m_DrcExclusions = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_DrcExclusions_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_DrcExclusions_set, doc=r"""m_DrcExclusions : std::set<(wxString,std::less<(wxString)>,std::allocator<(wxString)>)>""")
    m_ZoneFillVersion = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_ZoneFillVersion_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_ZoneFillVersion_set, doc=r"""m_ZoneFillVersion : int""")
    m_ZoneKeepExternalFillets = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_ZoneKeepExternalFillets_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_ZoneKeepExternalFillets_set, doc=r"""m_ZoneKeepExternalFillets : bool""")
    m_MaxError = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_MaxError_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_MaxError_set, doc=r"""m_MaxError : int""")
    m_SolderMaskMargin = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_SolderMaskMargin_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_SolderMaskMargin_set, doc=r"""m_SolderMaskMargin : int""")
    m_SolderMaskMinWidth = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_SolderMaskMinWidth_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_SolderMaskMinWidth_set, doc=r"""m_SolderMaskMinWidth : int""")
    m_SolderPasteMargin = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_SolderPasteMargin_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_SolderPasteMargin_set, doc=r"""m_SolderPasteMargin : int""")
    m_SolderPasteMarginRatio = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_SolderPasteMarginRatio_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_SolderPasteMarginRatio_set, doc=r"""m_SolderPasteMarginRatio : double""")
    m_DefaultFPTextItems = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_DefaultFPTextItems_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_DefaultFPTextItems_set, doc=r"""m_DefaultFPTextItems : std::vector<(TEXT_ITEM_INFO,std::allocator<(TEXT_ITEM_INFO)>)>""")
    m_LineThickness = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_LineThickness_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_LineThickness_set, doc=r"""m_LineThickness : a(LAYER_CLASS_COUNT).int""")
    m_TextSize = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_TextSize_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_TextSize_set, doc=r"""m_TextSize : a(LAYER_CLASS_COUNT).wxSize""")
    m_TextThickness = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_TextThickness_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_TextThickness_set, doc=r"""m_TextThickness : a(LAYER_CLASS_COUNT).int""")
    m_TextItalic = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_TextItalic_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_TextItalic_set, doc=r"""m_TextItalic : a(LAYER_CLASS_COUNT).bool""")
    m_TextUpright = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_TextUpright_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_TextUpright_set, doc=r"""m_TextUpright : a(LAYER_CLASS_COUNT).bool""")
    m_DimensionUnitsMode = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_DimensionUnitsMode_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_DimensionUnitsMode_set, doc=r"""m_DimensionUnitsMode : DIM_UNITS_MODE""")
    m_DimensionPrecision = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_DimensionPrecision_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_DimensionPrecision_set, doc=r"""m_DimensionPrecision : int""")
    m_DimensionUnitsFormat = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_DimensionUnitsFormat_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_DimensionUnitsFormat_set, doc=r"""m_DimensionUnitsFormat : DIM_UNITS_FORMAT""")
    m_DimensionSuppressZeroes = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_DimensionSuppressZeroes_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_DimensionSuppressZeroes_set, doc=r"""m_DimensionSuppressZeroes : bool""")
    m_DimensionTextPosition = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_DimensionTextPosition_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_DimensionTextPosition_set, doc=r"""m_DimensionTextPosition : DIM_TEXT_POSITION""")
    m_DimensionKeepTextAligned = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_DimensionKeepTextAligned_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_DimensionKeepTextAligned_set, doc=r"""m_DimensionKeepTextAligned : bool""")
    m_DimensionArrowLength = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_DimensionArrowLength_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_DimensionArrowLength_set, doc=r"""m_DimensionArrowLength : int""")
    m_DimensionExtensionOffset = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_DimensionExtensionOffset_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_DimensionExtensionOffset_set, doc=r"""m_DimensionExtensionOffset : int""")
    m_HasStackup = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_HasStackup_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_HasStackup_set, doc=r"""m_HasStackup : bool""")
    m_UseHeightForLengthCalcs = property(_pcbnew.BOARD_DESIGN_SETTINGS_m_UseHeightForLengthCalcs_get, _pcbnew.BOARD_DESIGN_SETTINGS_m_UseHeightForLengthCalcs_set, doc=r"""m_UseHeightForLengthCalcs : bool""")

    def CloneFrom(self, aOther: "BOARD_DESIGN_SETTINGS") -> "void":
        r"""CloneFrom(BOARD_DESIGN_SETTINGS self, BOARD_DESIGN_SETTINGS aOther)"""
        return _pcbnew.BOARD_DESIGN_SETTINGS_CloneFrom(self, aOther)

# Register BOARD_DESIGN_SETTINGS in _pcbnew:
_pcbnew.BOARD_DESIGN_SETTINGS_swigregister(BOARD_DESIGN_SETTINGS)

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    net = property(_pcbnew.CN_DISJOINT_NET_ENTRY_net_get, _pcbnew.CN_DISJOINT_NET_ENTRY_net_set, doc=r"""net : int""")
    a = property(_pcbnew.CN_DISJOINT_NET_ENTRY_a_get, _pcbnew.CN_DISJOINT_NET_ENTRY_a_set, doc=r"""a : p.BOARD_CONNECTED_ITEM""")
    b = property(_pcbnew.CN_DISJOINT_NET_ENTRY_b_get, _pcbnew.CN_DISJOINT_NET_ENTRY_b_set, doc=r"""b : p.BOARD_CONNECTED_ITEM""")
    anchorA = property(_pcbnew.CN_DISJOINT_NET_ENTRY_anchorA_get, _pcbnew.CN_DISJOINT_NET_ENTRY_anchorA_set, doc=r"""anchorA : VECTOR2I""")
    anchorB = property(_pcbnew.CN_DISJOINT_NET_ENTRY_anchorB_get, _pcbnew.CN_DISJOINT_NET_ENTRY_anchorB_set, doc=r"""anchorB : VECTOR2I""")

    def __init__(self):
        r"""__init__(CN_DISJOINT_NET_ENTRY self) -> CN_DISJOINT_NET_ENTRY"""
        _pcbnew.CN_DISJOINT_NET_ENTRY_swiginit(self, _pcbnew.new_CN_DISJOINT_NET_ENTRY())
    __swig_destroy__ = _pcbnew.delete_CN_DISJOINT_NET_ENTRY

# Register CN_DISJOINT_NET_ENTRY in _pcbnew:
_pcbnew.CN_DISJOINT_NET_ENTRY_swigregister(CN_DISJOINT_NET_ENTRY)

class CN_ZONE_ISOLATED_ISLAND_LIST(object):
    r"""Proxy of C++ CN_ZONE_ISOLATED_ISLAND_LIST 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, aZone: "ZONE"):
        r"""__init__(CN_ZONE_ISOLATED_ISLAND_LIST self, ZONE aZone) -> CN_ZONE_ISOLATED_ISLAND_LIST"""
        _pcbnew.CN_ZONE_ISOLATED_ISLAND_LIST_swiginit(self, _pcbnew.new_CN_ZONE_ISOLATED_ISLAND_LIST(aZone))
    m_zone = property(_pcbnew.CN_ZONE_ISOLATED_ISLAND_LIST_m_zone_get, _pcbnew.CN_ZONE_ISOLATED_ISLAND_LIST_m_zone_set, doc=r"""m_zone : p.ZONE""")
    m_islands = property(_pcbnew.CN_ZONE_ISOLATED_ISLAND_LIST_m_islands_get, _pcbnew.CN_ZONE_ISOLATED_ISLAND_LIST_m_islands_set, doc=r"""m_islands : std::map<(PCB_LAYER_ID,std::vector<(int,std::allocator<(int)>)>,std::less<(PCB_LAYER_ID)>,std::allocator<(std::pair<(q(const).PCB_LAYER_ID,std::vector<(int,std::allocator<(int)>)>)>)>)>""")
    __swig_destroy__ = _pcbnew.delete_CN_ZONE_ISOLATED_ISLAND_LIST

# Register CN_ZONE_ISOLATED_ISLAND_LIST in _pcbnew:
_pcbnew.CN_ZONE_ISOLATED_ISLAND_LIST_swigregister(CN_ZONE_ISOLATED_ISLAND_LIST)

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    netCode = property(_pcbnew.RN_DYNAMIC_LINE_netCode_get, _pcbnew.RN_DYNAMIC_LINE_netCode_set, doc=r"""netCode : int""")
    a = property(_pcbnew.RN_DYNAMIC_LINE_a_get, _pcbnew.RN_DYNAMIC_LINE_a_set, doc=r"""a : VECTOR2I""")
    b = property(_pcbnew.RN_DYNAMIC_LINE_b_get, _pcbnew.RN_DYNAMIC_LINE_b_set, doc=r"""b : VECTOR2I""")

    def __init__(self):
        r"""__init__(RN_DYNAMIC_LINE self) -> RN_DYNAMIC_LINE"""
        _pcbnew.RN_DYNAMIC_LINE_swiginit(self, _pcbnew.new_RN_DYNAMIC_LINE())
    __swig_destroy__ = _pcbnew.delete_RN_DYNAMIC_LINE

# Register RN_DYNAMIC_LINE in _pcbnew:
_pcbnew.RN_DYNAMIC_LINE_swigregister(RN_DYNAMIC_LINE)

PROPAGATE_MODE_SKIP_CONFLICTS = _pcbnew.PROPAGATE_MODE_SKIP_CONFLICTS

PROPAGATE_MODE_RESOLVE_CONFLICTS = _pcbnew.PROPAGATE_MODE_RESOLVE_CONFLICTS

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

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

    def __init__(self, *args):
        r"""
        __init__(CONNECTIVITY_DATA self) -> CONNECTIVITY_DATA
        __init__(CONNECTIVITY_DATA self, std::vector< BOARD_ITEM *,std::allocator< BOARD_ITEM * > > const & aItems, bool aSkipItems=False) -> CONNECTIVITY_DATA
        """
        _pcbnew.CONNECTIVITY_DATA_swiginit(self, _pcbnew.new_CONNECTIVITY_DATA(*args))

    def Build(self, *args) -> "void":
        r"""
        Build(CONNECTIVITY_DATA self, BOARD aBoard, PROGRESS_REPORTER * aReporter=None)
        Build(CONNECTIVITY_DATA self, std::vector< BOARD_ITEM *,std::allocator< BOARD_ITEM * > > const & aItems)
        """
        return _pcbnew.CONNECTIVITY_DATA_Build(self, *args)

    def Add(self, aItem: "BOARD_ITEM") -> "bool":
        r"""Add(CONNECTIVITY_DATA self, BOARD_ITEM aItem) -> bool"""
        return _pcbnew.CONNECTIVITY_DATA_Add(self, aItem)

    def Remove(self, aItem: "BOARD_ITEM") -> "bool":
        r"""Remove(CONNECTIVITY_DATA self, BOARD_ITEM aItem) -> bool"""
        return _pcbnew.CONNECTIVITY_DATA_Remove(self, aItem)

    def Update(self, aItem: "BOARD_ITEM") -> "bool":
        r"""Update(CONNECTIVITY_DATA self, BOARD_ITEM aItem) -> bool"""
        return _pcbnew.CONNECTIVITY_DATA_Update(self, aItem)

    def Move(self, aDelta: "VECTOR2I") -> "void":
        r"""Move(CONNECTIVITY_DATA self, VECTOR2I aDelta)"""
        return _pcbnew.CONNECTIVITY_DATA_Move(self, aDelta)

    def Clear(self) -> "void":
        r"""Clear(CONNECTIVITY_DATA self)"""
        return _pcbnew.CONNECTIVITY_DATA_Clear(self)

    def GetNetCount(self) -> "int":
        r"""GetNetCount(CONNECTIVITY_DATA self) -> int"""
        return _pcbnew.CONNECTIVITY_DATA_GetNetCount(self)

    def GetRatsnestForNet(self, aNet: "int") -> "RN_NET *":
        r"""GetRatsnestForNet(CONNECTIVITY_DATA self, int aNet) -> RN_NET *"""
        return _pcbnew.CONNECTIVITY_DATA_GetRatsnestForNet(self, aNet)

    def PropagateNets(self, *args) -> "void":
        r"""PropagateNets(CONNECTIVITY_DATA self, BOARD_COMMIT * aCommit=None, PROPAGATE_MODE aMode=SKIP_CONFLICTS)"""
        return _pcbnew.CONNECTIVITY_DATA_PropagateNets(self, *args)

    def CheckConnectivity(self, aReport: "std::vector< CN_DISJOINT_NET_ENTRY,std::allocator< CN_DISJOINT_NET_ENTRY > > &") -> "bool":
        r"""CheckConnectivity(CONNECTIVITY_DATA self, std::vector< CN_DISJOINT_NET_ENTRY,std::allocator< CN_DISJOINT_NET_ENTRY > > & aReport) -> bool"""
        return _pcbnew.CONNECTIVITY_DATA_CheckConnectivity(self, aReport)

    def FindIsolatedCopperIslands(self, *args) -> "void":
        r"""
        FindIsolatedCopperIslands(CONNECTIVITY_DATA self, ZONE aZone, intVector aIslands)
        FindIsolatedCopperIslands(CONNECTIVITY_DATA self, std::vector< CN_ZONE_ISOLATED_ISLAND_LIST,std::allocator< CN_ZONE_ISOLATED_ISLAND_LIST > > & aZones)
        """
        return _pcbnew.CONNECTIVITY_DATA_FindIsolatedCopperIslands(self, *args)

    def RecalculateRatsnest(self, aCommit: "BOARD_COMMIT *"=None) -> "void":
        r"""RecalculateRatsnest(CONNECTIVITY_DATA self, BOARD_COMMIT * aCommit=None)"""
        return _pcbnew.CONNECTIVITY_DATA_RecalculateRatsnest(self, aCommit)

    def GetUnconnectedCount(self) -> "unsigned int":
        r"""GetUnconnectedCount(CONNECTIVITY_DATA self) -> unsigned int"""
        return _pcbnew.CONNECTIVITY_DATA_GetUnconnectedCount(self)

    def IsConnectedOnLayer(self, *args) -> "bool":
        r"""IsConnectedOnLayer(CONNECTIVITY_DATA self, BOARD_CONNECTED_ITEM aItem, int aLayer, std::vector< KICAD_T,std::allocator< KICAD_T > > aTypes={}, bool aCheckOptionalFlashing=False) -> bool"""
        return _pcbnew.CONNECTIVITY_DATA_IsConnectedOnLayer(self, *args)

    def GetNodeCount(self, aNet: "int"=-1) -> "unsigned int":
        r"""GetNodeCount(CONNECTIVITY_DATA self, int aNet=-1) -> unsigned int"""
        return _pcbnew.CONNECTIVITY_DATA_GetNodeCount(self, aNet)

    def GetPadCount(self, aNet: "int"=-1) -> "unsigned int":
        r"""GetPadCount(CONNECTIVITY_DATA self, int aNet=-1) -> unsigned int"""
        return _pcbnew.CONNECTIVITY_DATA_GetPadCount(self, aNet)

    def GetConnectedTracks(self, aItem: "BOARD_CONNECTED_ITEM") -> "std::vector< PCB_TRACK *,std::allocator< PCB_TRACK * > > const":
        r"""GetConnectedTracks(CONNECTIVITY_DATA self, BOARD_CONNECTED_ITEM aItem) -> TRACKS_VEC"""
        return _pcbnew.CONNECTIVITY_DATA_GetConnectedTracks(self, aItem)

    def GetConnectedPads(self, *args) -> "void":
        r"""
        GetConnectedPads(CONNECTIVITY_DATA self, BOARD_CONNECTED_ITEM aItem) -> PADS_VEC
        GetConnectedPads(CONNECTIVITY_DATA self, BOARD_CONNECTED_ITEM aItem, std::set< PAD *,std::less< PAD * >,std::allocator< PAD * > > * pads)
        """
        return _pcbnew.CONNECTIVITY_DATA_GetConnectedPads(self, *args)

    def GetConnectedItemsAtAnchor(self, aItem: "BOARD_CONNECTED_ITEM", aAnchor: "VECTOR2I", aTypes: "KICAD_T const []", aMaxError: "int const &"=0) -> "std::vector< BOARD_CONNECTED_ITEM *,std::allocator< BOARD_CONNECTED_ITEM * > > const":
        r"""GetConnectedItemsAtAnchor(CONNECTIVITY_DATA self, BOARD_CONNECTED_ITEM aItem, VECTOR2I aAnchor, KICAD_T const [] aTypes, int const & aMaxError=0) -> std::vector< BOARD_CONNECTED_ITEM *,std::allocator< BOARD_CONNECTED_ITEM * > > const"""
        return _pcbnew.CONNECTIVITY_DATA_GetConnectedItemsAtAnchor(self, aItem, aAnchor, aTypes, aMaxError)

    def GetUnconnectedEdges(self, aEdges: "std::vector< CN_EDGE,std::allocator< CN_EDGE > > &") -> "void":
        r"""GetUnconnectedEdges(CONNECTIVITY_DATA self, std::vector< CN_EDGE,std::allocator< CN_EDGE > > & aEdges)"""
        return _pcbnew.CONNECTIVITY_DATA_GetUnconnectedEdges(self, aEdges)

    def TestTrackEndpointDangling(self, aTrack: "PCB_TRACK", aPos: "wxPoint"=None) -> "bool":
        r"""TestTrackEndpointDangling(CONNECTIVITY_DATA self, PCB_TRACK aTrack, wxPoint aPos=None) -> bool"""
        return _pcbnew.CONNECTIVITY_DATA_TestTrackEndpointDangling(self, aTrack, aPos)

    def ClearDynamicRatsnest(self) -> "void":
        r"""ClearDynamicRatsnest(CONNECTIVITY_DATA self)"""
        return _pcbnew.CONNECTIVITY_DATA_ClearDynamicRatsnest(self)

    def HideDynamicRatsnest(self) -> "void":
        r"""HideDynamicRatsnest(CONNECTIVITY_DATA self)"""
        return _pcbnew.CONNECTIVITY_DATA_HideDynamicRatsnest(self)

    def ComputeDynamicRatsnest(self, *args) -> "void":
        r"""ComputeDynamicRatsnest(CONNECTIVITY_DATA self, std::vector< BOARD_ITEM *,std::allocator< BOARD_ITEM * > > const & aItems, CONNECTIVITY_DATA aDynamicData, VECTOR2I aInternalOffset={ 0, 0 })"""
        return _pcbnew.CONNECTIVITY_DATA_ComputeDynamicRatsnest(self, *args)

    def GetDynamicRatsnest(self) -> "std::vector< RN_DYNAMIC_LINE,std::allocator< RN_DYNAMIC_LINE > > const &":
        r"""GetDynamicRatsnest(CONNECTIVITY_DATA self) -> std::vector< RN_DYNAMIC_LINE,std::allocator< RN_DYNAMIC_LINE > > const &"""
        return _pcbnew.CONNECTIVITY_DATA_GetDynamicRatsnest(self)

    def GetConnectedItems(self, aItem: "BOARD_CONNECTED_ITEM", aTypes: "KICAD_T const []", aIgnoreNetcodes: "bool"=False) -> "std::vector< BOARD_CONNECTED_ITEM *,std::allocator< BOARD_CONNECTED_ITEM * > > const":
        r"""GetConnectedItems(CONNECTIVITY_DATA self, BOARD_CONNECTED_ITEM aItem, KICAD_T const [] aTypes, bool aIgnoreNetcodes=False) -> std::vector< BOARD_CONNECTED_ITEM *,std::allocator< BOARD_CONNECTED_ITEM * > > const"""
        return _pcbnew.CONNECTIVITY_DATA_GetConnectedItems(self, aItem, aTypes, aIgnoreNetcodes)

    def GetNetItems(self, aNetCode: "int", aTypes: "KICAD_T const []") -> "std::vector< BOARD_CONNECTED_ITEM *,std::allocator< BOARD_CONNECTED_ITEM * > > const":
        r"""GetNetItems(CONNECTIVITY_DATA self, int aNetCode, KICAD_T const [] aTypes) -> std::vector< BOARD_CONNECTED_ITEM *,std::allocator< BOARD_CONNECTED_ITEM * > > const"""
        return _pcbnew.CONNECTIVITY_DATA_GetNetItems(self, aNetCode, aTypes)

    def BlockRatsnestItems(self, aItems: "std::vector< BOARD_ITEM *,std::allocator< BOARD_ITEM * > > const &") -> "void":
        r"""BlockRatsnestItems(CONNECTIVITY_DATA self, std::vector< BOARD_ITEM *,std::allocator< BOARD_ITEM * > > const & aItems)"""
        return _pcbnew.CONNECTIVITY_DATA_BlockRatsnestItems(self, aItems)

    def GetConnectivityAlgo(self) -> "std::shared_ptr< CN_CONNECTIVITY_ALGO >":
        r"""GetConnectivityAlgo(CONNECTIVITY_DATA self) -> std::shared_ptr< CN_CONNECTIVITY_ALGO >"""
        return _pcbnew.CONNECTIVITY_DATA_GetConnectivityAlgo(self)

    def GetLock(self) -> "KISPINLOCK &":
        r"""GetLock(CONNECTIVITY_DATA self) -> KISPINLOCK &"""
        return _pcbnew.CONNECTIVITY_DATA_GetLock(self)

    def MarkItemNetAsDirty(self, aItem: "BOARD_ITEM") -> "void":
        r"""MarkItemNetAsDirty(CONNECTIVITY_DATA self, BOARD_ITEM aItem)"""
        return _pcbnew.CONNECTIVITY_DATA_MarkItemNetAsDirty(self, aItem)

    def SetProgressReporter(self, aReporter: "PROGRESS_REPORTER *") -> "void":
        r"""SetProgressReporter(CONNECTIVITY_DATA self, PROGRESS_REPORTER * aReporter)"""
        return _pcbnew.CONNECTIVITY_DATA_SetProgressReporter(self, aReporter)

    def GetNetclassMap(self) -> "std::map< int,wxString,std::less< int >,std::allocator< std::pair< int const,wxString > > > const &":
        r"""GetNetclassMap(CONNECTIVITY_DATA self) -> std::map< int,wxString,std::less< int >,std::allocator< std::pair< int const,wxString > > > const &"""
        return _pcbnew.CONNECTIVITY_DATA_GetNetclassMap(self)

    def GetFromToCache(self) -> "std::shared_ptr< FROM_TO_CACHE >":
        r"""GetFromToCache(CONNECTIVITY_DATA self) -> std::shared_ptr< FROM_TO_CACHE >"""
        return _pcbnew.CONNECTIVITY_DATA_GetFromToCache(self)

# Register CONNECTIVITY_DATA in _pcbnew:
_pcbnew.CONNECTIVITY_DATA_swigregister(CONNECTIVITY_DATA)

class MARKERS(object):
    r"""Proxy of C++ std::vector< PCB_MARKER * > 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) -> "swig::SwigPyIterator *":
        r"""iterator(MARKERS self) -> SwigPyIterator"""
        return _pcbnew.MARKERS_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(MARKERS self) -> bool"""
        return _pcbnew.MARKERS___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(MARKERS self) -> bool"""
        return _pcbnew.MARKERS___bool__(self)

    def __len__(self) -> "std::vector< PCB_MARKER * >::size_type":
        r"""__len__(MARKERS self) -> std::vector< PCB_MARKER * >::size_type"""
        return _pcbnew.MARKERS___len__(self)

    def __getslice__(self, i: "std::vector< PCB_MARKER * >::difference_type", j: "std::vector< PCB_MARKER * >::difference_type") -> "std::vector< PCB_MARKER *,std::allocator< PCB_MARKER * > > *":
        r"""__getslice__(MARKERS self, std::vector< PCB_MARKER * >::difference_type i, std::vector< PCB_MARKER * >::difference_type j) -> MARKERS"""
        return _pcbnew.MARKERS___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        r"""
        __setslice__(MARKERS self, std::vector< PCB_MARKER * >::difference_type i, std::vector< PCB_MARKER * >::difference_type j)
        __setslice__(MARKERS self, std::vector< PCB_MARKER * >::difference_type i, std::vector< PCB_MARKER * >::difference_type j, MARKERS v)
        """
        return _pcbnew.MARKERS___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< PCB_MARKER * >::difference_type", j: "std::vector< PCB_MARKER * >::difference_type") -> "void":
        r"""__delslice__(MARKERS self, std::vector< PCB_MARKER * >::difference_type i, std::vector< PCB_MARKER * >::difference_type j)"""
        return _pcbnew.MARKERS___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        r"""
        __delitem__(MARKERS self, std::vector< PCB_MARKER * >::difference_type i)
        __delitem__(MARKERS self, PySliceObject * slice)
        """
        return _pcbnew.MARKERS___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< PCB_MARKER * >::value_type":
        r"""
        __getitem__(MARKERS self, PySliceObject * slice) -> MARKERS
        __getitem__(MARKERS self, std::vector< PCB_MARKER * >::difference_type i) -> PCB_MARKER
        """
        return _pcbnew.MARKERS___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(MARKERS self, PySliceObject * slice, MARKERS v)
        __setitem__(MARKERS self, PySliceObject * slice)
        __setitem__(MARKERS self, std::vector< PCB_MARKER * >::difference_type i, PCB_MARKER x)
        """
        return _pcbnew.MARKERS___setitem__(self, *args)

    def pop(self) -> "std::vector< PCB_MARKER * >::value_type":
        r"""pop(MARKERS self) -> PCB_MARKER"""
        return _pcbnew.MARKERS_pop(self)

    def append(self, x: "PCB_MARKER") -> "void":
        r"""append(MARKERS self, PCB_MARKER x)"""
        return _pcbnew.MARKERS_append(self, x)

    def empty(self) -> "bool":
        r"""empty(MARKERS self) -> bool"""
        return _pcbnew.MARKERS_empty(self)

    def size(self) -> "std::vector< PCB_MARKER * >::size_type":
        r"""size(MARKERS self) -> std::vector< PCB_MARKER * >::size_type"""
        return _pcbnew.MARKERS_size(self)

    def swap(self, v: "MARKERS") -> "void":
        r"""swap(MARKERS self, MARKERS v)"""
        return _pcbnew.MARKERS_swap(self, v)

    def begin(self) -> "std::vector< PCB_MARKER * >::iterator":
        r"""begin(MARKERS self) -> std::vector< PCB_MARKER * >::iterator"""
        return _pcbnew.MARKERS_begin(self)

    def end(self) -> "std::vector< PCB_MARKER * >::iterator":
        r"""end(MARKERS self) -> std::vector< PCB_MARKER * >::iterator"""
        return _pcbnew.MARKERS_end(self)

    def rbegin(self) -> "std::vector< PCB_MARKER * >::reverse_iterator":
        r"""rbegin(MARKERS self) -> std::vector< PCB_MARKER * >::reverse_iterator"""
        return _pcbnew.MARKERS_rbegin(self)

    def rend(self) -> "std::vector< PCB_MARKER * >::reverse_iterator":
        r"""rend(MARKERS self) -> std::vector< PCB_MARKER * >::reverse_iterator"""
        return _pcbnew.MARKERS_rend(self)

    def clear(self) -> "void":
        r"""clear(MARKERS self)"""
        return _pcbnew.MARKERS_clear(self)

    def get_allocator(self) -> "std::vector< PCB_MARKER * >::allocator_type":
        r"""get_allocator(MARKERS self) -> std::vector< PCB_MARKER * >::allocator_type"""
        return _pcbnew.MARKERS_get_allocator(self)

    def pop_back(self) -> "void":
        r"""pop_back(MARKERS self)"""
        return _pcbnew.MARKERS_pop_back(self)

    def erase(self, *args) -> "std::vector< PCB_MARKER * >::iterator":
        r"""
        erase(MARKERS self, std::vector< PCB_MARKER * >::iterator pos) -> std::vector< PCB_MARKER * >::iterator
        erase(MARKERS self, std::vector< PCB_MARKER * >::iterator first, std::vector< PCB_MARKER * >::iterator last) -> std::vector< PCB_MARKER * >::iterator
        """
        return _pcbnew.MARKERS_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(MARKERS self) -> MARKERS
        __init__(MARKERS self, MARKERS other) -> MARKERS
        __init__(MARKERS self, std::vector< PCB_MARKER * >::size_type size) -> MARKERS
        __init__(MARKERS self, std::vector< PCB_MARKER * >::size_type size, PCB_MARKER value) -> MARKERS
        """
        _pcbnew.MARKERS_swiginit(self, _pcbnew.new_MARKERS(*args))

    def push_back(self, x: "PCB_MARKER") -> "void":
        r"""push_back(MARKERS self, PCB_MARKER x)"""
        return _pcbnew.MARKERS_push_back(self, x)

    def front(self) -> "std::vector< PCB_MARKER * >::value_type":
        r"""front(MARKERS self) -> PCB_MARKER"""
        return _pcbnew.MARKERS_front(self)

    def back(self) -> "std::vector< PCB_MARKER * >::value_type":
        r"""back(MARKERS self) -> PCB_MARKER"""
        return _pcbnew.MARKERS_back(self)

    def assign(self, n: "std::vector< PCB_MARKER * >::size_type", x: "PCB_MARKER") -> "void":
        r"""assign(MARKERS self, std::vector< PCB_MARKER * >::size_type n, PCB_MARKER x)"""
        return _pcbnew.MARKERS_assign(self, n, x)

    def resize(self, *args) -> "void":
        r"""
        resize(MARKERS self, std::vector< PCB_MARKER * >::size_type new_size)
        resize(MARKERS self, std::vector< PCB_MARKER * >::size_type new_size, PCB_MARKER x)
        """
        return _pcbnew.MARKERS_resize(self, *args)

    def insert(self, *args) -> "void":
        r"""
        insert(MARKERS self, std::vector< PCB_MARKER * >::iterator pos, PCB_MARKER x) -> std::vector< PCB_MARKER * >::iterator
        insert(MARKERS self, std::vector< PCB_MARKER * >::iterator pos, std::vector< PCB_MARKER * >::size_type n, PCB_MARKER x)
        """
        return _pcbnew.MARKERS_insert(self, *args)

    def reserve(self, n: "std::vector< PCB_MARKER * >::size_type") -> "void":
        r"""reserve(MARKERS self, std::vector< PCB_MARKER * >::size_type n)"""
        return _pcbnew.MARKERS_reserve(self, n)

    def capacity(self) -> "std::vector< PCB_MARKER * >::size_type":
        r"""capacity(MARKERS self) -> std::vector< PCB_MARKER * >::size_type"""
        return _pcbnew.MARKERS_capacity(self)
    __swig_destroy__ = _pcbnew.delete_MARKERS

# Register MARKERS in _pcbnew:
_pcbnew.MARKERS_swigregister(MARKERS)

class ZONES(object):
    r"""Proxy of C++ std::vector< ZONE * > 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) -> "swig::SwigPyIterator *":
        r"""iterator(ZONES self) -> SwigPyIterator"""
        return _pcbnew.ZONES_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(ZONES self) -> bool"""
        return _pcbnew.ZONES___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(ZONES self) -> bool"""
        return _pcbnew.ZONES___bool__(self)

    def __len__(self) -> "std::vector< ZONE * >::size_type":
        r"""__len__(ZONES self) -> std::vector< ZONE * >::size_type"""
        return _pcbnew.ZONES___len__(self)

    def __getslice__(self, i: "std::vector< ZONE * >::difference_type", j: "std::vector< ZONE * >::difference_type") -> "std::vector< ZONE *,std::allocator< ZONE * > > *":
        r"""__getslice__(ZONES self, std::vector< ZONE * >::difference_type i, std::vector< ZONE * >::difference_type j) -> ZONES"""
        return _pcbnew.ZONES___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        r"""
        __setslice__(ZONES self, std::vector< ZONE * >::difference_type i, std::vector< ZONE * >::difference_type j)
        __setslice__(ZONES self, std::vector< ZONE * >::difference_type i, std::vector< ZONE * >::difference_type j, ZONES v)
        """
        return _pcbnew.ZONES___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< ZONE * >::difference_type", j: "std::vector< ZONE * >::difference_type") -> "void":
        r"""__delslice__(ZONES self, std::vector< ZONE * >::difference_type i, std::vector< ZONE * >::difference_type j)"""
        return _pcbnew.ZONES___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        r"""
        __delitem__(ZONES self, std::vector< ZONE * >::difference_type i)
        __delitem__(ZONES self, PySliceObject * slice)
        """
        return _pcbnew.ZONES___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< ZONE * >::value_type":
        r"""
        __getitem__(ZONES self, PySliceObject * slice) -> ZONES
        __getitem__(ZONES self, std::vector< ZONE * >::difference_type i) -> ZONE
        """
        return _pcbnew.ZONES___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(ZONES self, PySliceObject * slice, ZONES v)
        __setitem__(ZONES self, PySliceObject * slice)
        __setitem__(ZONES self, std::vector< ZONE * >::difference_type i, ZONE x)
        """
        return _pcbnew.ZONES___setitem__(self, *args)

    def pop(self) -> "std::vector< ZONE * >::value_type":
        r"""pop(ZONES self) -> ZONE"""
        return _pcbnew.ZONES_pop(self)

    def append(self, x: "ZONE") -> "void":
        r"""append(ZONES self, ZONE x)"""
        return _pcbnew.ZONES_append(self, x)

    def empty(self) -> "bool":
        r"""empty(ZONES self) -> bool"""
        return _pcbnew.ZONES_empty(self)

    def size(self) -> "std::vector< ZONE * >::size_type":
        r"""size(ZONES self) -> std::vector< ZONE * >::size_type"""
        return _pcbnew.ZONES_size(self)

    def swap(self, v: "ZONES") -> "void":
        r"""swap(ZONES self, ZONES v)"""
        return _pcbnew.ZONES_swap(self, v)

    def begin(self) -> "std::vector< ZONE * >::iterator":
        r"""begin(ZONES self) -> std::vector< ZONE * >::iterator"""
        return _pcbnew.ZONES_begin(self)

    def end(self) -> "std::vector< ZONE * >::iterator":
        r"""end(ZONES self) -> std::vector< ZONE * >::iterator"""
        return _pcbnew.ZONES_end(self)

    def rbegin(self) -> "std::vector< ZONE * >::reverse_iterator":
        r"""rbegin(ZONES self) -> std::vector< ZONE * >::reverse_iterator"""
        return _pcbnew.ZONES_rbegin(self)

    def rend(self) -> "std::vector< ZONE * >::reverse_iterator":
        r"""rend(ZONES self) -> std::vector< ZONE * >::reverse_iterator"""
        return _pcbnew.ZONES_rend(self)

    def clear(self) -> "void":
        r"""clear(ZONES self)"""
        return _pcbnew.ZONES_clear(self)

    def get_allocator(self) -> "std::vector< ZONE * >::allocator_type":
        r"""get_allocator(ZONES self) -> std::vector< ZONE * >::allocator_type"""
        return _pcbnew.ZONES_get_allocator(self)

    def pop_back(self) -> "void":
        r"""pop_back(ZONES self)"""
        return _pcbnew.ZONES_pop_back(self)

    def erase(self, *args) -> "std::vector< ZONE * >::iterator":
        r"""
        erase(ZONES self, std::vector< ZONE * >::iterator pos) -> std::vector< ZONE * >::iterator
        erase(ZONES self, std::vector< ZONE * >::iterator first, std::vector< ZONE * >::iterator last) -> std::vector< ZONE * >::iterator
        """
        return _pcbnew.ZONES_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(ZONES self) -> ZONES
        __init__(ZONES self, ZONES other) -> ZONES
        __init__(ZONES self, std::vector< ZONE * >::size_type size) -> ZONES
        __init__(ZONES self, std::vector< ZONE * >::size_type size, ZONE value) -> ZONES
        """
        _pcbnew.ZONES_swiginit(self, _pcbnew.new_ZONES(*args))

    def push_back(self, x: "ZONE") -> "void":
        r"""push_back(ZONES self, ZONE x)"""
        return _pcbnew.ZONES_push_back(self, x)

    def front(self) -> "std::vector< ZONE * >::value_type":
        r"""front(ZONES self) -> ZONE"""
        return _pcbnew.ZONES_front(self)

    def back(self) -> "std::vector< ZONE * >::value_type":
        r"""back(ZONES self) -> ZONE"""
        return _pcbnew.ZONES_back(self)

    def assign(self, n: "std::vector< ZONE * >::size_type", x: "ZONE") -> "void":
        r"""assign(ZONES self, std::vector< ZONE * >::size_type n, ZONE x)"""
        return _pcbnew.ZONES_assign(self, n, x)

    def resize(self, *args) -> "void":
        r"""
        resize(ZONES self, std::vector< ZONE * >::size_type new_size)
        resize(ZONES self, std::vector< ZONE * >::size_type new_size, ZONE x)
        """
        return _pcbnew.ZONES_resize(self, *args)

    def insert(self, *args) -> "void":
        r"""
        insert(ZONES self, std::vector< ZONE * >::iterator pos, ZONE x) -> std::vector< ZONE * >::iterator
        insert(ZONES self, std::vector< ZONE * >::iterator pos, std::vector< ZONE * >::size_type n, ZONE x)
        """
        return _pcbnew.ZONES_insert(self, *args)

    def reserve(self, n: "std::vector< ZONE * >::size_type") -> "void":
        r"""reserve(ZONES self, std::vector< ZONE * >::size_type n)"""
        return _pcbnew.ZONES_reserve(self, n)

    def capacity(self) -> "std::vector< ZONE * >::size_type":
        r"""capacity(ZONES self) -> std::vector< ZONE * >::size_type"""
        return _pcbnew.ZONES_capacity(self)
    __swig_destroy__ = _pcbnew.delete_ZONES

# Register ZONES in _pcbnew:
_pcbnew.ZONES_swigregister(ZONES)

class TRACKS(object):
    r"""Proxy of C++ std::deque< PCB_TRACK * > 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) -> "swig::SwigPyIterator *":
        r"""iterator(TRACKS self) -> SwigPyIterator"""
        return _pcbnew.TRACKS_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(TRACKS self) -> bool"""
        return _pcbnew.TRACKS___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(TRACKS self) -> bool"""
        return _pcbnew.TRACKS___bool__(self)

    def __len__(self) -> "std::deque< PCB_TRACK * >::size_type":
        r"""__len__(TRACKS self) -> std::deque< PCB_TRACK * >::size_type"""
        return _pcbnew.TRACKS___len__(self)

    def __getslice__(self, i: "std::deque< PCB_TRACK * >::difference_type", j: "std::deque< PCB_TRACK * >::difference_type") -> "std::deque< PCB_TRACK *,std::allocator< PCB_TRACK * > > *":
        r"""__getslice__(TRACKS self, std::deque< PCB_TRACK * >::difference_type i, std::deque< PCB_TRACK * >::difference_type j) -> TRACKS"""
        return _pcbnew.TRACKS___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        r"""
        __setslice__(TRACKS self, std::deque< PCB_TRACK * >::difference_type i, std::deque< PCB_TRACK * >::difference_type j)
        __setslice__(TRACKS self, std::deque< PCB_TRACK * >::difference_type i, std::deque< PCB_TRACK * >::difference_type j, TRACKS v)
        """
        return _pcbnew.TRACKS___setslice__(self, *args)

    def __delslice__(self, i: "std::deque< PCB_TRACK * >::difference_type", j: "std::deque< PCB_TRACK * >::difference_type") -> "void":
        r"""__delslice__(TRACKS self, std::deque< PCB_TRACK * >::difference_type i, std::deque< PCB_TRACK * >::difference_type j)"""
        return _pcbnew.TRACKS___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        r"""
        __delitem__(TRACKS self, std::deque< PCB_TRACK * >::difference_type i)
        __delitem__(TRACKS self, PySliceObject * slice)
        """
        return _pcbnew.TRACKS___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::deque< PCB_TRACK * >::value_type":
        r"""
        __getitem__(TRACKS self, PySliceObject * slice) -> TRACKS
        __getitem__(TRACKS self, std::deque< PCB_TRACK * >::difference_type i) -> PCB_TRACK
        """
        return _pcbnew.TRACKS___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(TRACKS self, PySliceObject * slice, TRACKS v)
        __setitem__(TRACKS self, PySliceObject * slice)
        __setitem__(TRACKS self, std::deque< PCB_TRACK * >::difference_type i, PCB_TRACK x)
        """
        return _pcbnew.TRACKS___setitem__(self, *args)

    def pop(self) -> "std::deque< PCB_TRACK * >::value_type":
        r"""pop(TRACKS self) -> PCB_TRACK"""
        return _pcbnew.TRACKS_pop(self)

    def append(self, x: "PCB_TRACK") -> "void":
        r"""append(TRACKS self, PCB_TRACK x)"""
        return _pcbnew.TRACKS_append(self, x)

    def empty(self) -> "bool":
        r"""empty(TRACKS self) -> bool"""
        return _pcbnew.TRACKS_empty(self)

    def size(self) -> "std::deque< PCB_TRACK * >::size_type":
        r"""size(TRACKS self) -> std::deque< PCB_TRACK * >::size_type"""
        return _pcbnew.TRACKS_size(self)

    def swap(self, v: "TRACKS") -> "void":
        r"""swap(TRACKS self, TRACKS v)"""
        return _pcbnew.TRACKS_swap(self, v)

    def begin(self) -> "std::deque< PCB_TRACK * >::iterator":
        r"""begin(TRACKS self) -> std::deque< PCB_TRACK * >::iterator"""
        return _pcbnew.TRACKS_begin(self)

    def end(self) -> "std::deque< PCB_TRACK * >::iterator":
        r"""end(TRACKS self) -> std::deque< PCB_TRACK * >::iterator"""
        return _pcbnew.TRACKS_end(self)

    def rbegin(self) -> "std::deque< PCB_TRACK * >::reverse_iterator":
        r"""rbegin(TRACKS self) -> std::deque< PCB_TRACK * >::reverse_iterator"""
        return _pcbnew.TRACKS_rbegin(self)

    def rend(self) -> "std::deque< PCB_TRACK * >::reverse_iterator":
        r"""rend(TRACKS self) -> std::deque< PCB_TRACK * >::reverse_iterator"""
        return _pcbnew.TRACKS_rend(self)

    def clear(self) -> "void":
        r"""clear(TRACKS self)"""
        return _pcbnew.TRACKS_clear(self)

    def get_allocator(self) -> "std::deque< PCB_TRACK * >::allocator_type":
        r"""get_allocator(TRACKS self) -> std::deque< PCB_TRACK * >::allocator_type"""
        return _pcbnew.TRACKS_get_allocator(self)

    def pop_back(self) -> "void":
        r"""pop_back(TRACKS self)"""
        return _pcbnew.TRACKS_pop_back(self)

    def erase(self, *args) -> "std::deque< PCB_TRACK * >::iterator":
        r"""
        erase(TRACKS self, std::deque< PCB_TRACK * >::iterator pos) -> std::deque< PCB_TRACK * >::iterator
        erase(TRACKS self, std::deque< PCB_TRACK * >::iterator first, std::deque< PCB_TRACK * >::iterator last) -> std::deque< PCB_TRACK * >::iterator
        """
        return _pcbnew.TRACKS_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(TRACKS self) -> TRACKS
        __init__(TRACKS self, TRACKS other) -> TRACKS
        __init__(TRACKS self, std::deque< PCB_TRACK * >::size_type size) -> TRACKS
        __init__(TRACKS self, std::deque< PCB_TRACK * >::size_type size, PCB_TRACK value) -> TRACKS
        """
        _pcbnew.TRACKS_swiginit(self, _pcbnew.new_TRACKS(*args))

    def push_back(self, x: "PCB_TRACK") -> "void":
        r"""push_back(TRACKS self, PCB_TRACK x)"""
        return _pcbnew.TRACKS_push_back(self, x)

    def front(self) -> "std::deque< PCB_TRACK * >::value_type":
        r"""front(TRACKS self) -> PCB_TRACK"""
        return _pcbnew.TRACKS_front(self)

    def back(self) -> "std::deque< PCB_TRACK * >::value_type":
        r"""back(TRACKS self) -> PCB_TRACK"""
        return _pcbnew.TRACKS_back(self)

    def assign(self, n: "std::deque< PCB_TRACK * >::size_type", x: "PCB_TRACK") -> "void":
        r"""assign(TRACKS self, std::deque< PCB_TRACK * >::size_type n, PCB_TRACK x)"""
        return _pcbnew.TRACKS_assign(self, n, x)

    def resize(self, *args) -> "void":
        r"""
        resize(TRACKS self, std::deque< PCB_TRACK * >::size_type new_size)
        resize(TRACKS self, std::deque< PCB_TRACK * >::size_type new_size, PCB_TRACK x)
        """
        return _pcbnew.TRACKS_resize(self, *args)

    def insert(self, *args) -> "void":
        r"""
        insert(TRACKS self, std::deque< PCB_TRACK * >::iterator pos, PCB_TRACK x) -> std::deque< PCB_TRACK * >::iterator
        insert(TRACKS self, std::deque< PCB_TRACK * >::iterator pos, std::deque< PCB_TRACK * >::size_type n, PCB_TRACK x)
        """
        return _pcbnew.TRACKS_insert(self, *args)

    def pop_front(self) -> "void":
        r"""pop_front(TRACKS self)"""
        return _pcbnew.TRACKS_pop_front(self)

    def push_front(self, x: "PCB_TRACK") -> "void":
        r"""push_front(TRACKS self, PCB_TRACK x)"""
        return _pcbnew.TRACKS_push_front(self, x)

    def __iter__(self):
        it = self.iterator()
        try:
            while True:
                item = it.next()  # throws StopIteration when iterator reached the end.
                yield item.Cast()
        except StopIteration:
            return

    __swig_destroy__ = _pcbnew.delete_TRACKS

# Register TRACKS in _pcbnew:
_pcbnew.TRACKS_swigregister(TRACKS)

class FOOTPRINTS(object):
    r"""Proxy of C++ std::deque< FOOTPRINT * > 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) -> "swig::SwigPyIterator *":
        r"""iterator(FOOTPRINTS self) -> SwigPyIterator"""
        return _pcbnew.FOOTPRINTS_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(FOOTPRINTS self) -> bool"""
        return _pcbnew.FOOTPRINTS___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(FOOTPRINTS self) -> bool"""
        return _pcbnew.FOOTPRINTS___bool__(self)

    def __len__(self) -> "std::deque< FOOTPRINT * >::size_type":
        r"""__len__(FOOTPRINTS self) -> std::deque< FOOTPRINT * >::size_type"""
        return _pcbnew.FOOTPRINTS___len__(self)

    def __getslice__(self, i: "std::deque< FOOTPRINT * >::difference_type", j: "std::deque< FOOTPRINT * >::difference_type") -> "std::deque< FOOTPRINT *,std::allocator< FOOTPRINT * > > *":
        r"""__getslice__(FOOTPRINTS self, std::deque< FOOTPRINT * >::difference_type i, std::deque< FOOTPRINT * >::difference_type j) -> FOOTPRINTS"""
        return _pcbnew.FOOTPRINTS___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        r"""
        __setslice__(FOOTPRINTS self, std::deque< FOOTPRINT * >::difference_type i, std::deque< FOOTPRINT * >::difference_type j)
        __setslice__(FOOTPRINTS self, std::deque< FOOTPRINT * >::difference_type i, std::deque< FOOTPRINT * >::difference_type j, FOOTPRINTS v)
        """
        return _pcbnew.FOOTPRINTS___setslice__(self, *args)

    def __delslice__(self, i: "std::deque< FOOTPRINT * >::difference_type", j: "std::deque< FOOTPRINT * >::difference_type") -> "void":
        r"""__delslice__(FOOTPRINTS self, std::deque< FOOTPRINT * >::difference_type i, std::deque< FOOTPRINT * >::difference_type j)"""
        return _pcbnew.FOOTPRINTS___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        r"""
        __delitem__(FOOTPRINTS self, std::deque< FOOTPRINT * >::difference_type i)
        __delitem__(FOOTPRINTS self, PySliceObject * slice)
        """
        return _pcbnew.FOOTPRINTS___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::deque< FOOTPRINT * >::value_type":
        r"""
        __getitem__(FOOTPRINTS self, PySliceObject * slice) -> FOOTPRINTS
        __getitem__(FOOTPRINTS self, std::deque< FOOTPRINT * >::difference_type i) -> FOOTPRINT
        """
        return _pcbnew.FOOTPRINTS___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(FOOTPRINTS self, PySliceObject * slice, FOOTPRINTS v)
        __setitem__(FOOTPRINTS self, PySliceObject * slice)
        __setitem__(FOOTPRINTS self, std::deque< FOOTPRINT * >::difference_type i, FOOTPRINT x)
        """
        return _pcbnew.FOOTPRINTS___setitem__(self, *args)

    def pop(self) -> "std::deque< FOOTPRINT * >::value_type":
        r"""pop(FOOTPRINTS self) -> FOOTPRINT"""
        return _pcbnew.FOOTPRINTS_pop(self)

    def append(self, x: "FOOTPRINT") -> "void":
        r"""append(FOOTPRINTS self, FOOTPRINT x)"""
        return _pcbnew.FOOTPRINTS_append(self, x)

    def empty(self) -> "bool":
        r"""empty(FOOTPRINTS self) -> bool"""
        return _pcbnew.FOOTPRINTS_empty(self)

    def size(self) -> "std::deque< FOOTPRINT * >::size_type":
        r"""size(FOOTPRINTS self) -> std::deque< FOOTPRINT * >::size_type"""
        return _pcbnew.FOOTPRINTS_size(self)

    def swap(self, v: "FOOTPRINTS") -> "void":
        r"""swap(FOOTPRINTS self, FOOTPRINTS v)"""
        return _pcbnew.FOOTPRINTS_swap(self, v)

    def begin(self) -> "std::deque< FOOTPRINT * >::iterator":
        r"""begin(FOOTPRINTS self) -> std::deque< FOOTPRINT * >::iterator"""
        return _pcbnew.FOOTPRINTS_begin(self)

    def end(self) -> "std::deque< FOOTPRINT * >::iterator":
        r"""end(FOOTPRINTS self) -> std::deque< FOOTPRINT * >::iterator"""
        return _pcbnew.FOOTPRINTS_end(self)

    def rbegin(self) -> "std::deque< FOOTPRINT * >::reverse_iterator":
        r"""rbegin(FOOTPRINTS self) -> std::deque< FOOTPRINT * >::reverse_iterator"""
        return _pcbnew.FOOTPRINTS_rbegin(self)

    def rend(self) -> "std::deque< FOOTPRINT * >::reverse_iterator":
        r"""rend(FOOTPRINTS self) -> std::deque< FOOTPRINT * >::reverse_iterator"""
        return _pcbnew.FOOTPRINTS_rend(self)

    def clear(self) -> "void":
        r"""clear(FOOTPRINTS self)"""
        return _pcbnew.FOOTPRINTS_clear(self)

    def get_allocator(self) -> "std::deque< FOOTPRINT * >::allocator_type":
        r"""get_allocator(FOOTPRINTS self) -> std::deque< FOOTPRINT * >::allocator_type"""
        return _pcbnew.FOOTPRINTS_get_allocator(self)

    def pop_back(self) -> "void":
        r"""pop_back(FOOTPRINTS self)"""
        return _pcbnew.FOOTPRINTS_pop_back(self)

    def erase(self, *args) -> "std::deque< FOOTPRINT * >::iterator":
        r"""
        erase(FOOTPRINTS self, std::deque< FOOTPRINT * >::iterator pos) -> std::deque< FOOTPRINT * >::iterator
        erase(FOOTPRINTS self, std::deque< FOOTPRINT * >::iterator first, std::deque< FOOTPRINT * >::iterator last) -> std::deque< FOOTPRINT * >::iterator
        """
        return _pcbnew.FOOTPRINTS_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(FOOTPRINTS self) -> FOOTPRINTS
        __init__(FOOTPRINTS self, FOOTPRINTS other) -> FOOTPRINTS
        __init__(FOOTPRINTS self, std::deque< FOOTPRINT * >::size_type size) -> FOOTPRINTS
        __init__(FOOTPRINTS self, std::deque< FOOTPRINT * >::size_type size, FOOTPRINT value) -> FOOTPRINTS
        """
        _pcbnew.FOOTPRINTS_swiginit(self, _pcbnew.new_FOOTPRINTS(*args))

    def push_back(self, x: "FOOTPRINT") -> "void":
        r"""push_back(FOOTPRINTS self, FOOTPRINT x)"""
        return _pcbnew.FOOTPRINTS_push_back(self, x)

    def front(self) -> "std::deque< FOOTPRINT * >::value_type":
        r"""front(FOOTPRINTS self) -> FOOTPRINT"""
        return _pcbnew.FOOTPRINTS_front(self)

    def back(self) -> "std::deque< FOOTPRINT * >::value_type":
        r"""back(FOOTPRINTS self) -> FOOTPRINT"""
        return _pcbnew.FOOTPRINTS_back(self)

    def assign(self, n: "std::deque< FOOTPRINT * >::size_type", x: "FOOTPRINT") -> "void":
        r"""assign(FOOTPRINTS self, std::deque< FOOTPRINT * >::size_type n, FOOTPRINT x)"""
        return _pcbnew.FOOTPRINTS_assign(self, n, x)

    def resize(self, *args) -> "void":
        r"""
        resize(FOOTPRINTS self, std::deque< FOOTPRINT * >::size_type new_size)
        resize(FOOTPRINTS self, std::deque< FOOTPRINT * >::size_type new_size, FOOTPRINT x)
        """
        return _pcbnew.FOOTPRINTS_resize(self, *args)

    def insert(self, *args) -> "void":
        r"""
        insert(FOOTPRINTS self, std::deque< FOOTPRINT * >::iterator pos, FOOTPRINT x) -> std::deque< FOOTPRINT * >::iterator
        insert(FOOTPRINTS self, std::deque< FOOTPRINT * >::iterator pos, std::deque< FOOTPRINT * >::size_type n, FOOTPRINT x)
        """
        return _pcbnew.FOOTPRINTS_insert(self, *args)

    def pop_front(self) -> "void":
        r"""pop_front(FOOTPRINTS self)"""
        return _pcbnew.FOOTPRINTS_pop_front(self)

    def push_front(self, x: "FOOTPRINT") -> "void":
        r"""push_front(FOOTPRINTS self, FOOTPRINT x)"""
        return _pcbnew.FOOTPRINTS_push_front(self, x)
    __swig_destroy__ = _pcbnew.delete_FOOTPRINTS

# Register FOOTPRINTS in _pcbnew:
_pcbnew.FOOTPRINTS_swigregister(FOOTPRINTS)

class GROUPS(object):
    r"""Proxy of C++ std::deque< PCB_GROUP * > 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) -> "swig::SwigPyIterator *":
        r"""iterator(GROUPS self) -> SwigPyIterator"""
        return _pcbnew.GROUPS_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(GROUPS self) -> bool"""
        return _pcbnew.GROUPS___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(GROUPS self) -> bool"""
        return _pcbnew.GROUPS___bool__(self)

    def __len__(self) -> "std::deque< PCB_GROUP * >::size_type":
        r"""__len__(GROUPS self) -> std::deque< PCB_GROUP * >::size_type"""
        return _pcbnew.GROUPS___len__(self)

    def __getslice__(self, i: "std::deque< PCB_GROUP * >::difference_type", j: "std::deque< PCB_GROUP * >::difference_type") -> "std::deque< PCB_GROUP *,std::allocator< PCB_GROUP * > > *":
        r"""__getslice__(GROUPS self, std::deque< PCB_GROUP * >::difference_type i, std::deque< PCB_GROUP * >::difference_type j) -> GROUPS"""
        return _pcbnew.GROUPS___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        r"""
        __setslice__(GROUPS self, std::deque< PCB_GROUP * >::difference_type i, std::deque< PCB_GROUP * >::difference_type j)
        __setslice__(GROUPS self, std::deque< PCB_GROUP * >::difference_type i, std::deque< PCB_GROUP * >::difference_type j, GROUPS v)
        """
        return _pcbnew.GROUPS___setslice__(self, *args)

    def __delslice__(self, i: "std::deque< PCB_GROUP * >::difference_type", j: "std::deque< PCB_GROUP * >::difference_type") -> "void":
        r"""__delslice__(GROUPS self, std::deque< PCB_GROUP * >::difference_type i, std::deque< PCB_GROUP * >::difference_type j)"""
        return _pcbnew.GROUPS___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        r"""
        __delitem__(GROUPS self, std::deque< PCB_GROUP * >::difference_type i)
        __delitem__(GROUPS self, PySliceObject * slice)
        """
        return _pcbnew.GROUPS___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::deque< PCB_GROUP * >::value_type":
        r"""
        __getitem__(GROUPS self, PySliceObject * slice) -> GROUPS
        __getitem__(GROUPS self, std::deque< PCB_GROUP * >::difference_type i) -> PCB_GROUP
        """
        return _pcbnew.GROUPS___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(GROUPS self, PySliceObject * slice, GROUPS v)
        __setitem__(GROUPS self, PySliceObject * slice)
        __setitem__(GROUPS self, std::deque< PCB_GROUP * >::difference_type i, PCB_GROUP x)
        """
        return _pcbnew.GROUPS___setitem__(self, *args)

    def pop(self) -> "std::deque< PCB_GROUP * >::value_type":
        r"""pop(GROUPS self) -> PCB_GROUP"""
        return _pcbnew.GROUPS_pop(self)

    def append(self, x: "PCB_GROUP") -> "void":
        r"""append(GROUPS self, PCB_GROUP x)"""
        return _pcbnew.GROUPS_append(self, x)

    def empty(self) -> "bool":
        r"""empty(GROUPS self) -> bool"""
        return _pcbnew.GROUPS_empty(self)

    def size(self) -> "std::deque< PCB_GROUP * >::size_type":
        r"""size(GROUPS self) -> std::deque< PCB_GROUP * >::size_type"""
        return _pcbnew.GROUPS_size(self)

    def swap(self, v: "GROUPS") -> "void":
        r"""swap(GROUPS self, GROUPS v)"""
        return _pcbnew.GROUPS_swap(self, v)

    def begin(self) -> "std::deque< PCB_GROUP * >::iterator":
        r"""begin(GROUPS self) -> std::deque< PCB_GROUP * >::iterator"""
        return _pcbnew.GROUPS_begin(self)

    def end(self) -> "std::deque< PCB_GROUP * >::iterator":
        r"""end(GROUPS self) -> std::deque< PCB_GROUP * >::iterator"""
        return _pcbnew.GROUPS_end(self)

    def rbegin(self) -> "std::deque< PCB_GROUP * >::reverse_iterator":
        r"""rbegin(GROUPS self) -> std::deque< PCB_GROUP * >::reverse_iterator"""
        return _pcbnew.GROUPS_rbegin(self)

    def rend(self) -> "std::deque< PCB_GROUP * >::reverse_iterator":
        r"""rend(GROUPS self) -> std::deque< PCB_GROUP * >::reverse_iterator"""
        return _pcbnew.GROUPS_rend(self)

    def clear(self) -> "void":
        r"""clear(GROUPS self)"""
        return _pcbnew.GROUPS_clear(self)

    def get_allocator(self) -> "std::deque< PCB_GROUP * >::allocator_type":
        r"""get_allocator(GROUPS self) -> std::deque< PCB_GROUP * >::allocator_type"""
        return _pcbnew.GROUPS_get_allocator(self)

    def pop_back(self) -> "void":
        r"""pop_back(GROUPS self)"""
        return _pcbnew.GROUPS_pop_back(self)

    def erase(self, *args) -> "std::deque< PCB_GROUP * >::iterator":
        r"""
        erase(GROUPS self, std::deque< PCB_GROUP * >::iterator pos) -> std::deque< PCB_GROUP * >::iterator
        erase(GROUPS self, std::deque< PCB_GROUP * >::iterator first, std::deque< PCB_GROUP * >::iterator last) -> std::deque< PCB_GROUP * >::iterator
        """
        return _pcbnew.GROUPS_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(GROUPS self) -> GROUPS
        __init__(GROUPS self, GROUPS other) -> GROUPS
        __init__(GROUPS self, std::deque< PCB_GROUP * >::size_type size) -> GROUPS
        __init__(GROUPS self, std::deque< PCB_GROUP * >::size_type size, PCB_GROUP value) -> GROUPS
        """
        _pcbnew.GROUPS_swiginit(self, _pcbnew.new_GROUPS(*args))

    def push_back(self, x: "PCB_GROUP") -> "void":
        r"""push_back(GROUPS self, PCB_GROUP x)"""
        return _pcbnew.GROUPS_push_back(self, x)

    def front(self) -> "std::deque< PCB_GROUP * >::value_type":
        r"""front(GROUPS self) -> PCB_GROUP"""
        return _pcbnew.GROUPS_front(self)

    def back(self) -> "std::deque< PCB_GROUP * >::value_type":
        r"""back(GROUPS self) -> PCB_GROUP"""
        return _pcbnew.GROUPS_back(self)

    def assign(self, n: "std::deque< PCB_GROUP * >::size_type", x: "PCB_GROUP") -> "void":
        r"""assign(GROUPS self, std::deque< PCB_GROUP * >::size_type n, PCB_GROUP x)"""
        return _pcbnew.GROUPS_assign(self, n, x)

    def resize(self, *args) -> "void":
        r"""
        resize(GROUPS self, std::deque< PCB_GROUP * >::size_type new_size)
        resize(GROUPS self, std::deque< PCB_GROUP * >::size_type new_size, PCB_GROUP x)
        """
        return _pcbnew.GROUPS_resize(self, *args)

    def insert(self, *args) -> "void":
        r"""
        insert(GROUPS self, std::deque< PCB_GROUP * >::iterator pos, PCB_GROUP x) -> std::deque< PCB_GROUP * >::iterator
        insert(GROUPS self, std::deque< PCB_GROUP * >::iterator pos, std::deque< PCB_GROUP * >::size_type n, PCB_GROUP x)
        """
        return _pcbnew.GROUPS_insert(self, *args)

    def pop_front(self) -> "void":
        r"""pop_front(GROUPS self)"""
        return _pcbnew.GROUPS_pop_front(self)

    def push_front(self, x: "PCB_GROUP") -> "void":
        r"""push_front(GROUPS self, PCB_GROUP x)"""
        return _pcbnew.GROUPS_push_front(self, x)
    __swig_destroy__ = _pcbnew.delete_GROUPS

# Register GROUPS in _pcbnew:
_pcbnew.GROUPS_swigregister(GROUPS)

class DRAWINGS(object):
    r"""Proxy of C++ std::deque< BOARD_ITEM * > 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) -> "swig::SwigPyIterator *":
        r"""iterator(DRAWINGS self) -> SwigPyIterator"""
        return _pcbnew.DRAWINGS_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(DRAWINGS self) -> bool"""
        return _pcbnew.DRAWINGS___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(DRAWINGS self) -> bool"""
        return _pcbnew.DRAWINGS___bool__(self)

    def __len__(self) -> "std::deque< BOARD_ITEM * >::size_type":
        r"""__len__(DRAWINGS self) -> std::deque< BOARD_ITEM * >::size_type"""
        return _pcbnew.DRAWINGS___len__(self)

    def __getslice__(self, i: "std::deque< BOARD_ITEM * >::difference_type", j: "std::deque< BOARD_ITEM * >::difference_type") -> "std::deque< BOARD_ITEM *,std::allocator< BOARD_ITEM * > > *":
        r"""__getslice__(DRAWINGS self, std::deque< BOARD_ITEM * >::difference_type i, std::deque< BOARD_ITEM * >::difference_type j) -> DRAWINGS"""
        return _pcbnew.DRAWINGS___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        r"""
        __setslice__(DRAWINGS self, std::deque< BOARD_ITEM * >::difference_type i, std::deque< BOARD_ITEM * >::difference_type j)
        __setslice__(DRAWINGS self, std::deque< BOARD_ITEM * >::difference_type i, std::deque< BOARD_ITEM * >::difference_type j, DRAWINGS v)
        """
        return _pcbnew.DRAWINGS___setslice__(self, *args)

    def __delslice__(self, i: "std::deque< BOARD_ITEM * >::difference_type", j: "std::deque< BOARD_ITEM * >::difference_type") -> "void":
        r"""__delslice__(DRAWINGS self, std::deque< BOARD_ITEM * >::difference_type i, std::deque< BOARD_ITEM * >::difference_type j)"""
        return _pcbnew.DRAWINGS___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        r"""
        __delitem__(DRAWINGS self, std::deque< BOARD_ITEM * >::difference_type i)
        __delitem__(DRAWINGS self, PySliceObject * slice)
        """
        return _pcbnew.DRAWINGS___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::deque< BOARD_ITEM * >::value_type":
        r"""
        __getitem__(DRAWINGS self, PySliceObject * slice) -> DRAWINGS
        __getitem__(DRAWINGS self, std::deque< BOARD_ITEM * >::difference_type i) -> BOARD_ITEM
        """
        return _pcbnew.DRAWINGS___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(DRAWINGS self, PySliceObject * slice, DRAWINGS v)
        __setitem__(DRAWINGS self, PySliceObject * slice)
        __setitem__(DRAWINGS self, std::deque< BOARD_ITEM * >::difference_type i, BOARD_ITEM x)
        """
        return _pcbnew.DRAWINGS___setitem__(self, *args)

    def pop(self) -> "std::deque< BOARD_ITEM * >::value_type":
        r"""pop(DRAWINGS self) -> BOARD_ITEM"""
        return _pcbnew.DRAWINGS_pop(self)

    def append(self, x: "BOARD_ITEM") -> "void":
        r"""append(DRAWINGS self, BOARD_ITEM x)"""
        return _pcbnew.DRAWINGS_append(self, x)

    def empty(self) -> "bool":
        r"""empty(DRAWINGS self) -> bool"""
        return _pcbnew.DRAWINGS_empty(self)

    def size(self) -> "std::deque< BOARD_ITEM * >::size_type":
        r"""size(DRAWINGS self) -> std::deque< BOARD_ITEM * >::size_type"""
        return _pcbnew.DRAWINGS_size(self)

    def swap(self, v: "DRAWINGS") -> "void":
        r"""swap(DRAWINGS self, DRAWINGS v)"""
        return _pcbnew.DRAWINGS_swap(self, v)

    def begin(self) -> "std::deque< BOARD_ITEM * >::iterator":
        r"""begin(DRAWINGS self) -> std::deque< BOARD_ITEM * >::iterator"""
        return _pcbnew.DRAWINGS_begin(self)

    def end(self) -> "std::deque< BOARD_ITEM * >::iterator":
        r"""end(DRAWINGS self) -> std::deque< BOARD_ITEM * >::iterator"""
        return _pcbnew.DRAWINGS_end(self)

    def rbegin(self) -> "std::deque< BOARD_ITEM * >::reverse_iterator":
        r"""rbegin(DRAWINGS self) -> std::deque< BOARD_ITEM * >::reverse_iterator"""
        return _pcbnew.DRAWINGS_rbegin(self)

    def rend(self) -> "std::deque< BOARD_ITEM * >::reverse_iterator":
        r"""rend(DRAWINGS self) -> std::deque< BOARD_ITEM * >::reverse_iterator"""
        return _pcbnew.DRAWINGS_rend(self)

    def clear(self) -> "void":
        r"""clear(DRAWINGS self)"""
        return _pcbnew.DRAWINGS_clear(self)

    def get_allocator(self) -> "std::deque< BOARD_ITEM * >::allocator_type":
        r"""get_allocator(DRAWINGS self) -> std::deque< BOARD_ITEM * >::allocator_type"""
        return _pcbnew.DRAWINGS_get_allocator(self)

    def pop_back(self) -> "void":
        r"""pop_back(DRAWINGS self)"""
        return _pcbnew.DRAWINGS_pop_back(self)

    def erase(self, *args) -> "std::deque< BOARD_ITEM * >::iterator":
        r"""
        erase(DRAWINGS self, std::deque< BOARD_ITEM * >::iterator pos) -> std::deque< BOARD_ITEM * >::iterator
        erase(DRAWINGS self, std::deque< BOARD_ITEM * >::iterator first, std::deque< BOARD_ITEM * >::iterator last) -> std::deque< BOARD_ITEM * >::iterator
        """
        return _pcbnew.DRAWINGS_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(DRAWINGS self) -> DRAWINGS
        __init__(DRAWINGS self, DRAWINGS other) -> DRAWINGS
        __init__(DRAWINGS self, std::deque< BOARD_ITEM * >::size_type size) -> DRAWINGS
        __init__(DRAWINGS self, std::deque< BOARD_ITEM * >::size_type size, BOARD_ITEM value) -> DRAWINGS
        """
        _pcbnew.DRAWINGS_swiginit(self, _pcbnew.new_DRAWINGS(*args))

    def push_back(self, x: "BOARD_ITEM") -> "void":
        r"""push_back(DRAWINGS self, BOARD_ITEM x)"""
        return _pcbnew.DRAWINGS_push_back(self, x)

    def front(self) -> "std::deque< BOARD_ITEM * >::value_type":
        r"""front(DRAWINGS self) -> BOARD_ITEM"""
        return _pcbnew.DRAWINGS_front(self)

    def back(self) -> "std::deque< BOARD_ITEM * >::value_type":
        r"""back(DRAWINGS self) -> BOARD_ITEM"""
        return _pcbnew.DRAWINGS_back(self)

    def assign(self, n: "std::deque< BOARD_ITEM * >::size_type", x: "BOARD_ITEM") -> "void":
        r"""assign(DRAWINGS self, std::deque< BOARD_ITEM * >::size_type n, BOARD_ITEM x)"""
        return _pcbnew.DRAWINGS_assign(self, n, x)

    def resize(self, *args) -> "void":
        r"""
        resize(DRAWINGS self, std::deque< BOARD_ITEM * >::size_type new_size)
        resize(DRAWINGS self, std::deque< BOARD_ITEM * >::size_type new_size, BOARD_ITEM x)
        """
        return _pcbnew.DRAWINGS_resize(self, *args)

    def insert(self, *args) -> "void":
        r"""
        insert(DRAWINGS self, std::deque< BOARD_ITEM * >::iterator pos, BOARD_ITEM x) -> std::deque< BOARD_ITEM * >::iterator
        insert(DRAWINGS self, std::deque< BOARD_ITEM * >::iterator pos, std::deque< BOARD_ITEM * >::size_type n, BOARD_ITEM x)
        """
        return _pcbnew.DRAWINGS_insert(self, *args)

    def pop_front(self) -> "void":
        r"""pop_front(DRAWINGS self)"""
        return _pcbnew.DRAWINGS_pop_front(self)

    def push_front(self, x: "BOARD_ITEM") -> "void":
        r"""push_front(DRAWINGS self, BOARD_ITEM x)"""
        return _pcbnew.DRAWINGS_push_front(self, x)

    def __iter__(self):
        it = self.iterator()
        try:
            while True:
                item = it.next()  # throws StopIteration when iterator reached the end.
                yield item.Cast()
        except StopIteration:
            return

    __swig_destroy__ = _pcbnew.delete_DRAWINGS

# Register DRAWINGS in _pcbnew:
_pcbnew.DRAWINGS_swigregister(DRAWINGS)

class PADS(object):
    r"""Proxy of C++ std::deque< PAD * > 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) -> "swig::SwigPyIterator *":
        r"""iterator(PADS self) -> SwigPyIterator"""
        return _pcbnew.PADS_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(PADS self) -> bool"""
        return _pcbnew.PADS___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(PADS self) -> bool"""
        return _pcbnew.PADS___bool__(self)

    def __len__(self) -> "std::deque< PAD * >::size_type":
        r"""__len__(PADS self) -> std::deque< PAD * >::size_type"""
        return _pcbnew.PADS___len__(self)

    def __getslice__(self, i: "std::deque< PAD * >::difference_type", j: "std::deque< PAD * >::difference_type") -> "std::deque< PAD *,std::allocator< PAD * > > *":
        r"""__getslice__(PADS self, std::deque< PAD * >::difference_type i, std::deque< PAD * >::difference_type j) -> PADS"""
        return _pcbnew.PADS___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        r"""
        __setslice__(PADS self, std::deque< PAD * >::difference_type i, std::deque< PAD * >::difference_type j)
        __setslice__(PADS self, std::deque< PAD * >::difference_type i, std::deque< PAD * >::difference_type j, PADS v)
        """
        return _pcbnew.PADS___setslice__(self, *args)

    def __delslice__(self, i: "std::deque< PAD * >::difference_type", j: "std::deque< PAD * >::difference_type") -> "void":
        r"""__delslice__(PADS self, std::deque< PAD * >::difference_type i, std::deque< PAD * >::difference_type j)"""
        return _pcbnew.PADS___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        r"""
        __delitem__(PADS self, std::deque< PAD * >::difference_type i)
        __delitem__(PADS self, PySliceObject * slice)
        """
        return _pcbnew.PADS___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::deque< PAD * >::value_type":
        r"""
        __getitem__(PADS self, PySliceObject * slice) -> PADS
        __getitem__(PADS self, std::deque< PAD * >::difference_type i) -> PAD
        """
        return _pcbnew.PADS___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(PADS self, PySliceObject * slice, PADS v)
        __setitem__(PADS self, PySliceObject * slice)
        __setitem__(PADS self, std::deque< PAD * >::difference_type i, PAD x)
        """
        return _pcbnew.PADS___setitem__(self, *args)

    def pop(self) -> "std::deque< PAD * >::value_type":
        r"""pop(PADS self) -> PAD"""
        return _pcbnew.PADS_pop(self)

    def append(self, x: "PAD") -> "void":
        r"""append(PADS self, PAD x)"""
        return _pcbnew.PADS_append(self, x)

    def empty(self) -> "bool":
        r"""empty(PADS self) -> bool"""
        return _pcbnew.PADS_empty(self)

    def size(self) -> "std::deque< PAD * >::size_type":
        r"""size(PADS self) -> std::deque< PAD * >::size_type"""
        return _pcbnew.PADS_size(self)

    def swap(self, v: "PADS") -> "void":
        r"""swap(PADS self, PADS v)"""
        return _pcbnew.PADS_swap(self, v)

    def begin(self) -> "std::deque< PAD * >::iterator":
        r"""begin(PADS self) -> std::deque< PAD * >::iterator"""
        return _pcbnew.PADS_begin(self)

    def end(self) -> "std::deque< PAD * >::iterator":
        r"""end(PADS self) -> std::deque< PAD * >::iterator"""
        return _pcbnew.PADS_end(self)

    def rbegin(self) -> "std::deque< PAD * >::reverse_iterator":
        r"""rbegin(PADS self) -> std::deque< PAD * >::reverse_iterator"""
        return _pcbnew.PADS_rbegin(self)

    def rend(self) -> "std::deque< PAD * >::reverse_iterator":
        r"""rend(PADS self) -> std::deque< PAD * >::reverse_iterator"""
        return _pcbnew.PADS_rend(self)

    def clear(self) -> "void":
        r"""clear(PADS self)"""
        return _pcbnew.PADS_clear(self)

    def get_allocator(self) -> "std::deque< PAD * >::allocator_type":
        r"""get_allocator(PADS self) -> std::deque< PAD * >::allocator_type"""
        return _pcbnew.PADS_get_allocator(self)

    def pop_back(self) -> "void":
        r"""pop_back(PADS self)"""
        return _pcbnew.PADS_pop_back(self)

    def erase(self, *args) -> "std::deque< PAD * >::iterator":
        r"""
        erase(PADS self, std::deque< PAD * >::iterator pos) -> std::deque< PAD * >::iterator
        erase(PADS self, std::deque< PAD * >::iterator first, std::deque< PAD * >::iterator last) -> std::deque< PAD * >::iterator
        """
        return _pcbnew.PADS_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(PADS self) -> PADS
        __init__(PADS self, PADS other) -> PADS
        __init__(PADS self, std::deque< PAD * >::size_type size) -> PADS
        __init__(PADS self, std::deque< PAD * >::size_type size, PAD value) -> PADS
        """
        _pcbnew.PADS_swiginit(self, _pcbnew.new_PADS(*args))

    def push_back(self, x: "PAD") -> "void":
        r"""push_back(PADS self, PAD x)"""
        return _pcbnew.PADS_push_back(self, x)

    def front(self) -> "std::deque< PAD * >::value_type":
        r"""front(PADS self) -> PAD"""
        return _pcbnew.PADS_front(self)

    def back(self) -> "std::deque< PAD * >::value_type":
        r"""back(PADS self) -> PAD"""
        return _pcbnew.PADS_back(self)

    def assign(self, n: "std::deque< PAD * >::size_type", x: "PAD") -> "void":
        r"""assign(PADS self, std::deque< PAD * >::size_type n, PAD x)"""
        return _pcbnew.PADS_assign(self, n, x)

    def resize(self, *args) -> "void":
        r"""
        resize(PADS self, std::deque< PAD * >::size_type new_size)
        resize(PADS self, std::deque< PAD * >::size_type new_size, PAD x)
        """
        return _pcbnew.PADS_resize(self, *args)

    def insert(self, *args) -> "void":
        r"""
        insert(PADS self, std::deque< PAD * >::iterator pos, PAD x) -> std::deque< PAD * >::iterator
        insert(PADS self, std::deque< PAD * >::iterator pos, std::deque< PAD * >::size_type n, PAD x)
        """
        return _pcbnew.PADS_insert(self, *args)

    def pop_front(self) -> "void":
        r"""pop_front(PADS self)"""
        return _pcbnew.PADS_pop_front(self)

    def push_front(self, x: "PAD") -> "void":
        r"""push_front(PADS self, PAD x)"""
        return _pcbnew.PADS_push_front(self, x)
    __swig_destroy__ = _pcbnew.delete_PADS

# Register PADS in _pcbnew:
_pcbnew.PADS_swigregister(PADS)

class FP_ZONES(object):
    r"""Proxy of C++ std::vector< FP_ZONE * > 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) -> "swig::SwigPyIterator *":
        r"""iterator(FP_ZONES self) -> SwigPyIterator"""
        return _pcbnew.FP_ZONES_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(FP_ZONES self) -> bool"""
        return _pcbnew.FP_ZONES___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(FP_ZONES self) -> bool"""
        return _pcbnew.FP_ZONES___bool__(self)

    def __len__(self) -> "std::vector< FP_ZONE * >::size_type":
        r"""__len__(FP_ZONES self) -> std::vector< FP_ZONE * >::size_type"""
        return _pcbnew.FP_ZONES___len__(self)

    def __getslice__(self, i: "std::vector< FP_ZONE * >::difference_type", j: "std::vector< FP_ZONE * >::difference_type") -> "std::vector< FP_ZONE *,std::allocator< FP_ZONE * > > *":
        r"""__getslice__(FP_ZONES self, std::vector< FP_ZONE * >::difference_type i, std::vector< FP_ZONE * >::difference_type j) -> FP_ZONES"""
        return _pcbnew.FP_ZONES___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        r"""
        __setslice__(FP_ZONES self, std::vector< FP_ZONE * >::difference_type i, std::vector< FP_ZONE * >::difference_type j)
        __setslice__(FP_ZONES self, std::vector< FP_ZONE * >::difference_type i, std::vector< FP_ZONE * >::difference_type j, FP_ZONES v)
        """
        return _pcbnew.FP_ZONES___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< FP_ZONE * >::difference_type", j: "std::vector< FP_ZONE * >::difference_type") -> "void":
        r"""__delslice__(FP_ZONES self, std::vector< FP_ZONE * >::difference_type i, std::vector< FP_ZONE * >::difference_type j)"""
        return _pcbnew.FP_ZONES___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        r"""
        __delitem__(FP_ZONES self, std::vector< FP_ZONE * >::difference_type i)
        __delitem__(FP_ZONES self, PySliceObject * slice)
        """
        return _pcbnew.FP_ZONES___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< FP_ZONE * >::value_type":
        r"""
        __getitem__(FP_ZONES self, PySliceObject * slice) -> FP_ZONES
        __getitem__(FP_ZONES self, std::vector< FP_ZONE * >::difference_type i) -> FP_ZONE
        """
        return _pcbnew.FP_ZONES___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(FP_ZONES self, PySliceObject * slice, FP_ZONES v)
        __setitem__(FP_ZONES self, PySliceObject * slice)
        __setitem__(FP_ZONES self, std::vector< FP_ZONE * >::difference_type i, FP_ZONE x)
        """
        return _pcbnew.FP_ZONES___setitem__(self, *args)

    def pop(self) -> "std::vector< FP_ZONE * >::value_type":
        r"""pop(FP_ZONES self) -> FP_ZONE"""
        return _pcbnew.FP_ZONES_pop(self)

    def append(self, x: "FP_ZONE") -> "void":
        r"""append(FP_ZONES self, FP_ZONE x)"""
        return _pcbnew.FP_ZONES_append(self, x)

    def empty(self) -> "bool":
        r"""empty(FP_ZONES self) -> bool"""
        return _pcbnew.FP_ZONES_empty(self)

    def size(self) -> "std::vector< FP_ZONE * >::size_type":
        r"""size(FP_ZONES self) -> std::vector< FP_ZONE * >::size_type"""
        return _pcbnew.FP_ZONES_size(self)

    def swap(self, v: "FP_ZONES") -> "void":
        r"""swap(FP_ZONES self, FP_ZONES v)"""
        return _pcbnew.FP_ZONES_swap(self, v)

    def begin(self) -> "std::vector< FP_ZONE * >::iterator":
        r"""begin(FP_ZONES self) -> std::vector< FP_ZONE * >::iterator"""
        return _pcbnew.FP_ZONES_begin(self)

    def end(self) -> "std::vector< FP_ZONE * >::iterator":
        r"""end(FP_ZONES self) -> std::vector< FP_ZONE * >::iterator"""
        return _pcbnew.FP_ZONES_end(self)

    def rbegin(self) -> "std::vector< FP_ZONE * >::reverse_iterator":
        r"""rbegin(FP_ZONES self) -> std::vector< FP_ZONE * >::reverse_iterator"""
        return _pcbnew.FP_ZONES_rbegin(self)

    def rend(self) -> "std::vector< FP_ZONE * >::reverse_iterator":
        r"""rend(FP_ZONES self) -> std::vector< FP_ZONE * >::reverse_iterator"""
        return _pcbnew.FP_ZONES_rend(self)

    def clear(self) -> "void":
        r"""clear(FP_ZONES self)"""
        return _pcbnew.FP_ZONES_clear(self)

    def get_allocator(self) -> "std::vector< FP_ZONE * >::allocator_type":
        r"""get_allocator(FP_ZONES self) -> std::vector< FP_ZONE * >::allocator_type"""
        return _pcbnew.FP_ZONES_get_allocator(self)

    def pop_back(self) -> "void":
        r"""pop_back(FP_ZONES self)"""
        return _pcbnew.FP_ZONES_pop_back(self)

    def erase(self, *args) -> "std::vector< FP_ZONE * >::iterator":
        r"""
        erase(FP_ZONES self, std::vector< FP_ZONE * >::iterator pos) -> std::vector< FP_ZONE * >::iterator
        erase(FP_ZONES self, std::vector< FP_ZONE * >::iterator first, std::vector< FP_ZONE * >::iterator last) -> std::vector< FP_ZONE * >::iterator
        """
        return _pcbnew.FP_ZONES_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(FP_ZONES self) -> FP_ZONES
        __init__(FP_ZONES self, FP_ZONES other) -> FP_ZONES
        __init__(FP_ZONES self, std::vector< FP_ZONE * >::size_type size) -> FP_ZONES
        __init__(FP_ZONES self, std::vector< FP_ZONE * >::size_type size, FP_ZONE value) -> FP_ZONES
        """
        _pcbnew.FP_ZONES_swiginit(self, _pcbnew.new_FP_ZONES(*args))

    def push_back(self, x: "FP_ZONE") -> "void":
        r"""push_back(FP_ZONES self, FP_ZONE x)"""
        return _pcbnew.FP_ZONES_push_back(self, x)

    def front(self) -> "std::vector< FP_ZONE * >::value_type":
        r"""front(FP_ZONES self) -> FP_ZONE"""
        return _pcbnew.FP_ZONES_front(self)

    def back(self) -> "std::vector< FP_ZONE * >::value_type":
        r"""back(FP_ZONES self) -> FP_ZONE"""
        return _pcbnew.FP_ZONES_back(self)

    def assign(self, n: "std::vector< FP_ZONE * >::size_type", x: "FP_ZONE") -> "void":
        r"""assign(FP_ZONES self, std::vector< FP_ZONE * >::size_type n, FP_ZONE x)"""
        return _pcbnew.FP_ZONES_assign(self, n, x)

    def resize(self, *args) -> "void":
        r"""
        resize(FP_ZONES self, std::vector< FP_ZONE * >::size_type new_size)
        resize(FP_ZONES self, std::vector< FP_ZONE * >::size_type new_size, FP_ZONE x)
        """
        return _pcbnew.FP_ZONES_resize(self, *args)

    def insert(self, *args) -> "void":
        r"""
        insert(FP_ZONES self, std::vector< FP_ZONE * >::iterator pos, FP_ZONE x) -> std::vector< FP_ZONE * >::iterator
        insert(FP_ZONES self, std::vector< FP_ZONE * >::iterator pos, std::vector< FP_ZONE * >::size_type n, FP_ZONE x)
        """
        return _pcbnew.FP_ZONES_insert(self, *args)

    def reserve(self, n: "std::vector< FP_ZONE * >::size_type") -> "void":
        r"""reserve(FP_ZONES self, std::vector< FP_ZONE * >::size_type n)"""
        return _pcbnew.FP_ZONES_reserve(self, n)

    def capacity(self) -> "std::vector< FP_ZONE * >::size_type":
        r"""capacity(FP_ZONES self) -> std::vector< FP_ZONE * >::size_type"""
        return _pcbnew.FP_ZONES_capacity(self)
    __swig_destroy__ = _pcbnew.delete_FP_ZONES

# Register FP_ZONES in _pcbnew:
_pcbnew.FP_ZONES_swigregister(FP_ZONES)

class FP_GROUPS(object):
    r"""Proxy of C++ std::vector< PCB_GROUP * > 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) -> "swig::SwigPyIterator *":
        r"""iterator(FP_GROUPS self) -> SwigPyIterator"""
        return _pcbnew.FP_GROUPS_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(FP_GROUPS self) -> bool"""
        return _pcbnew.FP_GROUPS___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(FP_GROUPS self) -> bool"""
        return _pcbnew.FP_GROUPS___bool__(self)

    def __len__(self) -> "std::vector< PCB_GROUP * >::size_type":
        r"""__len__(FP_GROUPS self) -> std::vector< PCB_GROUP * >::size_type"""
        return _pcbnew.FP_GROUPS___len__(self)

    def __getslice__(self, i: "std::vector< PCB_GROUP * >::difference_type", j: "std::vector< PCB_GROUP * >::difference_type") -> "std::vector< PCB_GROUP *,std::allocator< PCB_GROUP * > > *":
        r"""__getslice__(FP_GROUPS self, std::vector< PCB_GROUP * >::difference_type i, std::vector< PCB_GROUP * >::difference_type j) -> FP_GROUPS"""
        return _pcbnew.FP_GROUPS___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        r"""
        __setslice__(FP_GROUPS self, std::vector< PCB_GROUP * >::difference_type i, std::vector< PCB_GROUP * >::difference_type j)
        __setslice__(FP_GROUPS self, std::vector< PCB_GROUP * >::difference_type i, std::vector< PCB_GROUP * >::difference_type j, FP_GROUPS v)
        """
        return _pcbnew.FP_GROUPS___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< PCB_GROUP * >::difference_type", j: "std::vector< PCB_GROUP * >::difference_type") -> "void":
        r"""__delslice__(FP_GROUPS self, std::vector< PCB_GROUP * >::difference_type i, std::vector< PCB_GROUP * >::difference_type j)"""
        return _pcbnew.FP_GROUPS___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        r"""
        __delitem__(FP_GROUPS self, std::vector< PCB_GROUP * >::difference_type i)
        __delitem__(FP_GROUPS self, PySliceObject * slice)
        """
        return _pcbnew.FP_GROUPS___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< PCB_GROUP * >::value_type":
        r"""
        __getitem__(FP_GROUPS self, PySliceObject * slice) -> FP_GROUPS
        __getitem__(FP_GROUPS self, std::vector< PCB_GROUP * >::difference_type i) -> PCB_GROUP
        """
        return _pcbnew.FP_GROUPS___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(FP_GROUPS self, PySliceObject * slice, FP_GROUPS v)
        __setitem__(FP_GROUPS self, PySliceObject * slice)
        __setitem__(FP_GROUPS self, std::vector< PCB_GROUP * >::difference_type i, PCB_GROUP x)
        """
        return _pcbnew.FP_GROUPS___setitem__(self, *args)

    def pop(self) -> "std::vector< PCB_GROUP * >::value_type":
        r"""pop(FP_GROUPS self) -> PCB_GROUP"""
        return _pcbnew.FP_GROUPS_pop(self)

    def append(self, x: "PCB_GROUP") -> "void":
        r"""append(FP_GROUPS self, PCB_GROUP x)"""
        return _pcbnew.FP_GROUPS_append(self, x)

    def empty(self) -> "bool":
        r"""empty(FP_GROUPS self) -> bool"""
        return _pcbnew.FP_GROUPS_empty(self)

    def size(self) -> "std::vector< PCB_GROUP * >::size_type":
        r"""size(FP_GROUPS self) -> std::vector< PCB_GROUP * >::size_type"""
        return _pcbnew.FP_GROUPS_size(self)

    def swap(self, v: "FP_GROUPS") -> "void":
        r"""swap(FP_GROUPS self, FP_GROUPS v)"""
        return _pcbnew.FP_GROUPS_swap(self, v)

    def begin(self) -> "std::vector< PCB_GROUP * >::iterator":
        r"""begin(FP_GROUPS self) -> std::vector< PCB_GROUP * >::iterator"""
        return _pcbnew.FP_GROUPS_begin(self)

    def end(self) -> "std::vector< PCB_GROUP * >::iterator":
        r"""end(FP_GROUPS self) -> std::vector< PCB_GROUP * >::iterator"""
        return _pcbnew.FP_GROUPS_end(self)

    def rbegin(self) -> "std::vector< PCB_GROUP * >::reverse_iterator":
        r"""rbegin(FP_GROUPS self) -> std::vector< PCB_GROUP * >::reverse_iterator"""
        return _pcbnew.FP_GROUPS_rbegin(self)

    def rend(self) -> "std::vector< PCB_GROUP * >::reverse_iterator":
        r"""rend(FP_GROUPS self) -> std::vector< PCB_GROUP * >::reverse_iterator"""
        return _pcbnew.FP_GROUPS_rend(self)

    def clear(self) -> "void":
        r"""clear(FP_GROUPS self)"""
        return _pcbnew.FP_GROUPS_clear(self)

    def get_allocator(self) -> "std::vector< PCB_GROUP * >::allocator_type":
        r"""get_allocator(FP_GROUPS self) -> std::vector< PCB_GROUP * >::allocator_type"""
        return _pcbnew.FP_GROUPS_get_allocator(self)

    def pop_back(self) -> "void":
        r"""pop_back(FP_GROUPS self)"""
        return _pcbnew.FP_GROUPS_pop_back(self)

    def erase(self, *args) -> "std::vector< PCB_GROUP * >::iterator":
        r"""
        erase(FP_GROUPS self, std::vector< PCB_GROUP * >::iterator pos) -> std::vector< PCB_GROUP * >::iterator
        erase(FP_GROUPS self, std::vector< PCB_GROUP * >::iterator first, std::vector< PCB_GROUP * >::iterator last) -> std::vector< PCB_GROUP * >::iterator
        """
        return _pcbnew.FP_GROUPS_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(FP_GROUPS self) -> FP_GROUPS
        __init__(FP_GROUPS self, FP_GROUPS other) -> FP_GROUPS
        __init__(FP_GROUPS self, std::vector< PCB_GROUP * >::size_type size) -> FP_GROUPS
        __init__(FP_GROUPS self, std::vector< PCB_GROUP * >::size_type size, PCB_GROUP value) -> FP_GROUPS
        """
        _pcbnew.FP_GROUPS_swiginit(self, _pcbnew.new_FP_GROUPS(*args))

    def push_back(self, x: "PCB_GROUP") -> "void":
        r"""push_back(FP_GROUPS self, PCB_GROUP x)"""
        return _pcbnew.FP_GROUPS_push_back(self, x)

    def front(self) -> "std::vector< PCB_GROUP * >::value_type":
        r"""front(FP_GROUPS self) -> PCB_GROUP"""
        return _pcbnew.FP_GROUPS_front(self)

    def back(self) -> "std::vector< PCB_GROUP * >::value_type":
        r"""back(FP_GROUPS self) -> PCB_GROUP"""
        return _pcbnew.FP_GROUPS_back(self)

    def assign(self, n: "std::vector< PCB_GROUP * >::size_type", x: "PCB_GROUP") -> "void":
        r"""assign(FP_GROUPS self, std::vector< PCB_GROUP * >::size_type n, PCB_GROUP x)"""
        return _pcbnew.FP_GROUPS_assign(self, n, x)

    def resize(self, *args) -> "void":
        r"""
        resize(FP_GROUPS self, std::vector< PCB_GROUP * >::size_type new_size)
        resize(FP_GROUPS self, std::vector< PCB_GROUP * >::size_type new_size, PCB_GROUP x)
        """
        return _pcbnew.FP_GROUPS_resize(self, *args)

    def insert(self, *args) -> "void":
        r"""
        insert(FP_GROUPS self, std::vector< PCB_GROUP * >::iterator pos, PCB_GROUP x) -> std::vector< PCB_GROUP * >::iterator
        insert(FP_GROUPS self, std::vector< PCB_GROUP * >::iterator pos, std::vector< PCB_GROUP * >::size_type n, PCB_GROUP x)
        """
        return _pcbnew.FP_GROUPS_insert(self, *args)

    def reserve(self, n: "std::vector< PCB_GROUP * >::size_type") -> "void":
        r"""reserve(FP_GROUPS self, std::vector< PCB_GROUP * >::size_type n)"""
        return _pcbnew.FP_GROUPS_reserve(self, n)

    def capacity(self) -> "std::vector< PCB_GROUP * >::size_type":
        r"""capacity(FP_GROUPS self) -> std::vector< PCB_GROUP * >::size_type"""
        return _pcbnew.FP_GROUPS_capacity(self)
    __swig_destroy__ = _pcbnew.delete_FP_GROUPS

# Register FP_GROUPS in _pcbnew:
_pcbnew.FP_GROUPS_swigregister(FP_GROUPS)

PAD_SHAPE_CIRCLE = _pcbnew.PAD_SHAPE_CIRCLE

PAD_SHAPE_RECT = _pcbnew.PAD_SHAPE_RECT

PAD_SHAPE_OVAL = _pcbnew.PAD_SHAPE_OVAL

PAD_SHAPE_TRAPEZOID = _pcbnew.PAD_SHAPE_TRAPEZOID

PAD_SHAPE_ROUNDRECT = _pcbnew.PAD_SHAPE_ROUNDRECT

PAD_SHAPE_CHAMFERED_RECT = _pcbnew.PAD_SHAPE_CHAMFERED_RECT

PAD_SHAPE_CUSTOM = _pcbnew.PAD_SHAPE_CUSTOM


def PAD_SHAPE_T_asString(a: "PAD_SHAPE") -> "std::string":
    r"""PAD_SHAPE_T_asString(PAD_SHAPE a) -> string"""
    return _pcbnew.PAD_SHAPE_T_asString(a)
PAD_DRILL_SHAPE_CIRCLE = _pcbnew.PAD_DRILL_SHAPE_CIRCLE

PAD_DRILL_SHAPE_OBLONG = _pcbnew.PAD_DRILL_SHAPE_OBLONG

PAD_ATTRIB_PTH = _pcbnew.PAD_ATTRIB_PTH

PAD_ATTRIB_SMD = _pcbnew.PAD_ATTRIB_SMD

PAD_ATTRIB_CONN = _pcbnew.PAD_ATTRIB_CONN

PAD_ATTRIB_NPTH = _pcbnew.PAD_ATTRIB_NPTH

PAD_PROP_NONE = _pcbnew.PAD_PROP_NONE

PAD_PROP_BGA = _pcbnew.PAD_PROP_BGA

PAD_PROP_FIDUCIAL_GLBL = _pcbnew.PAD_PROP_FIDUCIAL_GLBL

PAD_PROP_FIDUCIAL_LOCAL = _pcbnew.PAD_PROP_FIDUCIAL_LOCAL

PAD_PROP_TESTPOINT = _pcbnew.PAD_PROP_TESTPOINT

PAD_PROP_HEATSINK = _pcbnew.PAD_PROP_HEATSINK

PAD_PROP_CASTELLATED = _pcbnew.PAD_PROP_CASTELLATED

CUST_PAD_SHAPE_IN_ZONE_OUTLINE = _pcbnew.CUST_PAD_SHAPE_IN_ZONE_OUTLINE

CUST_PAD_SHAPE_IN_ZONE_CONVEXHULL = _pcbnew.CUST_PAD_SHAPE_IN_ZONE_CONVEXHULL

class PAD(BOARD_CONNECTED_ITEM):
    r"""Proxy of C++ PAD 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__(PAD self, FOOTPRINT parent) -> PAD
        __init__(PAD self, PAD aPad) -> PAD
        """
        _pcbnew.PAD_swiginit(self, _pcbnew.new_PAD(*args))

    @staticmethod
    def PTHMask() -> "LSET":
        r"""PTHMask() -> LSET"""
        return _pcbnew.PAD_PTHMask()

    @staticmethod
    def SMDMask() -> "LSET":
        r"""SMDMask() -> LSET"""
        return _pcbnew.PAD_SMDMask()

    @staticmethod
    def ConnSMDMask() -> "LSET":
        r"""ConnSMDMask() -> LSET"""
        return _pcbnew.PAD_ConnSMDMask()

    @staticmethod
    def UnplatedHoleMask() -> "LSET":
        r"""UnplatedHoleMask() -> LSET"""
        return _pcbnew.PAD_UnplatedHoleMask()

    @staticmethod
    def ApertureMask() -> "LSET":
        r"""ApertureMask() -> LSET"""
        return _pcbnew.PAD_ApertureMask()

    @staticmethod
    def ClassOf(aItem: "EDA_ITEM") -> "bool":
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.PAD_ClassOf(aItem)

    def IsType(self, aScanTypes: "KICAD_T const []") -> "bool":
        r"""IsType(PAD self, KICAD_T const [] aScanTypes) -> bool"""
        return _pcbnew.PAD_IsType(self, aScanTypes)

    def GetParent(self) -> "FOOTPRINT *":
        r"""GetParent(PAD self) -> FOOTPRINT"""
        return _pcbnew.PAD_GetParent(self)

    def GetParentAsString(self) -> "wxString":
        r"""GetParentAsString(PAD self) -> wxString"""
        return _pcbnew.PAD_GetParentAsString(self)

    def IsLocked(self) -> "bool":
        r"""IsLocked(PAD self) -> bool"""
        return _pcbnew.PAD_IsLocked(self)

    def ImportSettingsFrom(self, aMasterPad: "PAD") -> "void":
        r"""ImportSettingsFrom(PAD self, PAD aMasterPad)"""
        return _pcbnew.PAD_ImportSettingsFrom(self, aMasterPad)

    def IsFlipped(self) -> "bool":
        r"""IsFlipped(PAD self) -> bool"""
        return _pcbnew.PAD_IsFlipped(self)

    def SetNumber(self, aNumber: "wxString") -> "void":
        r"""SetNumber(PAD self, wxString aNumber)"""
        return _pcbnew.PAD_SetNumber(self, aNumber)

    def GetNumber(self) -> "wxString const &":
        r"""GetNumber(PAD self) -> wxString"""
        return _pcbnew.PAD_GetNumber(self)

    def CanHaveNumber(self) -> "bool":
        r"""CanHaveNumber(PAD self) -> bool"""
        return _pcbnew.PAD_CanHaveNumber(self)

    def SetPinFunction(self, aName: "wxString") -> "void":
        r"""SetPinFunction(PAD self, wxString aName)"""
        return _pcbnew.PAD_SetPinFunction(self, aName)

    def GetPinFunction(self) -> "wxString const &":
        r"""GetPinFunction(PAD self) -> wxString"""
        return _pcbnew.PAD_GetPinFunction(self)

    def SetPinType(self, aType: "wxString") -> "void":
        r"""SetPinType(PAD self, wxString aType)"""
        return _pcbnew.PAD_SetPinType(self, aType)

    def GetPinType(self) -> "wxString const &":
        r"""GetPinType(PAD self) -> wxString"""
        return _pcbnew.PAD_GetPinType(self)

    def SameLogicalPadAs(self, other: "PAD") -> "bool":
        r"""SameLogicalPadAs(PAD self, PAD other) -> bool"""
        return _pcbnew.PAD_SameLogicalPadAs(self, other)

    def SetShape(self, aShape: "PAD_SHAPE") -> "void":
        r"""SetShape(PAD self, PAD_SHAPE aShape)"""
        return _pcbnew.PAD_SetShape(self, aShape)

    def GetShape(self) -> "PAD_SHAPE":
        r"""GetShape(PAD self) -> PAD_SHAPE"""
        return _pcbnew.PAD_GetShape(self)

    def SetPosition(self, aPos: "wxPoint") -> "void":
        r"""SetPosition(PAD self, wxPoint aPos)"""
        return _pcbnew.PAD_SetPosition(self, aPos)

    def GetPosition(self) -> "wxPoint":
        r"""GetPosition(PAD self) -> wxPoint"""
        return _pcbnew.PAD_GetPosition(self)

    def GetAnchorPadShape(self) -> "PAD_SHAPE":
        r"""GetAnchorPadShape(PAD self) -> PAD_SHAPE"""
        return _pcbnew.PAD_GetAnchorPadShape(self)

    def GetCustomShapeInZoneOpt(self) -> "CUST_PAD_SHAPE_IN_ZONE":
        r"""GetCustomShapeInZoneOpt(PAD self) -> CUST_PAD_SHAPE_IN_ZONE"""
        return _pcbnew.PAD_GetCustomShapeInZoneOpt(self)

    def SetCustomShapeInZoneOpt(self, aOption: "CUST_PAD_SHAPE_IN_ZONE") -> "void":
        r"""SetCustomShapeInZoneOpt(PAD self, CUST_PAD_SHAPE_IN_ZONE aOption)"""
        return _pcbnew.PAD_SetCustomShapeInZoneOpt(self, aOption)

    def SetAnchorPadShape(self, aShape: "PAD_SHAPE") -> "void":
        r"""SetAnchorPadShape(PAD self, PAD_SHAPE aShape)"""
        return _pcbnew.PAD_SetAnchorPadShape(self, aShape)

    def IsOnCopperLayer(self) -> "bool":
        r"""IsOnCopperLayer(PAD self) -> bool"""
        return _pcbnew.PAD_IsOnCopperLayer(self)

    def SetY(self, y: "int") -> "void":
        r"""SetY(PAD self, int y)"""
        return _pcbnew.PAD_SetY(self, y)

    def SetX(self, x: "int") -> "void":
        r"""SetX(PAD self, int x)"""
        return _pcbnew.PAD_SetX(self, x)

    def SetPos0(self, aPos: "wxPoint") -> "void":
        r"""SetPos0(PAD self, wxPoint aPos)"""
        return _pcbnew.PAD_SetPos0(self, aPos)

    def GetPos0(self) -> "wxPoint const &":
        r"""GetPos0(PAD self) -> wxPoint"""
        return _pcbnew.PAD_GetPos0(self)

    def SetY0(self, y: "int") -> "void":
        r"""SetY0(PAD self, int y)"""
        return _pcbnew.PAD_SetY0(self, y)

    def SetX0(self, x: "int") -> "void":
        r"""SetX0(PAD self, int x)"""
        return _pcbnew.PAD_SetX0(self, x)

    def SetSize(self, aSize: "wxSize") -> "void":
        r"""SetSize(PAD self, wxSize aSize)"""
        return _pcbnew.PAD_SetSize(self, aSize)

    def GetSize(self) -> "wxSize const &":
        r"""GetSize(PAD self) -> wxSize"""
        return _pcbnew.PAD_GetSize(self)

    def SetSizeX(self, aX: "int const") -> "void":
        r"""SetSizeX(PAD self, int const aX)"""
        return _pcbnew.PAD_SetSizeX(self, aX)

    def GetSizeX(self) -> "int const":
        r"""GetSizeX(PAD self) -> int const"""
        return _pcbnew.PAD_GetSizeX(self)

    def SetSizeY(self, aY: "int const") -> "void":
        r"""SetSizeY(PAD self, int const aY)"""
        return _pcbnew.PAD_SetSizeY(self, aY)

    def GetSizeY(self) -> "int const":
        r"""GetSizeY(PAD self) -> int const"""
        return _pcbnew.PAD_GetSizeY(self)

    def SetDelta(self, aSize: "wxSize") -> "void":
        r"""SetDelta(PAD self, wxSize aSize)"""
        return _pcbnew.PAD_SetDelta(self, aSize)

    def GetDelta(self) -> "wxSize const &":
        r"""GetDelta(PAD self) -> wxSize"""
        return _pcbnew.PAD_GetDelta(self)

    def SetDrillSize(self, aSize: "wxSize") -> "void":
        r"""SetDrillSize(PAD self, wxSize aSize)"""
        return _pcbnew.PAD_SetDrillSize(self, aSize)

    def GetDrillSize(self) -> "wxSize const &":
        r"""GetDrillSize(PAD self) -> wxSize"""
        return _pcbnew.PAD_GetDrillSize(self)

    def SetDrillSizeX(self, aX: "int const") -> "void":
        r"""SetDrillSizeX(PAD self, int const aX)"""
        return _pcbnew.PAD_SetDrillSizeX(self, aX)

    def GetDrillSizeX(self) -> "int const":
        r"""GetDrillSizeX(PAD self) -> int const"""
        return _pcbnew.PAD_GetDrillSizeX(self)

    def SetDrillSizeY(self, aY: "int const") -> "void":
        r"""SetDrillSizeY(PAD self, int const aY)"""
        return _pcbnew.PAD_SetDrillSizeY(self, aY)

    def GetDrillSizeY(self) -> "int const":
        r"""GetDrillSizeY(PAD self) -> int const"""
        return _pcbnew.PAD_GetDrillSizeY(self)

    def SetOffset(self, aOffset: "wxPoint") -> "void":
        r"""SetOffset(PAD self, wxPoint aOffset)"""
        return _pcbnew.PAD_SetOffset(self, aOffset)

    def GetOffset(self) -> "wxPoint const &":
        r"""GetOffset(PAD self) -> wxPoint"""
        return _pcbnew.PAD_GetOffset(self)

    def GetCenter(self) -> "wxPoint":
        r"""GetCenter(PAD self) -> wxPoint"""
        return _pcbnew.PAD_GetCenter(self)

    def AddPrimitivePoly(self, *args) -> "void":
        r"""
        AddPrimitivePoly(PAD self, SHAPE_POLY_SET aPoly, int aThickness, bool aFilled)
        AddPrimitivePoly(PAD self, wxPoint_Vector aPoly, int aThickness, bool aFilled)
        """
        return _pcbnew.PAD_AddPrimitivePoly(self, *args)

    def AddPrimitiveSegment(self, aStart: "wxPoint", aEnd: "wxPoint", aThickness: "int") -> "void":
        r"""AddPrimitiveSegment(PAD self, wxPoint aStart, wxPoint aEnd, int aThickness)"""
        return _pcbnew.PAD_AddPrimitiveSegment(self, aStart, aEnd, aThickness)

    def AddPrimitiveCircle(self, aCenter: "wxPoint", aRadius: "int", aThickness: "int", aFilled: "bool") -> "void":
        r"""AddPrimitiveCircle(PAD self, wxPoint aCenter, int aRadius, int aThickness, bool aFilled)"""
        return _pcbnew.PAD_AddPrimitiveCircle(self, aCenter, aRadius, aThickness, aFilled)

    def AddPrimitiveRect(self, aStart: "wxPoint", aEnd: "wxPoint", aThickness: "int", aFilled: "bool") -> "void":
        r"""AddPrimitiveRect(PAD self, wxPoint aStart, wxPoint aEnd, int aThickness, bool aFilled)"""
        return _pcbnew.PAD_AddPrimitiveRect(self, aStart, aEnd, aThickness, aFilled)

    def AddPrimitiveArc(self, aCenter: "wxPoint", aStart: "wxPoint", aArcAngle: "int", aThickness: "int") -> "void":
        r"""AddPrimitiveArc(PAD self, wxPoint aCenter, wxPoint aStart, int aArcAngle, int aThickness)"""
        return _pcbnew.PAD_AddPrimitiveArc(self, aCenter, aStart, aArcAngle, aThickness)

    def AddPrimitiveCurve(self, aStart: "wxPoint", aEnd: "wxPoint", aCtrl1: "wxPoint", aCtrl2: "wxPoint", aThickness: "int") -> "void":
        r"""AddPrimitiveCurve(PAD self, wxPoint aStart, wxPoint aEnd, wxPoint aCtrl1, wxPoint aCtrl2, int aThickness)"""
        return _pcbnew.PAD_AddPrimitiveCurve(self, aStart, aEnd, aCtrl1, aCtrl2, aThickness)

    def GetBestAnchorPosition(self, aPos: "VECTOR2I") -> "bool":
        r"""GetBestAnchorPosition(PAD self, VECTOR2I aPos) -> bool"""
        return _pcbnew.PAD_GetBestAnchorPosition(self, aPos)

    def MergePrimitivesAsPolygon(self, *args) -> "void":
        r"""MergePrimitivesAsPolygon(PAD self, SHAPE_POLY_SET aMergedPolygon, ERROR_LOC aErrorLoc=ERROR_INSIDE)"""
        return _pcbnew.PAD_MergePrimitivesAsPolygon(self, *args)

    def DeletePrimitivesList(self) -> "void":
        r"""DeletePrimitivesList(PAD self)"""
        return _pcbnew.PAD_DeletePrimitivesList(self)

    def GetPrimitives(self) -> "std::vector< std::shared_ptr< PCB_SHAPE >,std::allocator< std::shared_ptr< PCB_SHAPE > > > const &":
        r"""GetPrimitives(PAD self) -> std::vector< std::shared_ptr< PCB_SHAPE >,std::allocator< std::shared_ptr< PCB_SHAPE > > > const &"""
        return _pcbnew.PAD_GetPrimitives(self)

    def Flip(self, aCentre: "wxPoint", aFlipLeftRight: "bool") -> "void":
        r"""Flip(PAD self, wxPoint aCentre, bool aFlipLeftRight)"""
        return _pcbnew.PAD_Flip(self, aCentre, aFlipLeftRight)

    def FlipPrimitives(self, aFlipLeftRight: "bool") -> "void":
        r"""FlipPrimitives(PAD self, bool aFlipLeftRight)"""
        return _pcbnew.PAD_FlipPrimitives(self, aFlipLeftRight)

    def ReplacePrimitives(self, aPrimitivesList: "std::vector< std::shared_ptr< PCB_SHAPE >,std::allocator< std::shared_ptr< PCB_SHAPE > > > const &") -> "void":
        r"""ReplacePrimitives(PAD self, std::vector< std::shared_ptr< PCB_SHAPE >,std::allocator< std::shared_ptr< PCB_SHAPE > > > const & aPrimitivesList)"""
        return _pcbnew.PAD_ReplacePrimitives(self, aPrimitivesList)

    def AppendPrimitives(self, aPrimitivesList: "std::vector< std::shared_ptr< PCB_SHAPE >,std::allocator< std::shared_ptr< PCB_SHAPE > > > const &") -> "void":
        r"""AppendPrimitives(PAD self, std::vector< std::shared_ptr< PCB_SHAPE >,std::allocator< std::shared_ptr< PCB_SHAPE > > > const & aPrimitivesList)"""
        return _pcbnew.PAD_AppendPrimitives(self, aPrimitivesList)

    def AddPrimitive(self, aPrimitive: "PCB_SHAPE") -> "void":
        r"""AddPrimitive(PAD self, PCB_SHAPE aPrimitive)"""
        return _pcbnew.PAD_AddPrimitive(self, aPrimitive)

    def SetOrientation(self, aAngle: "double") -> "void":
        r"""SetOrientation(PAD self, double aAngle)"""
        return _pcbnew.PAD_SetOrientation(self, aAngle)

    def SetOrientationDegrees(self, aOrientation: "double") -> "void":
        r"""SetOrientationDegrees(PAD self, double aOrientation)"""
        return _pcbnew.PAD_SetOrientationDegrees(self, aOrientation)

    def GetOrientation(self) -> "double":
        r"""GetOrientation(PAD self) -> double"""
        return _pcbnew.PAD_GetOrientation(self)

    def GetOrientationDegrees(self) -> "double":
        r"""GetOrientationDegrees(PAD self) -> double"""
        return _pcbnew.PAD_GetOrientationDegrees(self)

    def GetOrientationRadians(self) -> "double":
        r"""GetOrientationRadians(PAD self) -> double"""
        return _pcbnew.PAD_GetOrientationRadians(self)

    def SetDrillShape(self, aShape: "PAD_DRILL_SHAPE_T") -> "void":
        r"""SetDrillShape(PAD self, PAD_DRILL_SHAPE_T aShape)"""
        return _pcbnew.PAD_SetDrillShape(self, aShape)

    def GetDrillShape(self) -> "PAD_DRILL_SHAPE_T":
        r"""GetDrillShape(PAD self) -> PAD_DRILL_SHAPE_T"""
        return _pcbnew.PAD_GetDrillShape(self)

    def IsDirty(self) -> "bool":
        r"""IsDirty(PAD self) -> bool"""
        return _pcbnew.PAD_IsDirty(self)

    def SetDirty(self) -> "void":
        r"""SetDirty(PAD self)"""
        return _pcbnew.PAD_SetDirty(self)

    def SetLayerSet(self, aLayers: "LSET") -> "void":
        r"""SetLayerSet(PAD self, LSET aLayers)"""
        return _pcbnew.PAD_SetLayerSet(self, aLayers)

    def GetLayerSet(self) -> "LSET":
        r"""GetLayerSet(PAD self) -> LSET"""
        return _pcbnew.PAD_GetLayerSet(self)

    def SetAttribute(self, aAttribute: "PAD_ATTRIB") -> "void":
        r"""SetAttribute(PAD self, PAD_ATTRIB aAttribute)"""
        return _pcbnew.PAD_SetAttribute(self, aAttribute)

    def GetAttribute(self) -> "PAD_ATTRIB":
        r"""GetAttribute(PAD self) -> PAD_ATTRIB"""
        return _pcbnew.PAD_GetAttribute(self)

    def SetProperty(self, aProperty: "PAD_PROP") -> "void":
        r"""SetProperty(PAD self, PAD_PROP aProperty)"""
        return _pcbnew.PAD_SetProperty(self, aProperty)

    def GetProperty(self) -> "PAD_PROP":
        r"""GetProperty(PAD self) -> PAD_PROP"""
        return _pcbnew.PAD_GetProperty(self)

    def IsAperturePad(self) -> "bool":
        r"""IsAperturePad(PAD self) -> bool"""
        return _pcbnew.PAD_IsAperturePad(self)

    def SetPadToDieLength(self, aLength: "int") -> "void":
        r"""SetPadToDieLength(PAD self, int aLength)"""
        return _pcbnew.PAD_SetPadToDieLength(self, aLength)

    def GetPadToDieLength(self) -> "int":
        r"""GetPadToDieLength(PAD self) -> int"""
        return _pcbnew.PAD_GetPadToDieLength(self)

    def GetLocalSolderMaskMargin(self) -> "int":
        r"""GetLocalSolderMaskMargin(PAD self) -> int"""
        return _pcbnew.PAD_GetLocalSolderMaskMargin(self)

    def SetLocalSolderMaskMargin(self, aMargin: "int") -> "void":
        r"""SetLocalSolderMaskMargin(PAD self, int aMargin)"""
        return _pcbnew.PAD_SetLocalSolderMaskMargin(self, aMargin)

    def GetLocalClearance(self, *args) -> "int":
        r"""
        GetLocalClearance(PAD self, wxString aSource) -> int
        GetLocalClearance(PAD self) -> int
        """
        return _pcbnew.PAD_GetLocalClearance(self, *args)

    def SetLocalClearance(self, aClearance: "int") -> "void":
        r"""SetLocalClearance(PAD self, int aClearance)"""
        return _pcbnew.PAD_SetLocalClearance(self, aClearance)

    def GetLocalSolderPasteMargin(self) -> "int":
        r"""GetLocalSolderPasteMargin(PAD self) -> int"""
        return _pcbnew.PAD_GetLocalSolderPasteMargin(self)

    def SetLocalSolderPasteMargin(self, aMargin: "int") -> "void":
        r"""SetLocalSolderPasteMargin(PAD self, int aMargin)"""
        return _pcbnew.PAD_SetLocalSolderPasteMargin(self, aMargin)

    def GetLocalSolderPasteMarginRatio(self) -> "double":
        r"""GetLocalSolderPasteMarginRatio(PAD self) -> double"""
        return _pcbnew.PAD_GetLocalSolderPasteMarginRatio(self)

    def SetLocalSolderPasteMarginRatio(self, aRatio: "double") -> "void":
        r"""SetLocalSolderPasteMarginRatio(PAD self, double aRatio)"""
        return _pcbnew.PAD_SetLocalSolderPasteMarginRatio(self, aRatio)

    def TransformShapeWithClearanceToPolygon(self, aCornerBuffer: "SHAPE_POLY_SET", aLayer: "PCB_LAYER_ID", aClearanceValue: "int", aMaxError: "int", aErrorLoc: "ERROR_LOC", ignoreLineWidth: "bool"=False) -> "void":
        r"""TransformShapeWithClearanceToPolygon(PAD self, SHAPE_POLY_SET aCornerBuffer, PCB_LAYER_ID aLayer, int aClearanceValue, int aMaxError, ERROR_LOC aErrorLoc, bool ignoreLineWidth=False)"""
        return _pcbnew.PAD_TransformShapeWithClearanceToPolygon(self, aCornerBuffer, aLayer, aClearanceValue, aMaxError, aErrorLoc, ignoreLineWidth)

    def TransformHoleWithClearanceToPolygon(self, aCornerBuffer: "SHAPE_POLY_SET", aInflateValue: "int", aError: "int", aErrorLoc: "ERROR_LOC") -> "bool":
        r"""TransformHoleWithClearanceToPolygon(PAD self, SHAPE_POLY_SET aCornerBuffer, int aInflateValue, int aError, ERROR_LOC aErrorLoc) -> bool"""
        return _pcbnew.PAD_TransformHoleWithClearanceToPolygon(self, aCornerBuffer, aInflateValue, aError, aErrorLoc)

    def GetEffectiveShape(self, *args) -> "std::shared_ptr< SHAPE >":
        r"""GetEffectiveShape(PAD self, PCB_LAYER_ID aLayer=UNDEFINED_LAYER, FLASHING aFlash=DEFAULT) -> std::shared_ptr< SHAPE >"""
        return _pcbnew.PAD_GetEffectiveShape(self, *args)

    def GetEffectivePolygon(self) -> "std::shared_ptr< SHAPE_POLY_SET > const &":
        r"""GetEffectivePolygon(PAD self) -> std::shared_ptr< SHAPE_POLY_SET > const &"""
        return _pcbnew.PAD_GetEffectivePolygon(self)

    def GetEffectiveHoleShape(self) -> "SHAPE_SEGMENT const *":
        r"""GetEffectiveHoleShape(PAD self) -> SHAPE_SEGMENT const *"""
        return _pcbnew.PAD_GetEffectiveHoleShape(self)

    def GetBoundingRadius(self) -> "int":
        r"""GetBoundingRadius(PAD self) -> int"""
        return _pcbnew.PAD_GetBoundingRadius(self)

    def GetLocalClearanceOverrides(self, aSource: "wxString") -> "int":
        r"""GetLocalClearanceOverrides(PAD self, wxString aSource) -> int"""
        return _pcbnew.PAD_GetLocalClearanceOverrides(self, aSource)

    def GetSolderMaskMargin(self) -> "int":
        r"""GetSolderMaskMargin(PAD self) -> int"""
        return _pcbnew.PAD_GetSolderMaskMargin(self)

    def GetSolderPasteMargin(self) -> "wxSize":
        r"""GetSolderPasteMargin(PAD self) -> wxSize"""
        return _pcbnew.PAD_GetSolderPasteMargin(self)

    def SetZoneConnection(self, aType: "ZONE_CONNECTION") -> "void":
        r"""SetZoneConnection(PAD self, ZONE_CONNECTION aType)"""
        return _pcbnew.PAD_SetZoneConnection(self, aType)

    def GetZoneConnection(self) -> "ZONE_CONNECTION":
        r"""GetZoneConnection(PAD self) -> ZONE_CONNECTION"""
        return _pcbnew.PAD_GetZoneConnection(self)

    def GetEffectiveZoneConnection(self, aSource: "wxString"=None) -> "ZONE_CONNECTION":
        r"""GetEffectiveZoneConnection(PAD self, wxString aSource=None) -> ZONE_CONNECTION"""
        return _pcbnew.PAD_GetEffectiveZoneConnection(self, aSource)

    def SetThermalSpokeWidth(self, aWidth: "int") -> "void":
        r"""SetThermalSpokeWidth(PAD self, int aWidth)"""
        return _pcbnew.PAD_SetThermalSpokeWidth(self, aWidth)

    def GetThermalSpokeWidth(self) -> "int":
        r"""GetThermalSpokeWidth(PAD self) -> int"""
        return _pcbnew.PAD_GetThermalSpokeWidth(self)

    def GetEffectiveThermalSpokeWidth(self, aSource: "wxString"=None) -> "int":
        r"""GetEffectiveThermalSpokeWidth(PAD self, wxString aSource=None) -> int"""
        return _pcbnew.PAD_GetEffectiveThermalSpokeWidth(self, aSource)

    def SetThermalGap(self, aGap: "int") -> "void":
        r"""SetThermalGap(PAD self, int aGap)"""
        return _pcbnew.PAD_SetThermalGap(self, aGap)

    def GetThermalGap(self) -> "int":
        r"""GetThermalGap(PAD self) -> int"""
        return _pcbnew.PAD_GetThermalGap(self)

    def GetEffectiveThermalGap(self, aSource: "wxString"=None) -> "int":
        r"""GetEffectiveThermalGap(PAD self, wxString aSource=None) -> int"""
        return _pcbnew.PAD_GetEffectiveThermalGap(self, aSource)

    def SetRoundRectCornerRadius(self, aRadius: "double") -> "void":
        r"""SetRoundRectCornerRadius(PAD self, double aRadius)"""
        return _pcbnew.PAD_SetRoundRectCornerRadius(self, aRadius)

    def GetRoundRectCornerRadius(self) -> "int":
        r"""GetRoundRectCornerRadius(PAD self) -> int"""
        return _pcbnew.PAD_GetRoundRectCornerRadius(self)

    def ShapePos(self) -> "wxPoint":
        r"""ShapePos(PAD self) -> wxPoint"""
        return _pcbnew.PAD_ShapePos(self)

    def SetRoundRectRadiusRatio(self, aRadiusScale: "double") -> "void":
        r"""SetRoundRectRadiusRatio(PAD self, double aRadiusScale)"""
        return _pcbnew.PAD_SetRoundRectRadiusRatio(self, aRadiusScale)

    def GetRoundRectRadiusRatio(self) -> "double":
        r"""GetRoundRectRadiusRatio(PAD self) -> double"""
        return _pcbnew.PAD_GetRoundRectRadiusRatio(self)

    def SetChamferRectRatio(self, aChamferScale: "double") -> "void":
        r"""SetChamferRectRatio(PAD self, double aChamferScale)"""
        return _pcbnew.PAD_SetChamferRectRatio(self, aChamferScale)

    def GetChamferRectRatio(self) -> "double":
        r"""GetChamferRectRatio(PAD self) -> double"""
        return _pcbnew.PAD_GetChamferRectRatio(self)

    def SetChamferPositions(self, aPositions: "int") -> "void":
        r"""SetChamferPositions(PAD self, int aPositions)"""
        return _pcbnew.PAD_SetChamferPositions(self, aPositions)

    def GetChamferPositions(self) -> "int":
        r"""GetChamferPositions(PAD self) -> int"""
        return _pcbnew.PAD_GetChamferPositions(self)

    def GetSubRatsnest(self) -> "int":
        r"""GetSubRatsnest(PAD self) -> int"""
        return _pcbnew.PAD_GetSubRatsnest(self)

    def SetSubRatsnest(self, aSubRatsnest: "int") -> "void":
        r"""SetSubRatsnest(PAD self, int aSubRatsnest)"""
        return _pcbnew.PAD_SetSubRatsnest(self, aSubRatsnest)

    def SetRemoveUnconnected(self, aSet: "bool") -> "void":
        r"""SetRemoveUnconnected(PAD self, bool aSet)"""
        return _pcbnew.PAD_SetRemoveUnconnected(self, aSet)

    def GetRemoveUnconnected(self) -> "bool":
        r"""GetRemoveUnconnected(PAD self) -> bool"""
        return _pcbnew.PAD_GetRemoveUnconnected(self)

    def SetKeepTopBottom(self, aSet: "bool") -> "void":
        r"""SetKeepTopBottom(PAD self, bool aSet)"""
        return _pcbnew.PAD_SetKeepTopBottom(self, aSet)

    def GetKeepTopBottom(self) -> "bool":
        r"""GetKeepTopBottom(PAD self) -> bool"""
        return _pcbnew.PAD_GetKeepTopBottom(self)

    def GetMsgPanelInfo(self, aFrame: "EDA_DRAW_FRAME *", aList: "std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > &") -> "void":
        r"""GetMsgPanelInfo(PAD self, EDA_DRAW_FRAME * aFrame, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.PAD_GetMsgPanelInfo(self, aFrame, aList)

    def IsOnLayer(self, aLayer: "PCB_LAYER_ID") -> "bool":
        r"""IsOnLayer(PAD self, PCB_LAYER_ID aLayer) -> bool"""
        return _pcbnew.PAD_IsOnLayer(self, aLayer)

    def FlashLayer(self, *args) -> "bool":
        r"""
        FlashLayer(PAD self, int aLayer) -> bool
        FlashLayer(PAD self, LSET aLayers) -> bool
        """
        return _pcbnew.PAD_FlashLayer(self, *args)

    def HitTest(self, *args) -> "bool":
        r"""
        HitTest(PAD self, wxPoint aPosition, int aAccuracy=0) -> bool
        HitTest(PAD self, EDA_RECT aRect, bool aContained, int aAccuracy=0) -> bool
        """
        return _pcbnew.PAD_HitTest(self, *args)

    def GetClass(self) -> "wxString":
        r"""GetClass(PAD self) -> wxString"""
        return _pcbnew.PAD_GetClass(self)

    def GetBoundingBox(self) -> "EDA_RECT const":
        r"""GetBoundingBox(PAD self) -> EDA_RECT"""
        return _pcbnew.PAD_GetBoundingBox(self)

    def SetDrawCoord(self) -> "void":
        r"""SetDrawCoord(PAD self)"""
        return _pcbnew.PAD_SetDrawCoord(self)

    def SetLocalCoord(self) -> "void":
        r"""SetLocalCoord(PAD self)"""
        return _pcbnew.PAD_SetLocalCoord(self)

    @staticmethod
    def Compare(aPadRef: "PAD", aPadCmp: "PAD") -> "int":
        r"""Compare(PAD aPadRef, PAD aPadCmp) -> int"""
        return _pcbnew.PAD_Compare(aPadRef, aPadCmp)

    def Move(self, aMoveVector: "wxPoint") -> "void":
        r"""Move(PAD self, wxPoint aMoveVector)"""
        return _pcbnew.PAD_Move(self, aMoveVector)

    def Rotate(self, aRotCentre: "wxPoint", aAngle: "double") -> "void":
        r"""Rotate(PAD self, wxPoint aRotCentre, double aAngle)"""
        return _pcbnew.PAD_Rotate(self, aRotCentre, aAngle)

    def GetSelectMenuText(self, aUnits: "EDA_UNITS") -> "wxString":
        r"""GetSelectMenuText(PAD self, EDA_UNITS aUnits) -> wxString"""
        return _pcbnew.PAD_GetSelectMenuText(self, aUnits)

    def GetMenuImage(self) -> "BITMAPS":
        r"""GetMenuImage(PAD self) -> BITMAPS"""
        return _pcbnew.PAD_GetMenuImage(self)

    def ShowPadShape(self) -> "wxString":
        r"""ShowPadShape(PAD self) -> wxString"""
        return _pcbnew.PAD_ShowPadShape(self)

    def ShowPadAttr(self) -> "wxString":
        r"""ShowPadAttr(PAD self) -> wxString"""
        return _pcbnew.PAD_ShowPadAttr(self)

    def Clone(self) -> "EDA_ITEM *":
        r"""Clone(PAD self) -> EDA_ITEM"""
        return _pcbnew.PAD_Clone(self)

    def ClonePad(self) -> "PAD *":
        r"""ClonePad(PAD self) -> PAD"""
        return _pcbnew.PAD_ClonePad(self)

    def BuildEffectiveShapes(self, aLayer: "PCB_LAYER_ID") -> "void":
        r"""BuildEffectiveShapes(PAD self, PCB_LAYER_ID aLayer)"""
        return _pcbnew.PAD_BuildEffectiveShapes(self, aLayer)

    def BuildEffectivePolygon(self) -> "void":
        r"""BuildEffectivePolygon(PAD self)"""
        return _pcbnew.PAD_BuildEffectivePolygon(self)

    def ViewGetLayers(self, aLayers: "int []", aCount: "int &") -> "void":
        r"""ViewGetLayers(PAD self, int [] aLayers, int & aCount)"""
        return _pcbnew.PAD_ViewGetLayers(self, aLayers, aCount)

    def ViewGetLOD(self, aLayer: "int", aView: "KIGFX::VIEW *") -> "double":
        r"""ViewGetLOD(PAD self, int aLayer, KIGFX::VIEW * aView) -> double"""
        return _pcbnew.PAD_ViewGetLOD(self, aLayer, aView)

    def ViewBBox(self) -> "BOX2I const":
        r"""ViewBBox(PAD self) -> BOX2I const"""
        return _pcbnew.PAD_ViewBBox(self)

    def SwapData(self, aImage: "BOARD_ITEM") -> "void":
        r"""SwapData(PAD self, BOARD_ITEM aImage)"""
        return _pcbnew.PAD_SwapData(self, aImage)


        # SetPadName() is the old name for PAD::SetName()
        # define it for compatibility
    def SetPadName(self, aName):
        return self.SetNumber(aName)

    def SetName(self, aName):
        return self.SetNumber(aName)

    # GetPadName() is the old name for PAD::GetName()
    # define it for compatibility
    def GetPadName(self):
        return self.GetNumber()

    def GetName(self):
        return self.GetNumber()

    # AddPrimitive() is the old name for D_PAD::AddPrimitivePoly(),
    # PAD::AddPrimitiveSegment(), PAD::AddPrimitiveCircle(),
    # PAD::AddPrimitiveArc(), PAD::AddPrimitiveCurve()
    # define it for compatibility
    def AddPrimitive(self, *args):
        if len(args) == 2:
            return self.AddPrimitivePoly(*args, True)
        elif len(args) == 3:
            if type(args[1] in [wxPoint,wxSize]):
                return self.AddPrimitiveSegment(*args)
            else:
                return self.AddPrimitiveCircle(*args)
        elif len(args) == 4:
            return self.AddPrimitiveArc(*args)
        elif len(args) == 5:
            return self.AddPrimitiveCurve(*args)
        else:
            raise TypeError("Arguments not recognized.")

    # GetCustomShapeAsPolygon() is the old accessor to get custom shapes
    def GetCustomShapeAsPolygon(self, layer=UNDEFINED_LAYER):
        polygon_set = SHAPE_POLY_SET()
        self.MergePrimitivesAsPolygon(polygon_set)
        return polygon_set

    __swig_destroy__ = _pcbnew.delete_PAD

# Register PAD in _pcbnew:
_pcbnew.PAD_swigregister(PAD)

def PAD_PTHMask() -> "LSET":
    r"""PAD_PTHMask() -> LSET"""
    return _pcbnew.PAD_PTHMask()

def PAD_SMDMask() -> "LSET":
    r"""PAD_SMDMask() -> LSET"""
    return _pcbnew.PAD_SMDMask()

def PAD_ConnSMDMask() -> "LSET":
    r"""PAD_ConnSMDMask() -> LSET"""
    return _pcbnew.PAD_ConnSMDMask()

def PAD_UnplatedHoleMask() -> "LSET":
    r"""PAD_UnplatedHoleMask() -> LSET"""
    return _pcbnew.PAD_UnplatedHoleMask()

def PAD_ApertureMask() -> "LSET":
    r"""PAD_ApertureMask() -> LSET"""
    return _pcbnew.PAD_ApertureMask()

def PAD_ClassOf(aItem: "EDA_ITEM") -> "bool":
    r"""PAD_ClassOf(EDA_ITEM aItem) -> bool"""
    return _pcbnew.PAD_ClassOf(aItem)

def PAD_Compare(aPadRef: "PAD", aPadCmp: "PAD") -> "int":
    r"""PAD_Compare(PAD aPadRef, PAD aPadCmp) -> int"""
    return _pcbnew.PAD_Compare(aPadRef, aPadCmp)

ENDPOINT_START = _pcbnew.ENDPOINT_START

ENDPOINT_END = _pcbnew.ENDPOINT_END

VIATYPE_THROUGH = _pcbnew.VIATYPE_THROUGH

VIATYPE_BLIND_BURIED = _pcbnew.VIATYPE_BLIND_BURIED

VIATYPE_MICROVIA = _pcbnew.VIATYPE_MICROVIA

VIATYPE_NOT_DEFINED = _pcbnew.VIATYPE_NOT_DEFINED

UNDEFINED_DRILL_DIAMETER = _pcbnew.UNDEFINED_DRILL_DIAMETER

class PCB_TRACK(BOARD_CONNECTED_ITEM):
    r"""Proxy of C++ PCB_TRACK class."""

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

    @staticmethod
    def ClassOf(aItem: "EDA_ITEM") -> "bool":
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.PCB_TRACK_ClassOf(aItem)

    def __init__(self, aParent: "BOARD_ITEM", idtype: "KICAD_T"=PCB_TRACE_T):
        r"""__init__(PCB_TRACK self, BOARD_ITEM aParent, KICAD_T idtype=PCB_TRACE_T) -> PCB_TRACK"""
        _pcbnew.PCB_TRACK_swiginit(self, _pcbnew.new_PCB_TRACK(aParent, idtype))

    def Move(self, aMoveVector: "wxPoint") -> "void":
        r"""Move(PCB_TRACK self, wxPoint aMoveVector)"""
        return _pcbnew.PCB_TRACK_Move(self, aMoveVector)

    def Rotate(self, aRotCentre: "wxPoint", aAngle: "double") -> "void":
        r"""Rotate(PCB_TRACK self, wxPoint aRotCentre, double aAngle)"""
        return _pcbnew.PCB_TRACK_Rotate(self, aRotCentre, aAngle)

    def Flip(self, aCentre: "wxPoint", aFlipLeftRight: "bool") -> "void":
        r"""Flip(PCB_TRACK self, wxPoint aCentre, bool aFlipLeftRight)"""
        return _pcbnew.PCB_TRACK_Flip(self, aCentre, aFlipLeftRight)

    def SetPosition(self, aPos: "wxPoint") -> "void":
        r"""SetPosition(PCB_TRACK self, wxPoint aPos)"""
        return _pcbnew.PCB_TRACK_SetPosition(self, aPos)

    def GetPosition(self) -> "wxPoint":
        r"""GetPosition(PCB_TRACK self) -> wxPoint"""
        return _pcbnew.PCB_TRACK_GetPosition(self)

    def GetFocusPosition(self) -> "wxPoint const":
        r"""GetFocusPosition(PCB_TRACK self) -> wxPoint"""
        return _pcbnew.PCB_TRACK_GetFocusPosition(self)

    def SetWidth(self, aWidth: "int") -> "void":
        r"""SetWidth(PCB_TRACK self, int aWidth)"""
        return _pcbnew.PCB_TRACK_SetWidth(self, aWidth)

    def GetWidth(self) -> "int":
        r"""GetWidth(PCB_TRACK self) -> int"""
        return _pcbnew.PCB_TRACK_GetWidth(self)

    def SetEnd(self, aEnd: "wxPoint") -> "void":
        r"""SetEnd(PCB_TRACK self, wxPoint aEnd)"""
        return _pcbnew.PCB_TRACK_SetEnd(self, aEnd)

    def GetEnd(self) -> "wxPoint const &":
        r"""GetEnd(PCB_TRACK self) -> wxPoint"""
        return _pcbnew.PCB_TRACK_GetEnd(self)

    def SetStart(self, aStart: "wxPoint") -> "void":
        r"""SetStart(PCB_TRACK self, wxPoint aStart)"""
        return _pcbnew.PCB_TRACK_SetStart(self, aStart)

    def GetStart(self) -> "wxPoint const &":
        r"""GetStart(PCB_TRACK self) -> wxPoint"""
        return _pcbnew.PCB_TRACK_GetStart(self)

    def SetEndX(self, aX: "int") -> "void":
        r"""SetEndX(PCB_TRACK self, int aX)"""
        return _pcbnew.PCB_TRACK_SetEndX(self, aX)

    def SetEndY(self, aY: "int") -> "void":
        r"""SetEndY(PCB_TRACK self, int aY)"""
        return _pcbnew.PCB_TRACK_SetEndY(self, aY)

    def GetEndX(self) -> "int":
        r"""GetEndX(PCB_TRACK self) -> int"""
        return _pcbnew.PCB_TRACK_GetEndX(self)

    def GetEndY(self) -> "int":
        r"""GetEndY(PCB_TRACK self) -> int"""
        return _pcbnew.PCB_TRACK_GetEndY(self)

    def GetEndPoint(self, aEndPoint: "ENDPOINT_T") -> "wxPoint const &":
        r"""GetEndPoint(PCB_TRACK self, ENDPOINT_T aEndPoint) -> wxPoint"""
        return _pcbnew.PCB_TRACK_GetEndPoint(self, aEndPoint)

    def GetBoundingBox(self) -> "EDA_RECT const":
        r"""GetBoundingBox(PCB_TRACK self) -> EDA_RECT"""
        return _pcbnew.PCB_TRACK_GetBoundingBox(self)

    def GetLength(self) -> "double":
        r"""GetLength(PCB_TRACK self) -> double"""
        return _pcbnew.PCB_TRACK_GetLength(self)

    def TransformShapeWithClearanceToPolygon(self, aCornerBuffer: "SHAPE_POLY_SET", aLayer: "PCB_LAYER_ID", aClearanceValue: "int", aError: "int", aErrorLoc: "ERROR_LOC", ignoreLineWidth: "bool"=False) -> "void":
        r"""TransformShapeWithClearanceToPolygon(PCB_TRACK self, SHAPE_POLY_SET aCornerBuffer, PCB_LAYER_ID aLayer, int aClearanceValue, int aError, ERROR_LOC aErrorLoc, bool ignoreLineWidth=False)"""
        return _pcbnew.PCB_TRACK_TransformShapeWithClearanceToPolygon(self, aCornerBuffer, aLayer, aClearanceValue, aError, aErrorLoc, ignoreLineWidth)

    def GetEffectiveShape(self, *args) -> "std::shared_ptr< SHAPE >":
        r"""GetEffectiveShape(PCB_TRACK self, PCB_LAYER_ID aLayer=UNDEFINED_LAYER, FLASHING aFlash=DEFAULT) -> std::shared_ptr< SHAPE >"""
        return _pcbnew.PCB_TRACK_GetEffectiveShape(self, *args)

    def IsPointOnEnds(self, point: "wxPoint", min_dist: "int"=0) -> "EDA_ITEM_FLAGS":
        r"""IsPointOnEnds(PCB_TRACK self, wxPoint point, int min_dist=0) -> EDA_ITEM_FLAGS"""
        return _pcbnew.PCB_TRACK_IsPointOnEnds(self, point, min_dist)

    def IsNull(self) -> "bool":
        r"""IsNull(PCB_TRACK self) -> bool"""
        return _pcbnew.PCB_TRACK_IsNull(self)

    def GetMsgPanelInfo(self, aFrame: "EDA_DRAW_FRAME *", aList: "std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > &") -> "void":
        r"""GetMsgPanelInfo(PCB_TRACK self, EDA_DRAW_FRAME * aFrame, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.PCB_TRACK_GetMsgPanelInfo(self, aFrame, aList)

    def Visit(self, inspector: "INSPECTOR", testData: "void *", scanTypes: "KICAD_T const []") -> "SEARCH_RESULT":
        r"""Visit(PCB_TRACK self, INSPECTOR inspector, void * testData, KICAD_T const [] scanTypes) -> SEARCH_RESULT"""
        return _pcbnew.PCB_TRACK_Visit(self, inspector, testData, scanTypes)

    def HitTest(self, *args) -> "bool":
        r"""
        HitTest(PCB_TRACK self, wxPoint aPosition, int aAccuracy=0) -> bool
        HitTest(PCB_TRACK self, EDA_RECT aRect, bool aContained, int aAccuracy=0) -> bool
        """
        return _pcbnew.PCB_TRACK_HitTest(self, *args)

    def ApproxCollinear(self, aTrack: "PCB_TRACK") -> "bool":
        r"""ApproxCollinear(PCB_TRACK self, PCB_TRACK aTrack) -> bool"""
        return _pcbnew.PCB_TRACK_ApproxCollinear(self, aTrack)

    def GetClass(self) -> "wxString":
        r"""GetClass(PCB_TRACK self) -> wxString"""
        return _pcbnew.PCB_TRACK_GetClass(self)

    def GetLocalClearance(self, aSource: "wxString") -> "int":
        r"""GetLocalClearance(PCB_TRACK self, wxString aSource) -> int"""
        return _pcbnew.PCB_TRACK_GetLocalClearance(self, aSource)

    def GetSelectMenuText(self, aUnits: "EDA_UNITS") -> "wxString":
        r"""GetSelectMenuText(PCB_TRACK self, EDA_UNITS aUnits) -> wxString"""
        return _pcbnew.PCB_TRACK_GetSelectMenuText(self, aUnits)

    def GetMenuImage(self) -> "BITMAPS":
        r"""GetMenuImage(PCB_TRACK self) -> BITMAPS"""
        return _pcbnew.PCB_TRACK_GetMenuImage(self)

    def Clone(self) -> "EDA_ITEM *":
        r"""Clone(PCB_TRACK self) -> EDA_ITEM"""
        return _pcbnew.PCB_TRACK_Clone(self)

    def ViewGetLayers(self, aLayers: "int []", aCount: "int &") -> "void":
        r"""ViewGetLayers(PCB_TRACK self, int [] aLayers, int & aCount)"""
        return _pcbnew.PCB_TRACK_ViewGetLayers(self, aLayers, aCount)

    def ViewGetLOD(self, aLayer: "int", aView: "KIGFX::VIEW *") -> "double":
        r"""ViewGetLOD(PCB_TRACK self, int aLayer, KIGFX::VIEW * aView) -> double"""
        return _pcbnew.PCB_TRACK_ViewGetLOD(self, aLayer, aView)

    def ViewBBox(self) -> "BOX2I const":
        r"""ViewBBox(PCB_TRACK self) -> BOX2I const"""
        return _pcbnew.PCB_TRACK_ViewBBox(self)

    def SwapData(self, aImage: "BOARD_ITEM") -> "void":
        r"""SwapData(PCB_TRACK self, BOARD_ITEM aImage)"""
        return _pcbnew.PCB_TRACK_SwapData(self, aImage)

    def IsOnCopperLayer(self) -> "bool":
        r"""IsOnCopperLayer(PCB_TRACK self) -> bool"""
        return _pcbnew.PCB_TRACK_IsOnCopperLayer(self)
    __swig_destroy__ = _pcbnew.delete_PCB_TRACK

# Register PCB_TRACK in _pcbnew:
_pcbnew.PCB_TRACK_swigregister(PCB_TRACK)

def PCB_TRACK_ClassOf(aItem: "EDA_ITEM") -> "bool":
    r"""PCB_TRACK_ClassOf(EDA_ITEM aItem) -> bool"""
    return _pcbnew.PCB_TRACK_ClassOf(aItem)

class PCB_ARC(PCB_TRACK):
    r"""Proxy of C++ PCB_ARC 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__(PCB_ARC self, BOARD_ITEM aParent) -> PCB_ARC
        __init__(PCB_ARC self, BOARD_ITEM aParent, SHAPE_ARC const * aArc) -> PCB_ARC
        """
        _pcbnew.PCB_ARC_swiginit(self, _pcbnew.new_PCB_ARC(*args))

    @staticmethod
    def ClassOf(aItem: "EDA_ITEM") -> "bool":
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.PCB_ARC_ClassOf(aItem)

    def Move(self, aMoveVector: "wxPoint") -> "void":
        r"""Move(PCB_ARC self, wxPoint aMoveVector)"""
        return _pcbnew.PCB_ARC_Move(self, aMoveVector)

    def Rotate(self, aRotCentre: "wxPoint", aAngle: "double") -> "void":
        r"""Rotate(PCB_ARC self, wxPoint aRotCentre, double aAngle)"""
        return _pcbnew.PCB_ARC_Rotate(self, aRotCentre, aAngle)

    def Flip(self, aCentre: "wxPoint", aFlipLeftRight: "bool") -> "void":
        r"""Flip(PCB_ARC self, wxPoint aCentre, bool aFlipLeftRight)"""
        return _pcbnew.PCB_ARC_Flip(self, aCentre, aFlipLeftRight)

    def SetMid(self, aMid: "wxPoint") -> "void":
        r"""SetMid(PCB_ARC self, wxPoint aMid)"""
        return _pcbnew.PCB_ARC_SetMid(self, aMid)

    def GetMid(self) -> "wxPoint const &":
        r"""GetMid(PCB_ARC self) -> wxPoint"""
        return _pcbnew.PCB_ARC_GetMid(self)

    def SetPosition(self, aPos: "wxPoint") -> "void":
        r"""SetPosition(PCB_ARC self, wxPoint aPos)"""
        return _pcbnew.PCB_ARC_SetPosition(self, aPos)

    def GetPosition(self) -> "wxPoint":
        r"""GetPosition(PCB_ARC self) -> wxPoint"""
        return _pcbnew.PCB_ARC_GetPosition(self)

    def GetCenter(self) -> "wxPoint":
        r"""GetCenter(PCB_ARC self) -> wxPoint"""
        return _pcbnew.PCB_ARC_GetCenter(self)

    def GetRadius(self) -> "double":
        r"""GetRadius(PCB_ARC self) -> double"""
        return _pcbnew.PCB_ARC_GetRadius(self)

    def GetAngle(self) -> "double":
        r"""GetAngle(PCB_ARC self) -> double"""
        return _pcbnew.PCB_ARC_GetAngle(self)

    def GetArcAngleStart(self) -> "double":
        r"""GetArcAngleStart(PCB_ARC self) -> double"""
        return _pcbnew.PCB_ARC_GetArcAngleStart(self)

    def GetArcAngleEnd(self) -> "double":
        r"""GetArcAngleEnd(PCB_ARC self) -> double"""
        return _pcbnew.PCB_ARC_GetArcAngleEnd(self)

    def HitTest(self, *args) -> "bool":
        r"""
        HitTest(PCB_ARC self, wxPoint aPosition, int aAccuracy=0) -> bool
        HitTest(PCB_ARC self, EDA_RECT aRect, bool aContained=True, int aAccuracy=0) -> bool
        """
        return _pcbnew.PCB_ARC_HitTest(self, *args)

    def GetClass(self) -> "wxString":
        r"""GetClass(PCB_ARC self) -> wxString"""
        return _pcbnew.PCB_ARC_GetClass(self)

    def GetEffectiveShape(self, *args) -> "std::shared_ptr< SHAPE >":
        r"""GetEffectiveShape(PCB_ARC self, PCB_LAYER_ID aLayer=UNDEFINED_LAYER, FLASHING aFlash=DEFAULT) -> std::shared_ptr< SHAPE >"""
        return _pcbnew.PCB_ARC_GetEffectiveShape(self, *args)

    def GetLength(self) -> "double":
        r"""GetLength(PCB_ARC self) -> double"""
        return _pcbnew.PCB_ARC_GetLength(self)

    def Clone(self) -> "EDA_ITEM *":
        r"""Clone(PCB_ARC self) -> EDA_ITEM"""
        return _pcbnew.PCB_ARC_Clone(self)

    def SwapData(self, aImage: "BOARD_ITEM") -> "void":
        r"""SwapData(PCB_ARC self, BOARD_ITEM aImage)"""
        return _pcbnew.PCB_ARC_SwapData(self, aImage)
    __swig_destroy__ = _pcbnew.delete_PCB_ARC

# Register PCB_ARC in _pcbnew:
_pcbnew.PCB_ARC_swigregister(PCB_ARC)

def PCB_ARC_ClassOf(aItem: "EDA_ITEM") -> "bool":
    r"""PCB_ARC_ClassOf(EDA_ITEM aItem) -> bool"""
    return _pcbnew.PCB_ARC_ClassOf(aItem)

class PCB_VIA(PCB_TRACK):
    r"""Proxy of C++ PCB_VIA 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, aParent: "BOARD_ITEM"):
        r"""__init__(PCB_VIA self, BOARD_ITEM aParent) -> PCB_VIA"""
        _pcbnew.PCB_VIA_swiginit(self, _pcbnew.new_PCB_VIA(aParent))

    @staticmethod
    def ClassOf(aItem: "EDA_ITEM") -> "bool":
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.PCB_VIA_ClassOf(aItem)

    def IsType(self, aScanTypes: "KICAD_T const []") -> "bool":
        r"""IsType(PCB_VIA self, KICAD_T const [] aScanTypes) -> bool"""
        return _pcbnew.PCB_VIA_IsType(self, aScanTypes)

    def GetViaType(self) -> "VIATYPE":
        r"""GetViaType(PCB_VIA self) -> VIATYPE"""
        return _pcbnew.PCB_VIA_GetViaType(self)

    def SetViaType(self, aViaType: "VIATYPE") -> "void":
        r"""SetViaType(PCB_VIA self, VIATYPE aViaType)"""
        return _pcbnew.PCB_VIA_SetViaType(self, aViaType)

    def IsOnLayer(self, aLayer: "PCB_LAYER_ID") -> "bool":
        r"""IsOnLayer(PCB_VIA self, PCB_LAYER_ID aLayer) -> bool"""
        return _pcbnew.PCB_VIA_IsOnLayer(self, aLayer)

    def GetLayerSet(self) -> "LSET":
        r"""GetLayerSet(PCB_VIA self) -> LSET"""
        return _pcbnew.PCB_VIA_GetLayerSet(self)

    def SetLayerSet(self, aLayers: "LSET") -> "void":
        r"""SetLayerSet(PCB_VIA self, LSET aLayers)"""
        return _pcbnew.PCB_VIA_SetLayerSet(self, aLayers)

    def SetLayerPair(self, aTopLayer: "PCB_LAYER_ID", aBottomLayer: "PCB_LAYER_ID") -> "void":
        r"""SetLayerPair(PCB_VIA self, PCB_LAYER_ID aTopLayer, PCB_LAYER_ID aBottomLayer)"""
        return _pcbnew.PCB_VIA_SetLayerPair(self, aTopLayer, aBottomLayer)

    def SetBottomLayer(self, aLayer: "PCB_LAYER_ID") -> "void":
        r"""SetBottomLayer(PCB_VIA self, PCB_LAYER_ID aLayer)"""
        return _pcbnew.PCB_VIA_SetBottomLayer(self, aLayer)

    def SetTopLayer(self, aLayer: "PCB_LAYER_ID") -> "void":
        r"""SetTopLayer(PCB_VIA self, PCB_LAYER_ID aLayer)"""
        return _pcbnew.PCB_VIA_SetTopLayer(self, aLayer)

    def LayerPair(self, top_layer: "PCB_LAYER_ID *", bottom_layer: "PCB_LAYER_ID *") -> "void":
        r"""LayerPair(PCB_VIA self, PCB_LAYER_ID * top_layer, PCB_LAYER_ID * bottom_layer)"""
        return _pcbnew.PCB_VIA_LayerPair(self, top_layer, bottom_layer)

    def TopLayer(self) -> "PCB_LAYER_ID":
        r"""TopLayer(PCB_VIA self) -> PCB_LAYER_ID"""
        return _pcbnew.PCB_VIA_TopLayer(self)

    def BottomLayer(self) -> "PCB_LAYER_ID":
        r"""BottomLayer(PCB_VIA self) -> PCB_LAYER_ID"""
        return _pcbnew.PCB_VIA_BottomLayer(self)

    def SanitizeLayers(self) -> "void":
        r"""SanitizeLayers(PCB_VIA self)"""
        return _pcbnew.PCB_VIA_SanitizeLayers(self)

    def GetPosition(self) -> "wxPoint":
        r"""GetPosition(PCB_VIA self) -> wxPoint"""
        return _pcbnew.PCB_VIA_GetPosition(self)

    def SetPosition(self, aPoint: "wxPoint") -> "void":
        r"""SetPosition(PCB_VIA self, wxPoint aPoint)"""
        return _pcbnew.PCB_VIA_SetPosition(self, aPoint)

    def GetMsgPanelInfo(self, aFrame: "EDA_DRAW_FRAME *", aList: "std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > &") -> "void":
        r"""GetMsgPanelInfo(PCB_VIA self, EDA_DRAW_FRAME * aFrame, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.PCB_VIA_GetMsgPanelInfo(self, aFrame, aList)

    def HitTest(self, *args) -> "bool":
        r"""
        HitTest(PCB_VIA self, wxPoint aPosition, int aAccuracy=0) -> bool
        HitTest(PCB_VIA self, EDA_RECT aRect, bool aContained, int aAccuracy=0) -> bool
        """
        return _pcbnew.PCB_VIA_HitTest(self, *args)

    def GetClass(self) -> "wxString":
        r"""GetClass(PCB_VIA self) -> wxString"""
        return _pcbnew.PCB_VIA_GetClass(self)

    def GetSelectMenuText(self, aUnits: "EDA_UNITS") -> "wxString":
        r"""GetSelectMenuText(PCB_VIA self, EDA_UNITS aUnits) -> wxString"""
        return _pcbnew.PCB_VIA_GetSelectMenuText(self, aUnits)

    def GetMenuImage(self) -> "BITMAPS":
        r"""GetMenuImage(PCB_VIA self) -> BITMAPS"""
        return _pcbnew.PCB_VIA_GetMenuImage(self)

    def Clone(self) -> "EDA_ITEM *":
        r"""Clone(PCB_VIA self) -> EDA_ITEM"""
        return _pcbnew.PCB_VIA_Clone(self)

    def ViewGetLayers(self, aLayers: "int []", aCount: "int &") -> "void":
        r"""ViewGetLayers(PCB_VIA self, int [] aLayers, int & aCount)"""
        return _pcbnew.PCB_VIA_ViewGetLayers(self, aLayers, aCount)

    def ViewGetLOD(self, aLayer: "int", aView: "KIGFX::VIEW *") -> "double":
        r"""ViewGetLOD(PCB_VIA self, int aLayer, KIGFX::VIEW * aView) -> double"""
        return _pcbnew.PCB_VIA_ViewGetLOD(self, aLayer, aView)

    def Flip(self, aCentre: "wxPoint", aFlipLeftRight: "bool") -> "void":
        r"""Flip(PCB_VIA self, wxPoint aCentre, bool aFlipLeftRight)"""
        return _pcbnew.PCB_VIA_Flip(self, aCentre, aFlipLeftRight)

    def GetMinAnnulus(self, aLayer: "PCB_LAYER_ID", aSource: "wxString") -> "int":
        r"""GetMinAnnulus(PCB_VIA self, PCB_LAYER_ID aLayer, wxString aSource) -> int"""
        return _pcbnew.PCB_VIA_GetMinAnnulus(self, aLayer, aSource)

    def SetRemoveUnconnected(self, aSet: "bool") -> "void":
        r"""SetRemoveUnconnected(PCB_VIA self, bool aSet)"""
        return _pcbnew.PCB_VIA_SetRemoveUnconnected(self, aSet)

    def GetRemoveUnconnected(self) -> "bool":
        r"""GetRemoveUnconnected(PCB_VIA self) -> bool"""
        return _pcbnew.PCB_VIA_GetRemoveUnconnected(self)

    def SetKeepTopBottom(self, aSet: "bool") -> "void":
        r"""SetKeepTopBottom(PCB_VIA self, bool aSet)"""
        return _pcbnew.PCB_VIA_SetKeepTopBottom(self, aSet)

    def GetKeepTopBottom(self) -> "bool":
        r"""GetKeepTopBottom(PCB_VIA self) -> bool"""
        return _pcbnew.PCB_VIA_GetKeepTopBottom(self)

    def FlashLayer(self, *args) -> "bool":
        r"""
        FlashLayer(PCB_VIA self, int aLayer) -> bool
        FlashLayer(PCB_VIA self, LSET aLayers) -> bool
        """
        return _pcbnew.PCB_VIA_FlashLayer(self, *args)

    def SetDrill(self, aDrill: "int") -> "void":
        r"""SetDrill(PCB_VIA self, int aDrill)"""
        return _pcbnew.PCB_VIA_SetDrill(self, aDrill)

    def GetDrill(self) -> "int":
        r"""GetDrill(PCB_VIA self) -> int"""
        return _pcbnew.PCB_VIA_GetDrill(self)

    def GetDrillValue(self) -> "int":
        r"""GetDrillValue(PCB_VIA self) -> int"""
        return _pcbnew.PCB_VIA_GetDrillValue(self)

    def SetDrillDefault(self) -> "void":
        r"""SetDrillDefault(PCB_VIA self)"""
        return _pcbnew.PCB_VIA_SetDrillDefault(self)

    def GetIsFree(self) -> "bool":
        r"""GetIsFree(PCB_VIA self) -> bool"""
        return _pcbnew.PCB_VIA_GetIsFree(self)

    def SetIsFree(self, aFree: "bool"=True) -> "void":
        r"""SetIsFree(PCB_VIA self, bool aFree=True)"""
        return _pcbnew.PCB_VIA_SetIsFree(self, aFree)

    def IsDrillDefault(self) -> "bool":
        r"""IsDrillDefault(PCB_VIA self) -> bool"""
        return _pcbnew.PCB_VIA_IsDrillDefault(self)

    def SwapData(self, aImage: "BOARD_ITEM") -> "void":
        r"""SwapData(PCB_VIA self, BOARD_ITEM aImage)"""
        return _pcbnew.PCB_VIA_SwapData(self, aImage)

    def GetEffectiveShape(self, *args) -> "std::shared_ptr< SHAPE >":
        r"""GetEffectiveShape(PCB_VIA self, PCB_LAYER_ID aLayer=UNDEFINED_LAYER, FLASHING aFlash=DEFAULT) -> std::shared_ptr< SHAPE >"""
        return _pcbnew.PCB_VIA_GetEffectiveShape(self, *args)
    __swig_destroy__ = _pcbnew.delete_PCB_VIA

# Register PCB_VIA in _pcbnew:
_pcbnew.PCB_VIA_swigregister(PCB_VIA)

def PCB_VIA_ClassOf(aItem: "EDA_ITEM") -> "bool":
    r"""PCB_VIA_ClassOf(EDA_ITEM aItem) -> bool"""
    return _pcbnew.PCB_VIA_ClassOf(aItem)

class ZONE(BOARD_CONNECTED_ITEM):
    r"""Proxy of C++ ZONE 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__(ZONE self, BOARD_ITEM_CONTAINER parent, bool aInFP=False) -> ZONE
        __init__(ZONE self, ZONE aZone) -> ZONE
        """
        _pcbnew.ZONE_swiginit(self, _pcbnew.new_ZONE(*args))
    __swig_destroy__ = _pcbnew.delete_ZONE

    @staticmethod
    def ClassOf(aItem: "EDA_ITEM") -> "bool":
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.ZONE_ClassOf(aItem)

    def IsConnected(self) -> "bool":
        r"""IsConnected(ZONE self) -> bool"""
        return _pcbnew.ZONE_IsConnected(self)

    def GetNetClass(self) -> "NETCLASS *":
        r"""GetNetClass(ZONE self) -> NETCLASS *"""
        return _pcbnew.ZONE_GetNetClass(self)

    def GetNetClassName(self) -> "wxString":
        r"""GetNetClassName(ZONE self) -> wxString"""
        return _pcbnew.ZONE_GetNetClassName(self)

    def InitDataFromSrcInCopyCtor(self, aZone: "ZONE") -> "void":
        r"""InitDataFromSrcInCopyCtor(ZONE self, ZONE aZone)"""
        return _pcbnew.ZONE_InitDataFromSrcInCopyCtor(self, aZone)

    def GetPosition(self) -> "wxPoint":
        r"""GetPosition(ZONE self) -> wxPoint"""
        return _pcbnew.ZONE_GetPosition(self)

    def SetPosition(self, aPos: "wxPoint") -> "void":
        r"""SetPosition(ZONE self, wxPoint aPos)"""
        return _pcbnew.ZONE_SetPosition(self, aPos)

    def SetPriority(self, aPriority: "unsigned int") -> "void":
        r"""SetPriority(ZONE self, unsigned int aPriority)"""
        return _pcbnew.ZONE_SetPriority(self, aPriority)

    def GetPriority(self) -> "unsigned int":
        r"""GetPriority(ZONE self) -> unsigned int"""
        return _pcbnew.ZONE_GetPriority(self)

    def GetMsgPanelInfo(self, aFrame: "EDA_DRAW_FRAME *", aList: "std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > &") -> "void":
        r"""GetMsgPanelInfo(ZONE self, EDA_DRAW_FRAME * aFrame, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.ZONE_GetMsgPanelInfo(self, aFrame, aList)

    def SetLayerSet(self, aLayerSet: "LSET") -> "void":
        r"""SetLayerSet(ZONE self, LSET aLayerSet)"""
        return _pcbnew.ZONE_SetLayerSet(self, aLayerSet)

    def GetLayerSet(self) -> "LSET":
        r"""GetLayerSet(ZONE self) -> LSET"""
        return _pcbnew.ZONE_GetLayerSet(self)

    def GetZoneName(self) -> "wxString":
        r"""GetZoneName(ZONE self) -> wxString"""
        return _pcbnew.ZONE_GetZoneName(self)

    def SetZoneName(self, aName: "wxString") -> "void":
        r"""SetZoneName(ZONE self, wxString aName)"""
        return _pcbnew.ZONE_SetZoneName(self, aName)

    def Matches(self, aSearchData: "wxFindReplaceData const &", aAuxData: "void *") -> "bool":
        r"""Matches(ZONE self, wxFindReplaceData const & aSearchData, void * aAuxData) -> bool"""
        return _pcbnew.ZONE_Matches(self, aSearchData, aAuxData)

    def GetBoundingBox(self) -> "EDA_RECT const":
        r"""GetBoundingBox(ZONE self) -> EDA_RECT"""
        return _pcbnew.ZONE_GetBoundingBox(self)

    def GetCachedBoundingBox(self) -> "EDA_RECT const":
        r"""GetCachedBoundingBox(ZONE self) -> EDA_RECT"""
        return _pcbnew.ZONE_GetCachedBoundingBox(self)

    def CacheBoundingBox(self) -> "void":
        r"""CacheBoundingBox(ZONE self)"""
        return _pcbnew.ZONE_CacheBoundingBox(self)

    def GetLocalClearance(self, *args) -> "int":
        r"""
        GetLocalClearance(ZONE self, wxString aSource) -> int
        GetLocalClearance(ZONE self) -> int
        """
        return _pcbnew.ZONE_GetLocalClearance(self, *args)

    def SetLocalClearance(self, aClearance: "int") -> "void":
        r"""SetLocalClearance(ZONE self, int aClearance)"""
        return _pcbnew.ZONE_SetLocalClearance(self, aClearance)

    def IsOnCopperLayer(self) -> "bool":
        r"""IsOnCopperLayer(ZONE self) -> bool"""
        return _pcbnew.ZONE_IsOnCopperLayer(self)

    def CommonLayerExists(self, aLayerSet: "LSET") -> "bool":
        r"""CommonLayerExists(ZONE self, LSET aLayerSet) -> bool"""
        return _pcbnew.ZONE_CommonLayerExists(self, aLayerSet)

    def SetLayer(self, aLayer: "PCB_LAYER_ID") -> "void":
        r"""SetLayer(ZONE self, PCB_LAYER_ID aLayer)"""
        return _pcbnew.ZONE_SetLayer(self, aLayer)

    def GetLayer(self) -> "PCB_LAYER_ID":
        r"""GetLayer(ZONE self) -> PCB_LAYER_ID"""
        return _pcbnew.ZONE_GetLayer(self)

    def IsOnLayer(self, arg2: "PCB_LAYER_ID") -> "bool":
        r"""IsOnLayer(ZONE self, PCB_LAYER_ID arg2) -> bool"""
        return _pcbnew.ZONE_IsOnLayer(self, arg2)

    def ViewGetLayers(self, aLayers: "int []", aCount: "int &") -> "void":
        r"""ViewGetLayers(ZONE self, int [] aLayers, int & aCount)"""
        return _pcbnew.ZONE_ViewGetLayers(self, aLayers, aCount)

    def ViewGetLOD(self, aLayer: "int", aView: "KIGFX::VIEW *") -> "double":
        r"""ViewGetLOD(ZONE self, int aLayer, KIGFX::VIEW * aView) -> double"""
        return _pcbnew.ZONE_ViewGetLOD(self, aLayer, aView)

    def SetFillMode(self, aFillMode: "ZONE_FILL_MODE") -> "void":
        r"""SetFillMode(ZONE self, ZONE_FILL_MODE aFillMode)"""
        return _pcbnew.ZONE_SetFillMode(self, aFillMode)

    def GetFillMode(self) -> "ZONE_FILL_MODE":
        r"""GetFillMode(ZONE self) -> ZONE_FILL_MODE"""
        return _pcbnew.ZONE_GetFillMode(self)

    def SetThermalReliefGap(self, aThermalReliefGap: "int") -> "void":
        r"""SetThermalReliefGap(ZONE self, int aThermalReliefGap)"""
        return _pcbnew.ZONE_SetThermalReliefGap(self, aThermalReliefGap)

    def GetThermalReliefGap(self, *args) -> "int":
        r"""
        GetThermalReliefGap(ZONE self) -> int
        GetThermalReliefGap(ZONE self, PAD aPad, wxString aSource=None) -> int
        """
        return _pcbnew.ZONE_GetThermalReliefGap(self, *args)

    def SetThermalReliefSpokeWidth(self, aThermalReliefSpokeWidth: "int") -> "void":
        r"""SetThermalReliefSpokeWidth(ZONE self, int aThermalReliefSpokeWidth)"""
        return _pcbnew.ZONE_SetThermalReliefSpokeWidth(self, aThermalReliefSpokeWidth)

    def GetThermalReliefSpokeWidth(self, *args) -> "int":
        r"""
        GetThermalReliefSpokeWidth(ZONE self) -> int
        GetThermalReliefSpokeWidth(ZONE self, PAD aPad, wxString aSource=None) -> int
        """
        return _pcbnew.ZONE_GetThermalReliefSpokeWidth(self, *args)

    def CalculateFilledArea(self) -> "double":
        r"""CalculateFilledArea(ZONE self) -> double"""
        return _pcbnew.ZONE_CalculateFilledArea(self)

    def GetFilledArea(self) -> "double":
        r"""GetFilledArea(ZONE self) -> double"""
        return _pcbnew.ZONE_GetFilledArea(self)

    def GetLock(self) -> "std::mutex &":
        r"""GetLock(ZONE self) -> std::mutex &"""
        return _pcbnew.ZONE_GetLock(self)

    def GetFillFlag(self, aLayer: "PCB_LAYER_ID") -> "int":
        r"""GetFillFlag(ZONE self, PCB_LAYER_ID aLayer) -> int"""
        return _pcbnew.ZONE_GetFillFlag(self, aLayer)

    def SetFillFlag(self, aLayer: "PCB_LAYER_ID", aFlag: "bool") -> "void":
        r"""SetFillFlag(ZONE self, PCB_LAYER_ID aLayer, bool aFlag)"""
        return _pcbnew.ZONE_SetFillFlag(self, aLayer, aFlag)

    def IsFilled(self) -> "bool":
        r"""IsFilled(ZONE self) -> bool"""
        return _pcbnew.ZONE_IsFilled(self)

    def SetIsFilled(self, isFilled: "bool") -> "void":
        r"""SetIsFilled(ZONE self, bool isFilled)"""
        return _pcbnew.ZONE_SetIsFilled(self, isFilled)

    def NeedRefill(self) -> "bool":
        r"""NeedRefill(ZONE self) -> bool"""
        return _pcbnew.ZONE_NeedRefill(self)

    def SetNeedRefill(self, aNeedRefill: "bool") -> "void":
        r"""SetNeedRefill(ZONE self, bool aNeedRefill)"""
        return _pcbnew.ZONE_SetNeedRefill(self, aNeedRefill)

    def GetPadConnection(self, *args) -> "ZONE_CONNECTION":
        r"""
        GetPadConnection(ZONE self, PAD aPad, wxString aSource=None) -> ZONE_CONNECTION
        GetPadConnection(ZONE self) -> ZONE_CONNECTION
        """
        return _pcbnew.ZONE_GetPadConnection(self, *args)

    def SetPadConnection(self, aPadConnection: "ZONE_CONNECTION") -> "void":
        r"""SetPadConnection(ZONE self, ZONE_CONNECTION aPadConnection)"""
        return _pcbnew.ZONE_SetPadConnection(self, aPadConnection)

    def GetMinThickness(self) -> "int":
        r"""GetMinThickness(ZONE self) -> int"""
        return _pcbnew.ZONE_GetMinThickness(self)

    def SetMinThickness(self, aMinThickness: "int") -> "void":
        r"""SetMinThickness(ZONE self, int aMinThickness)"""
        return _pcbnew.ZONE_SetMinThickness(self, aMinThickness)

    def GetHatchThickness(self) -> "int":
        r"""GetHatchThickness(ZONE self) -> int"""
        return _pcbnew.ZONE_GetHatchThickness(self)

    def SetHatchThickness(self, aThickness: "int") -> "void":
        r"""SetHatchThickness(ZONE self, int aThickness)"""
        return _pcbnew.ZONE_SetHatchThickness(self, aThickness)

    def GetHatchGap(self) -> "int":
        r"""GetHatchGap(ZONE self) -> int"""
        return _pcbnew.ZONE_GetHatchGap(self)

    def SetHatchGap(self, aStep: "int") -> "void":
        r"""SetHatchGap(ZONE self, int aStep)"""
        return _pcbnew.ZONE_SetHatchGap(self, aStep)

    def GetHatchOrientation(self) -> "double":
        r"""GetHatchOrientation(ZONE self) -> double"""
        return _pcbnew.ZONE_GetHatchOrientation(self)

    def SetHatchOrientation(self, aStep: "double") -> "void":
        r"""SetHatchOrientation(ZONE self, double aStep)"""
        return _pcbnew.ZONE_SetHatchOrientation(self, aStep)

    def GetHatchSmoothingLevel(self) -> "int":
        r"""GetHatchSmoothingLevel(ZONE self) -> int"""
        return _pcbnew.ZONE_GetHatchSmoothingLevel(self)

    def SetHatchSmoothingLevel(self, aLevel: "int") -> "void":
        r"""SetHatchSmoothingLevel(ZONE self, int aLevel)"""
        return _pcbnew.ZONE_SetHatchSmoothingLevel(self, aLevel)

    def GetHatchSmoothingValue(self) -> "double":
        r"""GetHatchSmoothingValue(ZONE self) -> double"""
        return _pcbnew.ZONE_GetHatchSmoothingValue(self)

    def SetHatchSmoothingValue(self, aValue: "double") -> "void":
        r"""SetHatchSmoothingValue(ZONE self, double aValue)"""
        return _pcbnew.ZONE_SetHatchSmoothingValue(self, aValue)

    def GetHatchHoleMinArea(self) -> "double":
        r"""GetHatchHoleMinArea(ZONE self) -> double"""
        return _pcbnew.ZONE_GetHatchHoleMinArea(self)

    def SetHatchHoleMinArea(self, aPct: "double") -> "void":
        r"""SetHatchHoleMinArea(ZONE self, double aPct)"""
        return _pcbnew.ZONE_SetHatchHoleMinArea(self, aPct)

    def GetHatchBorderAlgorithm(self) -> "int":
        r"""GetHatchBorderAlgorithm(ZONE self) -> int"""
        return _pcbnew.ZONE_GetHatchBorderAlgorithm(self)

    def SetHatchBorderAlgorithm(self, aAlgo: "int") -> "void":
        r"""SetHatchBorderAlgorithm(ZONE self, int aAlgo)"""
        return _pcbnew.ZONE_SetHatchBorderAlgorithm(self, aAlgo)

    def GetSelectedCorner(self) -> "int":
        r"""GetSelectedCorner(ZONE self) -> int"""
        return _pcbnew.ZONE_GetSelectedCorner(self)

    def SetSelectedCorner(self, *args) -> "void":
        r"""
        SetSelectedCorner(ZONE self, int aCorner)
        SetSelectedCorner(ZONE self, wxPoint aPosition, int aAccuracy)
        """
        return _pcbnew.ZONE_SetSelectedCorner(self, *args)

    def GetLocalFlags(self) -> "int":
        r"""GetLocalFlags(ZONE self) -> int"""
        return _pcbnew.ZONE_GetLocalFlags(self)

    def SetLocalFlags(self, aFlags: "int") -> "void":
        r"""SetLocalFlags(ZONE self, int aFlags)"""
        return _pcbnew.ZONE_SetLocalFlags(self, aFlags)

    def FillSegments(self, *args) -> "std::vector< SEG,std::allocator< SEG > > const &":
        r"""
        FillSegments(ZONE self, PCB_LAYER_ID aLayer) -> std::vector< SEG,std::allocator< SEG > >
        FillSegments(ZONE self, PCB_LAYER_ID aLayer) -> std::vector< SEG,std::allocator< SEG > > const &
        """
        return _pcbnew.ZONE_FillSegments(self, *args)

    def Outline(self, *args) -> "SHAPE_POLY_SET const *":
        r"""
        Outline(ZONE self) -> SHAPE_POLY_SET
        Outline(ZONE self) -> SHAPE_POLY_SET
        """
        return _pcbnew.ZONE_Outline(self, *args)

    def SetOutline(self, aOutline: "SHAPE_POLY_SET") -> "void":
        r"""SetOutline(ZONE self, SHAPE_POLY_SET aOutline)"""
        return _pcbnew.ZONE_SetOutline(self, aOutline)

    def GetEffectiveShape(self, *args) -> "std::shared_ptr< SHAPE >":
        r"""GetEffectiveShape(ZONE self, PCB_LAYER_ID aLayer=UNDEFINED_LAYER, FLASHING aFlash=DEFAULT) -> std::shared_ptr< SHAPE >"""
        return _pcbnew.ZONE_GetEffectiveShape(self, *args)

    def HitTestFilledArea(self, aLayer: "PCB_LAYER_ID", aRefPos: "wxPoint", aAccuracy: "int"=0) -> "bool":
        r"""HitTestFilledArea(ZONE self, PCB_LAYER_ID aLayer, wxPoint aRefPos, int aAccuracy=0) -> bool"""
        return _pcbnew.ZONE_HitTestFilledArea(self, aLayer, aRefPos, aAccuracy)

    def HitTestCutout(self, *args) -> "bool":
        r"""
        HitTestCutout(ZONE self, VECTOR2I aRefPos, int * aOutlineIdx=None, int * aHoleIdx=None) -> bool
        HitTestCutout(ZONE self, wxPoint aRefPos, int * aOutlineIdx=None, int * aHoleIdx=None) -> bool
        """
        return _pcbnew.ZONE_HitTestCutout(self, *args)

    def GetInteractingZones(self, aLayer: "PCB_LAYER_ID", aZones: "ZONES") -> "void":
        r"""GetInteractingZones(ZONE self, PCB_LAYER_ID aLayer, ZONES aZones)"""
        return _pcbnew.ZONE_GetInteractingZones(self, aLayer, aZones)

    def TransformSolidAreasShapesToPolygon(self, *args) -> "void":
        r"""TransformSolidAreasShapesToPolygon(ZONE self, PCB_LAYER_ID aLayer, SHAPE_POLY_SET aCornerBuffer, int aError=ARC_HIGH_DEF)"""
        return _pcbnew.ZONE_TransformSolidAreasShapesToPolygon(self, *args)

    def TransformSmoothedOutlineToPolygon(self, aCornerBuffer: "SHAPE_POLY_SET", aClearance: "int", aError: "int", aErrorLoc: "ERROR_LOC", aBoardOutline: "SHAPE_POLY_SET") -> "void":
        r"""TransformSmoothedOutlineToPolygon(ZONE self, SHAPE_POLY_SET aCornerBuffer, int aClearance, int aError, ERROR_LOC aErrorLoc, SHAPE_POLY_SET aBoardOutline)"""
        return _pcbnew.ZONE_TransformSmoothedOutlineToPolygon(self, aCornerBuffer, aClearance, aError, aErrorLoc, aBoardOutline)

    def TransformShapeWithClearanceToPolygon(self, aCornerBuffer: "SHAPE_POLY_SET", aLayer: "PCB_LAYER_ID", aClearanceValue: "int", aError: "int", aErrorLoc: "ERROR_LOC", ignoreLineWidth: "bool"=False) -> "void":
        r"""TransformShapeWithClearanceToPolygon(ZONE self, SHAPE_POLY_SET aCornerBuffer, PCB_LAYER_ID aLayer, int aClearanceValue, int aError, ERROR_LOC aErrorLoc, bool ignoreLineWidth=False)"""
        return _pcbnew.ZONE_TransformShapeWithClearanceToPolygon(self, aCornerBuffer, aLayer, aClearanceValue, aError, aErrorLoc, ignoreLineWidth)

    def HitTestForCorner(self, *args) -> "bool":
        r"""
        HitTestForCorner(ZONE self, wxPoint refPos, int aAccuracy, SHAPE_POLY_SET::VERTEX_INDEX & aCornerHit) -> bool
        HitTestForCorner(ZONE self, wxPoint refPos, int aAccuracy) -> bool
        """
        return _pcbnew.ZONE_HitTestForCorner(self, *args)

    def HitTestForEdge(self, *args) -> "bool":
        r"""
        HitTestForEdge(ZONE self, wxPoint refPos, int aAccuracy, SHAPE_POLY_SET::VERTEX_INDEX & aCornerHit) -> bool
        HitTestForEdge(ZONE self, wxPoint refPos, int aAccuracy) -> bool
        """
        return _pcbnew.ZONE_HitTestForEdge(self, *args)

    def HitTest(self, *args) -> "bool":
        r"""
        HitTest(ZONE self, wxPoint aPosition, int aAccuracy=0) -> bool
        HitTest(ZONE self, EDA_RECT aRect, bool aContained=True, int aAccuracy=0) -> bool
        """
        return _pcbnew.ZONE_HitTest(self, *args)

    def UnFill(self) -> "bool":
        r"""UnFill(ZONE self) -> bool"""
        return _pcbnew.ZONE_UnFill(self)

    def Move(self, offset: "wxPoint") -> "void":
        r"""Move(ZONE self, wxPoint offset)"""
        return _pcbnew.ZONE_Move(self, offset)

    def MoveEdge(self, offset: "wxPoint", aEdge: "int") -> "void":
        r"""MoveEdge(ZONE self, wxPoint offset, int aEdge)"""
        return _pcbnew.ZONE_MoveEdge(self, offset, aEdge)

    def Rotate(self, aCentre: "wxPoint", aAngle: "double") -> "void":
        r"""Rotate(ZONE self, wxPoint aCentre, double aAngle)"""
        return _pcbnew.ZONE_Rotate(self, aCentre, aAngle)

    def Flip(self, aCentre: "wxPoint", aFlipLeftRight: "bool") -> "void":
        r"""Flip(ZONE self, wxPoint aCentre, bool aFlipLeftRight)"""
        return _pcbnew.ZONE_Flip(self, aCentre, aFlipLeftRight)

    def Mirror(self, aMirrorRef: "wxPoint", aMirrorLeftRight: "bool") -> "void":
        r"""Mirror(ZONE self, wxPoint aMirrorRef, bool aMirrorLeftRight)"""
        return _pcbnew.ZONE_Mirror(self, aMirrorRef, aMirrorLeftRight)

    def GetClass(self) -> "wxString":
        r"""GetClass(ZONE self) -> wxString"""
        return _pcbnew.ZONE_GetClass(self)

    def GetNumCorners(self) -> "int":
        r"""GetNumCorners(ZONE self) -> int"""
        return _pcbnew.ZONE_GetNumCorners(self)

    def Iterate(self) -> "SHAPE_POLY_SET::ITERATOR":
        r"""Iterate(ZONE self) -> SHAPE_POLY_SET::ITERATOR"""
        return _pcbnew.ZONE_Iterate(self)

    def IterateWithHoles(self) -> "SHAPE_POLY_SET::ITERATOR":
        r"""IterateWithHoles(ZONE self) -> SHAPE_POLY_SET::ITERATOR"""
        return _pcbnew.ZONE_IterateWithHoles(self)

    def CIterateWithHoles(self) -> "SHAPE_POLY_SET::CONST_ITERATOR":
        r"""CIterateWithHoles(ZONE self) -> SHAPE_POLY_SET::CONST_ITERATOR"""
        return _pcbnew.ZONE_CIterateWithHoles(self)

    def RemoveAllContours(self) -> "void":
        r"""RemoveAllContours(ZONE self)"""
        return _pcbnew.ZONE_RemoveAllContours(self)

    def GetCornerPosition(self, aCornerIndex: "int") -> "VECTOR2I const &":
        r"""GetCornerPosition(ZONE self, int aCornerIndex) -> VECTOR2I"""
        return _pcbnew.ZONE_GetCornerPosition(self, aCornerIndex)

    def SetCornerPosition(self, aCornerIndex: "int", new_pos: "wxPoint") -> "void":
        r"""SetCornerPosition(ZONE self, int aCornerIndex, wxPoint new_pos)"""
        return _pcbnew.ZONE_SetCornerPosition(self, aCornerIndex, new_pos)

    def NewHole(self) -> "void":
        r"""NewHole(ZONE self)"""
        return _pcbnew.ZONE_NewHole(self)

    def AppendCorner(self, aPosition: "wxPoint", aHoleIdx: "int", aAllowDuplication: "bool"=False) -> "bool":
        r"""AppendCorner(ZONE self, wxPoint aPosition, int aHoleIdx, bool aAllowDuplication=False) -> bool"""
        return _pcbnew.ZONE_AppendCorner(self, aPosition, aHoleIdx, aAllowDuplication)

    def GetHatchStyle(self) -> "ZONE_BORDER_DISPLAY_STYLE":
        r"""GetHatchStyle(ZONE self) -> ZONE_BORDER_DISPLAY_STYLE"""
        return _pcbnew.ZONE_GetHatchStyle(self)

    def SetHatchStyle(self, aStyle: "ZONE_BORDER_DISPLAY_STYLE") -> "void":
        r"""SetHatchStyle(ZONE self, ZONE_BORDER_DISPLAY_STYLE aStyle)"""
        return _pcbnew.ZONE_SetHatchStyle(self, aStyle)

    def IsSame(self, aZoneToCompare: "ZONE") -> "bool":
        r"""IsSame(ZONE self, ZONE aZoneToCompare) -> bool"""
        return _pcbnew.ZONE_IsSame(self, aZoneToCompare)

    def HasFilledPolysForLayer(self, aLayer: "PCB_LAYER_ID") -> "bool":
        r"""HasFilledPolysForLayer(ZONE self, PCB_LAYER_ID aLayer) -> bool"""
        return _pcbnew.ZONE_HasFilledPolysForLayer(self, aLayer)

    def GetFilledPolysList(self, aLayer: "PCB_LAYER_ID") -> "SHAPE_POLY_SET const &":
        r"""GetFilledPolysList(ZONE self, PCB_LAYER_ID aLayer) -> SHAPE_POLY_SET"""
        return _pcbnew.ZONE_GetFilledPolysList(self, aLayer)

    def CacheTriangulation(self, aLayer: "PCB_LAYER_ID"=UNDEFINED_LAYER) -> "void":
        r"""CacheTriangulation(ZONE self, PCB_LAYER_ID aLayer=UNDEFINED_LAYER)"""
        return _pcbnew.ZONE_CacheTriangulation(self, aLayer)

    def SetFilledPolysList(self, aLayer: "PCB_LAYER_ID", aPolysList: "SHAPE_POLY_SET") -> "void":
        r"""SetFilledPolysList(ZONE self, PCB_LAYER_ID aLayer, SHAPE_POLY_SET aPolysList)"""
        return _pcbnew.ZONE_SetFilledPolysList(self, aLayer, aPolysList)

    def SetRawPolysList(self, aLayer: "PCB_LAYER_ID", aPolysList: "SHAPE_POLY_SET") -> "void":
        r"""SetRawPolysList(ZONE self, PCB_LAYER_ID aLayer, SHAPE_POLY_SET aPolysList)"""
        return _pcbnew.ZONE_SetRawPolysList(self, aLayer, aPolysList)

    def IsIsland(self, aLayer: "PCB_LAYER_ID", aPolyIdx: "int") -> "bool":
        r"""IsIsland(ZONE self, PCB_LAYER_ID aLayer, int aPolyIdx) -> bool"""
        return _pcbnew.ZONE_IsIsland(self, aLayer, aPolyIdx)

    def SetIsIsland(self, aLayer: "PCB_LAYER_ID", aPolyIdx: "int") -> "void":
        r"""SetIsIsland(ZONE self, PCB_LAYER_ID aLayer, int aPolyIdx)"""
        return _pcbnew.ZONE_SetIsIsland(self, aLayer, aPolyIdx)

    def BuildSmoothedPoly(self, aSmoothedPoly: "SHAPE_POLY_SET", aLayer: "PCB_LAYER_ID", aBoardOutline: "SHAPE_POLY_SET", aSmoothedPolyWithApron: "SHAPE_POLY_SET"=None) -> "bool":
        r"""BuildSmoothedPoly(ZONE self, SHAPE_POLY_SET aSmoothedPoly, PCB_LAYER_ID aLayer, SHAPE_POLY_SET aBoardOutline, SHAPE_POLY_SET aSmoothedPolyWithApron=None) -> bool"""
        return _pcbnew.ZONE_BuildSmoothedPoly(self, aSmoothedPoly, aLayer, aBoardOutline, aSmoothedPolyWithApron)

    def SetCornerSmoothingType(self, aType: "int") -> "void":
        r"""SetCornerSmoothingType(ZONE self, int aType)"""
        return _pcbnew.ZONE_SetCornerSmoothingType(self, aType)

    def GetCornerSmoothingType(self) -> "int":
        r"""GetCornerSmoothingType(ZONE self) -> int"""
        return _pcbnew.ZONE_GetCornerSmoothingType(self)

    def SetCornerRadius(self, aRadius: "unsigned int") -> "void":
        r"""SetCornerRadius(ZONE self, unsigned int aRadius)"""
        return _pcbnew.ZONE_SetCornerRadius(self, aRadius)

    def GetCornerRadius(self) -> "unsigned int":
        r"""GetCornerRadius(ZONE self) -> unsigned int"""
        return _pcbnew.ZONE_GetCornerRadius(self)

    def GetFilledPolysUseThickness(self, *args) -> "bool":
        r"""
        GetFilledPolysUseThickness(ZONE self) -> bool
        GetFilledPolysUseThickness(ZONE self, PCB_LAYER_ID aLayer) -> bool
        """
        return _pcbnew.ZONE_GetFilledPolysUseThickness(self, *args)

    def GetFillVersion(self) -> "int":
        r"""GetFillVersion(ZONE self) -> int"""
        return _pcbnew.ZONE_GetFillVersion(self)

    def SetFillVersion(self, aVersion: "int") -> "void":
        r"""SetFillVersion(ZONE self, int aVersion)"""
        return _pcbnew.ZONE_SetFillVersion(self, aVersion)

    def RemoveCutout(self, aOutlineIdx: "int", aHoleIdx: "int") -> "void":
        r"""RemoveCutout(ZONE self, int aOutlineIdx, int aHoleIdx)"""
        return _pcbnew.ZONE_RemoveCutout(self, aOutlineIdx, aHoleIdx)

    def AddPolygon(self, *args) -> "void":
        r"""
        AddPolygon(ZONE self, wxPoint_Vector aPolygon)
        AddPolygon(ZONE self, SHAPE_LINE_CHAIN aPolygon)
        """
        return _pcbnew.ZONE_AddPolygon(self, *args)

    def SetFillSegments(self, aLayer: "PCB_LAYER_ID", aSegments: "std::vector< SEG,std::allocator< SEG > > const &") -> "void":
        r"""SetFillSegments(ZONE self, PCB_LAYER_ID aLayer, std::vector< SEG,std::allocator< SEG > > const & aSegments)"""
        return _pcbnew.ZONE_SetFillSegments(self, aLayer, aSegments)

    def RawPolysList(self, aLayer: "PCB_LAYER_ID") -> "SHAPE_POLY_SET &":
        r"""RawPolysList(ZONE self, PCB_LAYER_ID aLayer) -> SHAPE_POLY_SET"""
        return _pcbnew.ZONE_RawPolysList(self, aLayer)

    def GetSelectMenuText(self, aUnits: "EDA_UNITS") -> "wxString":
        r"""GetSelectMenuText(ZONE self, EDA_UNITS aUnits) -> wxString"""
        return _pcbnew.ZONE_GetSelectMenuText(self, aUnits)

    def GetMenuImage(self) -> "BITMAPS":
        r"""GetMenuImage(ZONE self) -> BITMAPS"""
        return _pcbnew.ZONE_GetMenuImage(self)

    def Clone(self) -> "EDA_ITEM *":
        r"""Clone(ZONE self) -> EDA_ITEM"""
        return _pcbnew.ZONE_Clone(self)

    def GetIsRuleArea(self) -> "bool":
        r"""GetIsRuleArea(ZONE self) -> bool"""
        return _pcbnew.ZONE_GetIsRuleArea(self)

    def GetDoNotAllowCopperPour(self) -> "bool":
        r"""GetDoNotAllowCopperPour(ZONE self) -> bool"""
        return _pcbnew.ZONE_GetDoNotAllowCopperPour(self)

    def GetDoNotAllowVias(self) -> "bool":
        r"""GetDoNotAllowVias(ZONE self) -> bool"""
        return _pcbnew.ZONE_GetDoNotAllowVias(self)

    def GetDoNotAllowTracks(self) -> "bool":
        r"""GetDoNotAllowTracks(ZONE self) -> bool"""
        return _pcbnew.ZONE_GetDoNotAllowTracks(self)

    def GetDoNotAllowPads(self) -> "bool":
        r"""GetDoNotAllowPads(ZONE self) -> bool"""
        return _pcbnew.ZONE_GetDoNotAllowPads(self)

    def GetDoNotAllowFootprints(self) -> "bool":
        r"""GetDoNotAllowFootprints(ZONE self) -> bool"""
        return _pcbnew.ZONE_GetDoNotAllowFootprints(self)

    def IsKeepout(self) -> "bool":
        r"""IsKeepout(ZONE self) -> bool"""
        return _pcbnew.ZONE_IsKeepout(self)

    def KeepoutAll(self) -> "bool":
        r"""KeepoutAll(ZONE self) -> bool"""
        return _pcbnew.ZONE_KeepoutAll(self)

    def SetIsRuleArea(self, aEnable: "bool") -> "void":
        r"""SetIsRuleArea(ZONE self, bool aEnable)"""
        return _pcbnew.ZONE_SetIsRuleArea(self, aEnable)

    def SetDoNotAllowCopperPour(self, aEnable: "bool") -> "void":
        r"""SetDoNotAllowCopperPour(ZONE self, bool aEnable)"""
        return _pcbnew.ZONE_SetDoNotAllowCopperPour(self, aEnable)

    def SetDoNotAllowVias(self, aEnable: "bool") -> "void":
        r"""SetDoNotAllowVias(ZONE self, bool aEnable)"""
        return _pcbnew.ZONE_SetDoNotAllowVias(self, aEnable)

    def SetDoNotAllowTracks(self, aEnable: "bool") -> "void":
        r"""SetDoNotAllowTracks(ZONE self, bool aEnable)"""
        return _pcbnew.ZONE_SetDoNotAllowTracks(self, aEnable)

    def SetDoNotAllowPads(self, aEnable: "bool") -> "void":
        r"""SetDoNotAllowPads(ZONE self, bool aEnable)"""
        return _pcbnew.ZONE_SetDoNotAllowPads(self, aEnable)

    def SetDoNotAllowFootprints(self, aEnable: "bool") -> "void":
        r"""SetDoNotAllowFootprints(ZONE self, bool aEnable)"""
        return _pcbnew.ZONE_SetDoNotAllowFootprints(self, aEnable)

    def GetIslandRemovalMode(self) -> "ISLAND_REMOVAL_MODE const":
        r"""GetIslandRemovalMode(ZONE self) -> ISLAND_REMOVAL_MODE const"""
        return _pcbnew.ZONE_GetIslandRemovalMode(self)

    def SetIslandRemovalMode(self, aRemove: "ISLAND_REMOVAL_MODE") -> "void":
        r"""SetIslandRemovalMode(ZONE self, ISLAND_REMOVAL_MODE aRemove)"""
        return _pcbnew.ZONE_SetIslandRemovalMode(self, aRemove)

    def GetMinIslandArea(self) -> "long long":
        r"""GetMinIslandArea(ZONE self) -> long long"""
        return _pcbnew.ZONE_GetMinIslandArea(self)

    def SetMinIslandArea(self, aArea: "long long") -> "void":
        r"""SetMinIslandArea(ZONE self, long long aArea)"""
        return _pcbnew.ZONE_SetMinIslandArea(self, aArea)

    def GetBorderHatchPitch(self) -> "int":
        r"""GetBorderHatchPitch(ZONE self) -> int"""
        return _pcbnew.ZONE_GetBorderHatchPitch(self)

    @staticmethod
    def GetDefaultHatchPitch() -> "int":
        r"""GetDefaultHatchPitch() -> int"""
        return _pcbnew.ZONE_GetDefaultHatchPitch()

    def SetBorderDisplayStyle(self, aHatchStyle: "ZONE_BORDER_DISPLAY_STYLE", aHatchPitch: "int", aRebuildHatch: "bool") -> "void":
        r"""SetBorderDisplayStyle(ZONE self, ZONE_BORDER_DISPLAY_STYLE aHatchStyle, int aHatchPitch, bool aRebuildHatch)"""
        return _pcbnew.ZONE_SetBorderDisplayStyle(self, aHatchStyle, aHatchPitch, aRebuildHatch)

    def SetHatchPitch(self, aPitch: "int") -> "void":
        r"""SetHatchPitch(ZONE self, int aPitch)"""
        return _pcbnew.ZONE_SetHatchPitch(self, aPitch)

    def UnHatchBorder(self) -> "void":
        r"""UnHatchBorder(ZONE self)"""
        return _pcbnew.ZONE_UnHatchBorder(self)

    def HatchBorder(self) -> "void":
        r"""HatchBorder(ZONE self)"""
        return _pcbnew.ZONE_HatchBorder(self)

    def GetHatchLines(self) -> "std::vector< SEG,std::allocator< SEG > > const &":
        r"""GetHatchLines(ZONE self) -> std::vector< SEG,std::allocator< SEG > > const &"""
        return _pcbnew.ZONE_GetHatchLines(self)

    def GetHV45(self) -> "bool":
        r"""GetHV45(ZONE self) -> bool"""
        return _pcbnew.ZONE_GetHV45(self)

    def SetHV45(self, aConstrain: "bool") -> "void":
        r"""SetHV45(ZONE self, bool aConstrain)"""
        return _pcbnew.ZONE_SetHV45(self, aConstrain)

    def BuildHashValue(self, aLayer: "PCB_LAYER_ID") -> "void":
        r"""BuildHashValue(ZONE self, PCB_LAYER_ID aLayer)"""
        return _pcbnew.ZONE_BuildHashValue(self, aLayer)

    def GetHashValue(self, aLayer: "PCB_LAYER_ID") -> "MD5_HASH":
        r"""GetHashValue(ZONE self, PCB_LAYER_ID aLayer) -> MD5_HASH"""
        return _pcbnew.ZONE_GetHashValue(self, aLayer)

    def SwapData(self, aImage: "BOARD_ITEM") -> "void":
        r"""SwapData(ZONE self, BOARD_ITEM aImage)"""
        return _pcbnew.ZONE_SwapData(self, aImage)

# Register ZONE in _pcbnew:
_pcbnew.ZONE_swigregister(ZONE)

def ZONE_ClassOf(aItem: "EDA_ITEM") -> "bool":
    r"""ZONE_ClassOf(EDA_ITEM aItem) -> bool"""
    return _pcbnew.ZONE_ClassOf(aItem)

def ZONE_GetDefaultHatchPitch() -> "int":
    r"""ZONE_GetDefaultHatchPitch() -> int"""
    return _pcbnew.ZONE_GetDefaultHatchPitch()

class FP_ZONE(ZONE):
    r"""Proxy of C++ FP_ZONE 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__(FP_ZONE self, BOARD_ITEM_CONTAINER aParent) -> FP_ZONE
        __init__(FP_ZONE self, FP_ZONE aZone) -> FP_ZONE
        """
        _pcbnew.FP_ZONE_swiginit(self, _pcbnew.new_FP_ZONE(*args))

    def Clone(self) -> "EDA_ITEM *":
        r"""Clone(FP_ZONE self) -> EDA_ITEM"""
        return _pcbnew.FP_ZONE_Clone(self)

    def ViewGetLOD(self, aLayer: "int", aView: "KIGFX::VIEW *") -> "double":
        r"""ViewGetLOD(FP_ZONE self, int aLayer, KIGFX::VIEW * aView) -> double"""
        return _pcbnew.FP_ZONE_ViewGetLOD(self, aLayer, aView)
    __swig_destroy__ = _pcbnew.delete_FP_ZONE

# Register FP_ZONE in _pcbnew:
_pcbnew.FP_ZONE_swigregister(FP_ZONE)

ZONE_THERMAL_RELIEF_GAP_MIL = _pcbnew.ZONE_THERMAL_RELIEF_GAP_MIL

ZONE_THERMAL_RELIEF_COPPER_WIDTH_MIL = _pcbnew.ZONE_THERMAL_RELIEF_COPPER_WIDTH_MIL

ZONE_THICKNESS_MIL = _pcbnew.ZONE_THICKNESS_MIL

ZONE_THICKNESS_MIN_VALUE_MIL = _pcbnew.ZONE_THICKNESS_MIN_VALUE_MIL

ZONE_CLEARANCE_MIL = _pcbnew.ZONE_CLEARANCE_MIL

ZONE_CLEARANCE_MAX_VALUE_MIL = _pcbnew.ZONE_CLEARANCE_MAX_VALUE_MIL

ZONE_EXPORT_VALUES = _pcbnew.ZONE_EXPORT_VALUES

ZONE_CONNECTION_INHERITED = _pcbnew.ZONE_CONNECTION_INHERITED

ZONE_CONNECTION_NONE = _pcbnew.ZONE_CONNECTION_NONE

ZONE_CONNECTION_THERMAL = _pcbnew.ZONE_CONNECTION_THERMAL

ZONE_CONNECTION_FULL = _pcbnew.ZONE_CONNECTION_FULL

ZONE_CONNECTION_THT_THERMAL = _pcbnew.ZONE_CONNECTION_THT_THERMAL


def InvokeNonCopperZonesEditor(aParent: "PCB_BASE_FRAME *", aSettings: "ZONE_SETTINGS") -> "int":
    r"""InvokeNonCopperZonesEditor(PCB_BASE_FRAME * aParent, ZONE_SETTINGS aSettings) -> int"""
    return _pcbnew.InvokeNonCopperZonesEditor(aParent, aSettings)

def InvokeCopperZonesEditor(aCaller: "PCB_BASE_FRAME *", aSettings: "ZONE_SETTINGS") -> "int":
    r"""InvokeCopperZonesEditor(PCB_BASE_FRAME * aCaller, ZONE_SETTINGS aSettings) -> int"""
    return _pcbnew.InvokeCopperZonesEditor(aCaller, aSettings)

def InvokeRuleAreaEditor(aCaller: "PCB_BASE_FRAME *", aSettings: "ZONE_SETTINGS") -> "int":
    r"""InvokeRuleAreaEditor(PCB_BASE_FRAME * aCaller, ZONE_SETTINGS aSettings) -> int"""
    return _pcbnew.InvokeRuleAreaEditor(aCaller, aSettings)
class ZONE_FILLER(object):
    r"""Proxy of C++ ZONE_FILLER class."""

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

    def SetProgressReporter(self, aReporter: "PROGRESS_REPORTER *") -> "void":
        r"""SetProgressReporter(ZONE_FILLER self, PROGRESS_REPORTER * aReporter)"""
        return _pcbnew.ZONE_FILLER_SetProgressReporter(self, aReporter)

    def Fill(self, aZones: "ZONES", aCheck: "bool"=False, aParent: "wxWindow *"=None) -> "bool":
        r"""Fill(ZONE_FILLER self, ZONES aZones, bool aCheck=False, wxWindow * aParent=None) -> bool"""
        return _pcbnew.ZONE_FILLER_Fill(self, aZones, aCheck, aParent)

    def IsDebug(self) -> "bool":
        r"""IsDebug(ZONE_FILLER self) -> bool"""
        return _pcbnew.ZONE_FILLER_IsDebug(self)

    def __init__(self, aBoard: "BOARD"):
        r"""__init__(ZONE_FILLER self, BOARD aBoard) -> ZONE_FILLER"""
        _pcbnew.ZONE_FILLER_swiginit(self, _pcbnew.new_ZONE_FILLER(aBoard))

# Register ZONE_FILLER in _pcbnew:
_pcbnew.ZONE_FILLER_swigregister(ZONE_FILLER)

ZONE_FILL_MODE_POLYGONS = _pcbnew.ZONE_FILL_MODE_POLYGONS

ZONE_FILL_MODE_HATCH_PATTERN = _pcbnew.ZONE_FILL_MODE_HATCH_PATTERN

ZONE_BORDER_DISPLAY_STYLE_NO_HATCH = _pcbnew.ZONE_BORDER_DISPLAY_STYLE_NO_HATCH

ZONE_BORDER_DISPLAY_STYLE_DIAGONAL_FULL = _pcbnew.ZONE_BORDER_DISPLAY_STYLE_DIAGONAL_FULL

ZONE_BORDER_DISPLAY_STYLE_DIAGONAL_EDGE = _pcbnew.ZONE_BORDER_DISPLAY_STYLE_DIAGONAL_EDGE

ISLAND_REMOVAL_MODE_ALWAYS = _pcbnew.ISLAND_REMOVAL_MODE_ALWAYS

ISLAND_REMOVAL_MODE_NEVER = _pcbnew.ISLAND_REMOVAL_MODE_NEVER

ISLAND_REMOVAL_MODE_AREA = _pcbnew.ISLAND_REMOVAL_MODE_AREA

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    SMOOTHING_UNDEFINED = _pcbnew.ZONE_SETTINGS_SMOOTHING_UNDEFINED
    
    SMOOTHING_NONE = _pcbnew.ZONE_SETTINGS_SMOOTHING_NONE
    
    SMOOTHING_CHAMFER = _pcbnew.ZONE_SETTINGS_SMOOTHING_CHAMFER
    
    SMOOTHING_FILLET = _pcbnew.ZONE_SETTINGS_SMOOTHING_FILLET
    
    SMOOTHING_LAST = _pcbnew.ZONE_SETTINGS_SMOOTHING_LAST
    
    m_ZonePriority = property(_pcbnew.ZONE_SETTINGS_m_ZonePriority_get, _pcbnew.ZONE_SETTINGS_m_ZonePriority_set, doc=r"""m_ZonePriority : int""")
    m_FillMode = property(_pcbnew.ZONE_SETTINGS_m_FillMode_get, _pcbnew.ZONE_SETTINGS_m_FillMode_set, doc=r"""m_FillMode : ZONE_FILL_MODE""")
    m_ZoneClearance = property(_pcbnew.ZONE_SETTINGS_m_ZoneClearance_get, _pcbnew.ZONE_SETTINGS_m_ZoneClearance_set, doc=r"""m_ZoneClearance : int""")
    m_ZoneMinThickness = property(_pcbnew.ZONE_SETTINGS_m_ZoneMinThickness_get, _pcbnew.ZONE_SETTINGS_m_ZoneMinThickness_set, doc=r"""m_ZoneMinThickness : int""")
    m_HatchThickness = property(_pcbnew.ZONE_SETTINGS_m_HatchThickness_get, _pcbnew.ZONE_SETTINGS_m_HatchThickness_set, doc=r"""m_HatchThickness : int""")
    m_HatchGap = property(_pcbnew.ZONE_SETTINGS_m_HatchGap_get, _pcbnew.ZONE_SETTINGS_m_HatchGap_set, doc=r"""m_HatchGap : int""")
    m_HatchOrientation = property(_pcbnew.ZONE_SETTINGS_m_HatchOrientation_get, _pcbnew.ZONE_SETTINGS_m_HatchOrientation_set, doc=r"""m_HatchOrientation : double""")
    m_HatchSmoothingLevel = property(_pcbnew.ZONE_SETTINGS_m_HatchSmoothingLevel_get, _pcbnew.ZONE_SETTINGS_m_HatchSmoothingLevel_set, doc=r"""m_HatchSmoothingLevel : int""")
    m_HatchSmoothingValue = property(_pcbnew.ZONE_SETTINGS_m_HatchSmoothingValue_get, _pcbnew.ZONE_SETTINGS_m_HatchSmoothingValue_set, doc=r"""m_HatchSmoothingValue : double""")
    m_HatchHoleMinArea = property(_pcbnew.ZONE_SETTINGS_m_HatchHoleMinArea_get, _pcbnew.ZONE_SETTINGS_m_HatchHoleMinArea_set, doc=r"""m_HatchHoleMinArea : double""")
    m_HatchBorderAlgorithm = property(_pcbnew.ZONE_SETTINGS_m_HatchBorderAlgorithm_get, _pcbnew.ZONE_SETTINGS_m_HatchBorderAlgorithm_set, doc=r"""m_HatchBorderAlgorithm : int""")
    m_NetcodeSelection = property(_pcbnew.ZONE_SETTINGS_m_NetcodeSelection_get, _pcbnew.ZONE_SETTINGS_m_NetcodeSelection_set, doc=r"""m_NetcodeSelection : int""")
    m_Name = property(_pcbnew.ZONE_SETTINGS_m_Name_get, _pcbnew.ZONE_SETTINGS_m_Name_set, doc=r"""m_Name : wxString""")
    m_Layers = property(_pcbnew.ZONE_SETTINGS_m_Layers_get, _pcbnew.ZONE_SETTINGS_m_Layers_set, doc=r"""m_Layers : LSET""")
    m_ZoneBorderDisplayStyle = property(_pcbnew.ZONE_SETTINGS_m_ZoneBorderDisplayStyle_get, _pcbnew.ZONE_SETTINGS_m_ZoneBorderDisplayStyle_set, doc=r"""m_ZoneBorderDisplayStyle : ZONE_BORDER_DISPLAY_STYLE""")
    m_ThermalReliefGap = property(_pcbnew.ZONE_SETTINGS_m_ThermalReliefGap_get, _pcbnew.ZONE_SETTINGS_m_ThermalReliefGap_set, doc=r"""m_ThermalReliefGap : long""")
    m_ThermalReliefSpokeWidth = property(_pcbnew.ZONE_SETTINGS_m_ThermalReliefSpokeWidth_get, _pcbnew.ZONE_SETTINGS_m_ThermalReliefSpokeWidth_set, doc=r"""m_ThermalReliefSpokeWidth : long""")
    m_Zone_45_Only = property(_pcbnew.ZONE_SETTINGS_m_Zone_45_Only_get, _pcbnew.ZONE_SETTINGS_m_Zone_45_Only_set, doc=r"""m_Zone_45_Only : bool""")
    m_Locked = property(_pcbnew.ZONE_SETTINGS_m_Locked_get, _pcbnew.ZONE_SETTINGS_m_Locked_set, doc=r"""m_Locked : bool""")

    def __init__(self):
        r"""__init__(ZONE_SETTINGS self) -> ZONE_SETTINGS"""
        _pcbnew.ZONE_SETTINGS_swiginit(self, _pcbnew.new_ZONE_SETTINGS())

    def __lshift__(self, aSource: "ZONE") -> "ZONE_SETTINGS &":
        r"""__lshift__(ZONE_SETTINGS self, ZONE aSource) -> ZONE_SETTINGS"""
        return _pcbnew.ZONE_SETTINGS___lshift__(self, aSource)

    def SetupLayersList(self, aList: "wxDataViewListCtrl *", aFrame: "PCB_BASE_FRAME *", aLayers: "LSET", aFpEditorMode: "bool") -> "void":
        r"""SetupLayersList(ZONE_SETTINGS self, wxDataViewListCtrl * aList, PCB_BASE_FRAME * aFrame, LSET aLayers, bool aFpEditorMode)"""
        return _pcbnew.ZONE_SETTINGS_SetupLayersList(self, aList, aFrame, aLayers, aFpEditorMode)

    def ExportSetting(self, aTarget: "ZONE", aFullExport: "bool"=True) -> "void":
        r"""ExportSetting(ZONE_SETTINGS self, ZONE aTarget, bool aFullExport=True)"""
        return _pcbnew.ZONE_SETTINGS_ExportSetting(self, aTarget, aFullExport)

    def SetCornerSmoothingType(self, aType: "int") -> "void":
        r"""SetCornerSmoothingType(ZONE_SETTINGS self, int aType)"""
        return _pcbnew.ZONE_SETTINGS_SetCornerSmoothingType(self, aType)

    def GetCornerSmoothingType(self) -> "int":
        r"""GetCornerSmoothingType(ZONE_SETTINGS self) -> int"""
        return _pcbnew.ZONE_SETTINGS_GetCornerSmoothingType(self)

    def SetCornerRadius(self, aRadius: "int") -> "void":
        r"""SetCornerRadius(ZONE_SETTINGS self, int aRadius)"""
        return _pcbnew.ZONE_SETTINGS_SetCornerRadius(self, aRadius)

    def GetCornerRadius(self) -> "unsigned int":
        r"""GetCornerRadius(ZONE_SETTINGS self) -> unsigned int"""
        return _pcbnew.ZONE_SETTINGS_GetCornerRadius(self)

    def GetPadConnection(self) -> "ZONE_CONNECTION":
        r"""GetPadConnection(ZONE_SETTINGS self) -> ZONE_CONNECTION"""
        return _pcbnew.ZONE_SETTINGS_GetPadConnection(self)

    def SetPadConnection(self, aPadConnection: "ZONE_CONNECTION") -> "void":
        r"""SetPadConnection(ZONE_SETTINGS self, ZONE_CONNECTION aPadConnection)"""
        return _pcbnew.ZONE_SETTINGS_SetPadConnection(self, aPadConnection)

    def GetIsRuleArea(self) -> "bool const":
        r"""GetIsRuleArea(ZONE_SETTINGS self) -> bool const"""
        return _pcbnew.ZONE_SETTINGS_GetIsRuleArea(self)

    def GetDoNotAllowCopperPour(self) -> "bool const":
        r"""GetDoNotAllowCopperPour(ZONE_SETTINGS self) -> bool const"""
        return _pcbnew.ZONE_SETTINGS_GetDoNotAllowCopperPour(self)

    def GetDoNotAllowVias(self) -> "bool const":
        r"""GetDoNotAllowVias(ZONE_SETTINGS self) -> bool const"""
        return _pcbnew.ZONE_SETTINGS_GetDoNotAllowVias(self)

    def GetDoNotAllowTracks(self) -> "bool const":
        r"""GetDoNotAllowTracks(ZONE_SETTINGS self) -> bool const"""
        return _pcbnew.ZONE_SETTINGS_GetDoNotAllowTracks(self)

    def GetDoNotAllowPads(self) -> "bool const":
        r"""GetDoNotAllowPads(ZONE_SETTINGS self) -> bool const"""
        return _pcbnew.ZONE_SETTINGS_GetDoNotAllowPads(self)

    def GetDoNotAllowFootprints(self) -> "bool const":
        r"""GetDoNotAllowFootprints(ZONE_SETTINGS self) -> bool const"""
        return _pcbnew.ZONE_SETTINGS_GetDoNotAllowFootprints(self)

    def SetIsRuleArea(self, aEnable: "bool") -> "void":
        r"""SetIsRuleArea(ZONE_SETTINGS self, bool aEnable)"""
        return _pcbnew.ZONE_SETTINGS_SetIsRuleArea(self, aEnable)

    def SetDoNotAllowCopperPour(self, aEnable: "bool") -> "void":
        r"""SetDoNotAllowCopperPour(ZONE_SETTINGS self, bool aEnable)"""
        return _pcbnew.ZONE_SETTINGS_SetDoNotAllowCopperPour(self, aEnable)

    def SetDoNotAllowVias(self, aEnable: "bool") -> "void":
        r"""SetDoNotAllowVias(ZONE_SETTINGS self, bool aEnable)"""
        return _pcbnew.ZONE_SETTINGS_SetDoNotAllowVias(self, aEnable)

    def SetDoNotAllowTracks(self, aEnable: "bool") -> "void":
        r"""SetDoNotAllowTracks(ZONE_SETTINGS self, bool aEnable)"""
        return _pcbnew.ZONE_SETTINGS_SetDoNotAllowTracks(self, aEnable)

    def SetDoNotAllowPads(self, aEnable: "bool") -> "void":
        r"""SetDoNotAllowPads(ZONE_SETTINGS self, bool aEnable)"""
        return _pcbnew.ZONE_SETTINGS_SetDoNotAllowPads(self, aEnable)

    def SetDoNotAllowFootprints(self, aEnable: "bool") -> "void":
        r"""SetDoNotAllowFootprints(ZONE_SETTINGS self, bool aEnable)"""
        return _pcbnew.ZONE_SETTINGS_SetDoNotAllowFootprints(self, aEnable)

    def GetIslandRemovalMode(self) -> "ISLAND_REMOVAL_MODE const":
        r"""GetIslandRemovalMode(ZONE_SETTINGS self) -> ISLAND_REMOVAL_MODE const"""
        return _pcbnew.ZONE_SETTINGS_GetIslandRemovalMode(self)

    def SetIslandRemovalMode(self, aRemove: "ISLAND_REMOVAL_MODE") -> "void":
        r"""SetIslandRemovalMode(ZONE_SETTINGS self, ISLAND_REMOVAL_MODE aRemove)"""
        return _pcbnew.ZONE_SETTINGS_SetIslandRemovalMode(self, aRemove)

    def GetMinIslandArea(self) -> "long long":
        r"""GetMinIslandArea(ZONE_SETTINGS self) -> long long"""
        return _pcbnew.ZONE_SETTINGS_GetMinIslandArea(self)

    def SetMinIslandArea(self, aArea: "long long") -> "void":
        r"""SetMinIslandArea(ZONE_SETTINGS self, long long aArea)"""
        return _pcbnew.ZONE_SETTINGS_SetMinIslandArea(self, aArea)
    __swig_destroy__ = _pcbnew.delete_ZONE_SETTINGS

# Register ZONE_SETTINGS in _pcbnew:
_pcbnew.ZONE_SETTINGS_swigregister(ZONE_SETTINGS)

SHAPE_T_SEGMENT = _pcbnew.SHAPE_T_SEGMENT

SHAPE_T_RECT = _pcbnew.SHAPE_T_RECT

SHAPE_T_ARC = _pcbnew.SHAPE_T_ARC

SHAPE_T_CIRCLE = _pcbnew.SHAPE_T_CIRCLE

SHAPE_T_POLY = _pcbnew.SHAPE_T_POLY

SHAPE_T_BEZIER = _pcbnew.SHAPE_T_BEZIER

SHAPE_T_LAST = _pcbnew.SHAPE_T_LAST

FILL_T_NO_FILL = _pcbnew.FILL_T_NO_FILL

FILL_T_FILLED_SHAPE = _pcbnew.FILL_T_FILLED_SHAPE

FILL_T_FILLED_WITH_BG_BODYCOLOR = _pcbnew.FILL_T_FILLED_WITH_BG_BODYCOLOR

FILL_T_FILLED_WITH_COLOR = _pcbnew.FILL_T_FILLED_WITH_COLOR

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    mid = property(_pcbnew.ARC_MID_mid_get, _pcbnew.ARC_MID_mid_set, doc=r"""mid : wxPoint""")
    start = property(_pcbnew.ARC_MID_start_get, _pcbnew.ARC_MID_start_set, doc=r"""start : wxPoint""")
    end = property(_pcbnew.ARC_MID_end_get, _pcbnew.ARC_MID_end_set, doc=r"""end : wxPoint""")
    center = property(_pcbnew.ARC_MID_center_get, _pcbnew.ARC_MID_center_set, doc=r"""center : wxPoint""")

    def __init__(self):
        r"""__init__(ARC_MID self) -> ARC_MID"""
        _pcbnew.ARC_MID_swiginit(self, _pcbnew.new_ARC_MID())
    __swig_destroy__ = _pcbnew.delete_ARC_MID

# Register ARC_MID in _pcbnew:
_pcbnew.ARC_MID_swigregister(ARC_MID)

class EDA_SHAPE(object):
    r"""Proxy of C++ EDA_SHAPE 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__ = _pcbnew.delete_EDA_SHAPE

    def SwapShape(self, aImage: "EDA_SHAPE") -> "void":
        r"""SwapShape(EDA_SHAPE self, EDA_SHAPE aImage)"""
        return _pcbnew.EDA_SHAPE_SwapShape(self, aImage)

    def ShowShape(self) -> "wxString":
        r"""ShowShape(EDA_SHAPE self) -> wxString"""
        return _pcbnew.EDA_SHAPE_ShowShape(self)

    def SHAPE_T_asString(self) -> "wxString":
        r"""SHAPE_T_asString(EDA_SHAPE self) -> wxString"""
        return _pcbnew.EDA_SHAPE_SHAPE_T_asString(self)

    def SetFillMode(self, aFill: "FILL_T") -> "void":
        r"""SetFillMode(EDA_SHAPE self, FILL_T aFill)"""
        return _pcbnew.EDA_SHAPE_SetFillMode(self, aFill)

    def GetFillType(self) -> "FILL_T":
        r"""GetFillType(EDA_SHAPE self) -> FILL_T"""
        return _pcbnew.EDA_SHAPE_GetFillType(self)

    def IsFilled(self) -> "bool":
        r"""IsFilled(EDA_SHAPE self) -> bool"""
        return _pcbnew.EDA_SHAPE_IsFilled(self)

    def SetFilled(self, aFlag: "bool") -> "void":
        r"""SetFilled(EDA_SHAPE self, bool aFlag)"""
        return _pcbnew.EDA_SHAPE_SetFilled(self, aFlag)

    def SetWidth(self, aWidth: "int") -> "void":
        r"""SetWidth(EDA_SHAPE self, int aWidth)"""
        return _pcbnew.EDA_SHAPE_SetWidth(self, aWidth)

    def GetWidth(self) -> "int":
        r"""GetWidth(EDA_SHAPE self) -> int"""
        return _pcbnew.EDA_SHAPE_GetWidth(self)

    def SetShape(self, aShape: "SHAPE_T") -> "void":
        r"""SetShape(EDA_SHAPE self, SHAPE_T aShape)"""
        return _pcbnew.EDA_SHAPE_SetShape(self, aShape)

    def GetShape(self) -> "SHAPE_T":
        r"""GetShape(EDA_SHAPE self) -> SHAPE_T"""
        return _pcbnew.EDA_SHAPE_GetShape(self)

    def GetStart(self) -> "wxPoint const &":
        r"""GetStart(EDA_SHAPE self) -> wxPoint"""
        return _pcbnew.EDA_SHAPE_GetStart(self)

    def GetStartY(self) -> "int":
        r"""GetStartY(EDA_SHAPE self) -> int"""
        return _pcbnew.EDA_SHAPE_GetStartY(self)

    def GetStartX(self) -> "int":
        r"""GetStartX(EDA_SHAPE self) -> int"""
        return _pcbnew.EDA_SHAPE_GetStartX(self)

    def SetStart(self, aStart: "wxPoint") -> "void":
        r"""SetStart(EDA_SHAPE self, wxPoint aStart)"""
        return _pcbnew.EDA_SHAPE_SetStart(self, aStart)

    def SetStartY(self, y: "int") -> "void":
        r"""SetStartY(EDA_SHAPE self, int y)"""
        return _pcbnew.EDA_SHAPE_SetStartY(self, y)

    def SetStartX(self, x: "int") -> "void":
        r"""SetStartX(EDA_SHAPE self, int x)"""
        return _pcbnew.EDA_SHAPE_SetStartX(self, x)

    def GetEnd(self) -> "wxPoint const &":
        r"""GetEnd(EDA_SHAPE self) -> wxPoint"""
        return _pcbnew.EDA_SHAPE_GetEnd(self)

    def GetEndY(self) -> "int":
        r"""GetEndY(EDA_SHAPE self) -> int"""
        return _pcbnew.EDA_SHAPE_GetEndY(self)

    def GetEndX(self) -> "int":
        r"""GetEndX(EDA_SHAPE self) -> int"""
        return _pcbnew.EDA_SHAPE_GetEndX(self)

    def SetEnd(self, aEnd: "wxPoint") -> "void":
        r"""SetEnd(EDA_SHAPE self, wxPoint aEnd)"""
        return _pcbnew.EDA_SHAPE_SetEnd(self, aEnd)

    def SetEndY(self, y: "int") -> "void":
        r"""SetEndY(EDA_SHAPE self, int y)"""
        return _pcbnew.EDA_SHAPE_SetEndY(self, y)

    def SetEndX(self, x: "int") -> "void":
        r"""SetEndX(EDA_SHAPE self, int x)"""
        return _pcbnew.EDA_SHAPE_SetEndX(self, x)

    def SetBezierC1(self, aPt: "wxPoint") -> "void":
        r"""SetBezierC1(EDA_SHAPE self, wxPoint aPt)"""
        return _pcbnew.EDA_SHAPE_SetBezierC1(self, aPt)

    def GetBezierC1(self) -> "wxPoint const &":
        r"""GetBezierC1(EDA_SHAPE self) -> wxPoint"""
        return _pcbnew.EDA_SHAPE_GetBezierC1(self)

    def SetBezierC2(self, aPt: "wxPoint") -> "void":
        r"""SetBezierC2(EDA_SHAPE self, wxPoint aPt)"""
        return _pcbnew.EDA_SHAPE_SetBezierC2(self, aPt)

    def GetBezierC2(self) -> "wxPoint const &":
        r"""GetBezierC2(EDA_SHAPE self) -> wxPoint"""
        return _pcbnew.EDA_SHAPE_GetBezierC2(self)

    def SetCenter(self, aCenter: "wxPoint") -> "void":
        r"""SetCenter(EDA_SHAPE self, wxPoint aCenter)"""
        return _pcbnew.EDA_SHAPE_SetCenter(self, aCenter)

    def SetArcAngleAndEnd(self, aAngle: "double", aCheckNegativeAngle: "bool"=False) -> "void":
        r"""SetArcAngleAndEnd(EDA_SHAPE self, double aAngle, bool aCheckNegativeAngle=False)"""
        return _pcbnew.EDA_SHAPE_SetArcAngleAndEnd(self, aAngle, aCheckNegativeAngle)

    def GetArcAngle(self) -> "double":
        r"""GetArcAngle(EDA_SHAPE self) -> double"""
        return _pcbnew.EDA_SHAPE_GetArcAngle(self)

    def EndsSwapped(self) -> "bool":
        r"""EndsSwapped(EDA_SHAPE self) -> bool"""
        return _pcbnew.EDA_SHAPE_EndsSwapped(self)

    def GetArcMid(self) -> "wxPoint":
        r"""GetArcMid(EDA_SHAPE self) -> wxPoint"""
        return _pcbnew.EDA_SHAPE_GetArcMid(self)

    def GetRectCorners(self) -> "std::vector< wxPoint,std::allocator< wxPoint > >":
        r"""GetRectCorners(EDA_SHAPE self) -> wxPoint_Vector"""
        return _pcbnew.EDA_SHAPE_GetRectCorners(self)

    def CalcArcAngles(self, aStartAngle: "double &", aEndAngle: "double &") -> "void":
        r"""CalcArcAngles(EDA_SHAPE self, double & aStartAngle, double & aEndAngle)"""
        return _pcbnew.EDA_SHAPE_CalcArcAngles(self, aStartAngle, aEndAngle)

    def GetRadius(self) -> "int":
        r"""GetRadius(EDA_SHAPE self) -> int"""
        return _pcbnew.EDA_SHAPE_GetRadius(self)

    def SetArcGeometry(self, aStart: "wxPoint", aMid: "wxPoint", aEnd: "wxPoint") -> "void":
        r"""SetArcGeometry(EDA_SHAPE self, wxPoint aStart, wxPoint aMid, wxPoint aEnd)"""
        return _pcbnew.EDA_SHAPE_SetArcGeometry(self, aStart, aMid, aEnd)

    def SetCachedArcData(self, aStart: "wxPoint", aMid: "wxPoint", aEnd: "wxPoint", aCenter: "wxPoint") -> "void":
        r"""SetCachedArcData(EDA_SHAPE self, wxPoint aStart, wxPoint aMid, wxPoint aEnd, wxPoint aCenter)"""
        return _pcbnew.EDA_SHAPE_SetCachedArcData(self, aStart, aMid, aEnd, aCenter)

    def GetBezierPoints(self) -> "std::vector< wxPoint,std::allocator< wxPoint > > const &":
        r"""GetBezierPoints(EDA_SHAPE self) -> wxPoint_Vector"""
        return _pcbnew.EDA_SHAPE_GetBezierPoints(self)

    def DupPolyPointsList(self, aBuffer: "wxPoint_Vector") -> "void":
        r"""DupPolyPointsList(EDA_SHAPE self, wxPoint_Vector aBuffer)"""
        return _pcbnew.EDA_SHAPE_DupPolyPointsList(self, aBuffer)

    def GetPointCount(self) -> "int":
        r"""GetPointCount(EDA_SHAPE self) -> int"""
        return _pcbnew.EDA_SHAPE_GetPointCount(self)

    def GetPolyShape(self, *args) -> "SHAPE_POLY_SET const &":
        r"""
        GetPolyShape(EDA_SHAPE self) -> SHAPE_POLY_SET
        GetPolyShape(EDA_SHAPE self) -> SHAPE_POLY_SET
        """
        return _pcbnew.EDA_SHAPE_GetPolyShape(self, *args)

    def IsPolyShapeValid(self) -> "bool":
        r"""IsPolyShapeValid(EDA_SHAPE self) -> bool"""
        return _pcbnew.EDA_SHAPE_IsPolyShapeValid(self)

    def SetPolyShape(self, aShape: "SHAPE_POLY_SET") -> "void":
        r"""SetPolyShape(EDA_SHAPE self, SHAPE_POLY_SET aShape)"""
        return _pcbnew.EDA_SHAPE_SetPolyShape(self, aShape)

    def SetPolyPoints(self, aPoints: "wxPoint_Vector") -> "void":
        r"""SetPolyPoints(EDA_SHAPE self, wxPoint_Vector aPoints)"""
        return _pcbnew.EDA_SHAPE_SetPolyPoints(self, aPoints)

    def RebuildBezierToSegmentsPointsList(self, aMinSegLen: "int") -> "void":
        r"""RebuildBezierToSegmentsPointsList(EDA_SHAPE self, int aMinSegLen)"""
        return _pcbnew.EDA_SHAPE_RebuildBezierToSegmentsPointsList(self, aMinSegLen)

    def MakeEffectiveShapes(self) -> "std::vector< SHAPE *,std::allocator< SHAPE * > >":
        r"""MakeEffectiveShapes(EDA_SHAPE self) -> std::vector< SHAPE *,std::allocator< SHAPE * > >"""
        return _pcbnew.EDA_SHAPE_MakeEffectiveShapes(self)

    def ShapeGetMsgPanelInfo(self, aFrame: "EDA_DRAW_FRAME *", aList: "std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > &") -> "void":
        r"""ShapeGetMsgPanelInfo(EDA_SHAPE self, EDA_DRAW_FRAME * aFrame, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.EDA_SHAPE_ShapeGetMsgPanelInfo(self, aFrame, aList)

    def GetLength(self) -> "double":
        r"""GetLength(EDA_SHAPE self) -> double"""
        return _pcbnew.EDA_SHAPE_GetLength(self)

    def TransformShapeWithClearanceToPolygon(self, aCornerBuffer: "SHAPE_POLY_SET", aClearanceValue: "int", aError: "int", aErrorLoc: "ERROR_LOC", ignoreLineWidth: "bool") -> "void":
        r"""TransformShapeWithClearanceToPolygon(EDA_SHAPE self, SHAPE_POLY_SET aCornerBuffer, int aClearanceValue, int aError, ERROR_LOC aErrorLoc, bool ignoreLineWidth)"""
        return _pcbnew.EDA_SHAPE_TransformShapeWithClearanceToPolygon(self, aCornerBuffer, aClearanceValue, aError, aErrorLoc, ignoreLineWidth)

    def Compare(self, aOther: "EDA_SHAPE") -> "int":
        r"""Compare(EDA_SHAPE self, EDA_SHAPE aOther) -> int"""
        return _pcbnew.EDA_SHAPE_Compare(self, aOther)

# Register EDA_SHAPE in _pcbnew:
_pcbnew.EDA_SHAPE_swigregister(EDA_SHAPE)

class PCB_SHAPE(BOARD_ITEM, EDA_SHAPE):
    r"""Proxy of C++ PCB_SHAPE 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__(PCB_SHAPE self, BOARD_ITEM aParent, KICAD_T idtype, SHAPE_T shapetype) -> PCB_SHAPE
        __init__(PCB_SHAPE self, BOARD_ITEM aParent=None, SHAPE_T shapetype=SEGMENT) -> PCB_SHAPE
        """
        _pcbnew.PCB_SHAPE_swiginit(self, _pcbnew.new_PCB_SHAPE(*args))
    __swig_destroy__ = _pcbnew.delete_PCB_SHAPE

    @staticmethod
    def ClassOf(aItem: "EDA_ITEM") -> "bool":
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.PCB_SHAPE_ClassOf(aItem)

    def GetClass(self) -> "wxString":
        r"""GetClass(PCB_SHAPE self) -> wxString"""
        return _pcbnew.PCB_SHAPE_GetClass(self)

    def IsType(self, aScanTypes: "KICAD_T const []") -> "bool":
        r"""IsType(PCB_SHAPE self, KICAD_T const [] aScanTypes) -> bool"""
        return _pcbnew.PCB_SHAPE_IsType(self, aScanTypes)

    def SetPosition(self, aPos: "wxPoint") -> "void":
        r"""SetPosition(PCB_SHAPE self, wxPoint aPos)"""
        return _pcbnew.PCB_SHAPE_SetPosition(self, aPos)

    def GetPosition(self) -> "wxPoint":
        r"""GetPosition(PCB_SHAPE self) -> wxPoint"""
        return _pcbnew.PCB_SHAPE_GetPosition(self)

    def GetCenter(self) -> "wxPoint":
        r"""GetCenter(PCB_SHAPE self) -> wxPoint"""
        return _pcbnew.PCB_SHAPE_GetCenter(self)

    def GetFocusPosition(self) -> "wxPoint const":
        r"""GetFocusPosition(PCB_SHAPE self) -> wxPoint"""
        return _pcbnew.PCB_SHAPE_GetFocusPosition(self)

    def GetParentFootprint(self) -> "FOOTPRINT *":
        r"""GetParentFootprint(PCB_SHAPE self) -> FOOTPRINT"""
        return _pcbnew.PCB_SHAPE_GetParentFootprint(self)

    def GetEffectiveShape(self, *args) -> "std::shared_ptr< SHAPE >":
        r"""GetEffectiveShape(PCB_SHAPE self, PCB_LAYER_ID aLayer=UNDEFINED_LAYER, FLASHING aFlash=DEFAULT) -> std::shared_ptr< SHAPE >"""
        return _pcbnew.PCB_SHAPE_GetEffectiveShape(self, *args)

    def GetMsgPanelInfo(self, aFrame: "EDA_DRAW_FRAME *", aList: "std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > &") -> "void":
        r"""GetMsgPanelInfo(PCB_SHAPE self, EDA_DRAW_FRAME * aFrame, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.PCB_SHAPE_GetMsgPanelInfo(self, aFrame, aList)

    def GetBoundingBox(self) -> "EDA_RECT const":
        r"""GetBoundingBox(PCB_SHAPE self) -> EDA_RECT"""
        return _pcbnew.PCB_SHAPE_GetBoundingBox(self)

    def HitTest(self, *args) -> "bool":
        r"""
        HitTest(PCB_SHAPE self, wxPoint aPosition, int aAccuracy=0) -> bool
        HitTest(PCB_SHAPE self, EDA_RECT aRect, bool aContained, int aAccuracy=0) -> bool
        """
        return _pcbnew.PCB_SHAPE_HitTest(self, *args)

    def Move(self, aMoveVector: "wxPoint") -> "void":
        r"""Move(PCB_SHAPE self, wxPoint aMoveVector)"""
        return _pcbnew.PCB_SHAPE_Move(self, aMoveVector)

    def Rotate(self, aRotCentre: "wxPoint", aAngle: "double") -> "void":
        r"""Rotate(PCB_SHAPE self, wxPoint aRotCentre, double aAngle)"""
        return _pcbnew.PCB_SHAPE_Rotate(self, aRotCentre, aAngle)

    def Flip(self, aCentre: "wxPoint", aFlipLeftRight: "bool") -> "void":
        r"""Flip(PCB_SHAPE self, wxPoint aCentre, bool aFlipLeftRight)"""
        return _pcbnew.PCB_SHAPE_Flip(self, aCentre, aFlipLeftRight)

    def Scale(self, aScale: "double") -> "void":
        r"""Scale(PCB_SHAPE self, double aScale)"""
        return _pcbnew.PCB_SHAPE_Scale(self, aScale)

    def TransformShapeWithClearanceToPolygon(self, aCornerBuffer: "SHAPE_POLY_SET", aLayer: "PCB_LAYER_ID", aClearanceValue: "int", aError: "int", aErrorLoc: "ERROR_LOC", ignoreLineWidth: "bool"=False) -> "void":
        r"""TransformShapeWithClearanceToPolygon(PCB_SHAPE self, SHAPE_POLY_SET aCornerBuffer, PCB_LAYER_ID aLayer, int aClearanceValue, int aError, ERROR_LOC aErrorLoc, bool ignoreLineWidth=False)"""
        return _pcbnew.PCB_SHAPE_TransformShapeWithClearanceToPolygon(self, aCornerBuffer, aLayer, aClearanceValue, aError, aErrorLoc, ignoreLineWidth)

    def GetSelectMenuText(self, aUnits: "EDA_UNITS") -> "wxString":
        r"""GetSelectMenuText(PCB_SHAPE self, EDA_UNITS aUnits) -> wxString"""
        return _pcbnew.PCB_SHAPE_GetSelectMenuText(self, aUnits)

    def GetMenuImage(self) -> "BITMAPS":
        r"""GetMenuImage(PCB_SHAPE self) -> BITMAPS"""
        return _pcbnew.PCB_SHAPE_GetMenuImage(self)

    def Clone(self) -> "EDA_ITEM *":
        r"""Clone(PCB_SHAPE self) -> EDA_ITEM"""
        return _pcbnew.PCB_SHAPE_Clone(self)

    def ViewBBox(self) -> "BOX2I const":
        r"""ViewBBox(PCB_SHAPE self) -> BOX2I const"""
        return _pcbnew.PCB_SHAPE_ViewBBox(self)

    def SwapData(self, aImage: "BOARD_ITEM") -> "void":
        r"""SwapData(PCB_SHAPE self, BOARD_ITEM aImage)"""
        return _pcbnew.PCB_SHAPE_SwapData(self, aImage)

    def GetArcAngleStart(self) -> "double":
        r"""GetArcAngleStart(PCB_SHAPE self) -> double"""
        return _pcbnew.PCB_SHAPE_GetArcAngleStart(self)

    def GetShapeStr(self):
        return self.ShowShape(self.GetShape())


# Register PCB_SHAPE in _pcbnew:
_pcbnew.PCB_SHAPE_swigregister(PCB_SHAPE)

def PCB_SHAPE_ClassOf(aItem: "EDA_ITEM") -> "bool":
    r"""PCB_SHAPE_ClassOf(EDA_ITEM aItem) -> bool"""
    return _pcbnew.PCB_SHAPE_ClassOf(aItem)

class PCB_TEXT(BOARD_ITEM, EDA_TEXT):
    r"""Proxy of C++ PCB_TEXT 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, parent: "BOARD_ITEM"):
        r"""__init__(PCB_TEXT self, BOARD_ITEM parent) -> PCB_TEXT"""
        _pcbnew.PCB_TEXT_swiginit(self, _pcbnew.new_PCB_TEXT(parent))
    __swig_destroy__ = _pcbnew.delete_PCB_TEXT

    @staticmethod
    def ClassOf(aItem: "EDA_ITEM") -> "bool":
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.PCB_TEXT_ClassOf(aItem)

    def IsType(self, aScanTypes: "KICAD_T const []") -> "bool":
        r"""IsType(PCB_TEXT self, KICAD_T const [] aScanTypes) -> bool"""
        return _pcbnew.PCB_TEXT_IsType(self, aScanTypes)

    def GetShownText(self, aDepth: "int"=0) -> "wxString":
        r"""GetShownText(PCB_TEXT self, int aDepth=0) -> wxString"""
        return _pcbnew.PCB_TEXT_GetShownText(self, aDepth)

    def SetVisible(self, aVisible: "bool") -> "void":
        r"""SetVisible(PCB_TEXT self, bool aVisible)"""
        return _pcbnew.PCB_TEXT_SetVisible(self, aVisible)

    def IsVisible(self) -> "bool":
        r"""IsVisible(PCB_TEXT self) -> bool"""
        return _pcbnew.PCB_TEXT_IsVisible(self)

    def Matches(self, aSearchData: "wxFindReplaceData const &", aAuxData: "void *") -> "bool":
        r"""Matches(PCB_TEXT self, wxFindReplaceData const & aSearchData, void * aAuxData) -> bool"""
        return _pcbnew.PCB_TEXT_Matches(self, aSearchData, aAuxData)

    def GetPosition(self) -> "wxPoint":
        r"""GetPosition(PCB_TEXT self) -> wxPoint"""
        return _pcbnew.PCB_TEXT_GetPosition(self)

    def SetPosition(self, aPos: "wxPoint") -> "void":
        r"""SetPosition(PCB_TEXT self, wxPoint aPos)"""
        return _pcbnew.PCB_TEXT_SetPosition(self, aPos)

    def Move(self, aMoveVector: "wxPoint") -> "void":
        r"""Move(PCB_TEXT self, wxPoint aMoveVector)"""
        return _pcbnew.PCB_TEXT_Move(self, aMoveVector)

    def SetTextAngle(self, aAngle: "double") -> "void":
        r"""SetTextAngle(PCB_TEXT self, double aAngle)"""
        return _pcbnew.PCB_TEXT_SetTextAngle(self, aAngle)

    def Rotate(self, aRotCentre: "wxPoint", aAngle: "double") -> "void":
        r"""Rotate(PCB_TEXT self, wxPoint aRotCentre, double aAngle)"""
        return _pcbnew.PCB_TEXT_Rotate(self, aRotCentre, aAngle)

    def Flip(self, aCentre: "wxPoint", aFlipLeftRight: "bool") -> "void":
        r"""Flip(PCB_TEXT self, wxPoint aCentre, bool aFlipLeftRight)"""
        return _pcbnew.PCB_TEXT_Flip(self, aCentre, aFlipLeftRight)

    def GetMsgPanelInfo(self, aFrame: "EDA_DRAW_FRAME *", aList: "std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > &") -> "void":
        r"""GetMsgPanelInfo(PCB_TEXT self, EDA_DRAW_FRAME * aFrame, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.PCB_TEXT_GetMsgPanelInfo(self, aFrame, aList)

    def TextHitTest(self, *args) -> "bool":
        r"""
        TextHitTest(PCB_TEXT self, wxPoint aPoint, int aAccuracy=0) -> bool
        TextHitTest(PCB_TEXT self, EDA_RECT aRect, bool aContains, int aAccuracy=0) -> bool
        """
        return _pcbnew.PCB_TEXT_TextHitTest(self, *args)

    def HitTest(self, *args) -> "bool":
        r"""
        HitTest(PCB_TEXT self, wxPoint aPosition, int aAccuracy) -> bool
        HitTest(PCB_TEXT self, EDA_RECT aRect, bool aContained, int aAccuracy=0) -> bool
        """
        return _pcbnew.PCB_TEXT_HitTest(self, *args)

    def GetClass(self) -> "wxString":
        r"""GetClass(PCB_TEXT self) -> wxString"""
        return _pcbnew.PCB_TEXT_GetClass(self)

    def TransformTextShapeWithClearanceToPolygon(self, aCornerBuffer: "SHAPE_POLY_SET", aLayer: "PCB_LAYER_ID", aClearanceValue: "int", aError: "int", aErrorLoc: "ERROR_LOC") -> "void":
        r"""TransformTextShapeWithClearanceToPolygon(PCB_TEXT self, SHAPE_POLY_SET aCornerBuffer, PCB_LAYER_ID aLayer, int aClearanceValue, int aError, ERROR_LOC aErrorLoc)"""
        return _pcbnew.PCB_TEXT_TransformTextShapeWithClearanceToPolygon(self, aCornerBuffer, aLayer, aClearanceValue, aError, aErrorLoc)

    def TransformShapeWithClearanceToPolygon(self, aCornerBuffer: "SHAPE_POLY_SET", aLayer: "PCB_LAYER_ID", aClearanceValue: "int", aError: "int", aErrorLoc: "ERROR_LOC", aIgnoreLineWidth: "bool"=False) -> "void":
        r"""TransformShapeWithClearanceToPolygon(PCB_TEXT self, SHAPE_POLY_SET aCornerBuffer, PCB_LAYER_ID aLayer, int aClearanceValue, int aError, ERROR_LOC aErrorLoc, bool aIgnoreLineWidth=False)"""
        return _pcbnew.PCB_TEXT_TransformShapeWithClearanceToPolygon(self, aCornerBuffer, aLayer, aClearanceValue, aError, aErrorLoc, aIgnoreLineWidth)

    def GetEffectiveShape(self, *args) -> "std::shared_ptr< SHAPE >":
        r"""GetEffectiveShape(PCB_TEXT self, PCB_LAYER_ID aLayer=UNDEFINED_LAYER, FLASHING aFlash=DEFAULT) -> std::shared_ptr< SHAPE >"""
        return _pcbnew.PCB_TEXT_GetEffectiveShape(self, *args)

    def GetSelectMenuText(self, aUnits: "EDA_UNITS") -> "wxString":
        r"""GetSelectMenuText(PCB_TEXT self, EDA_UNITS aUnits) -> wxString"""
        return _pcbnew.PCB_TEXT_GetSelectMenuText(self, aUnits)

    def GetMenuImage(self) -> "BITMAPS":
        r"""GetMenuImage(PCB_TEXT self) -> BITMAPS"""
        return _pcbnew.PCB_TEXT_GetMenuImage(self)

    def GetBoundingBox(self) -> "EDA_RECT const":
        r"""GetBoundingBox(PCB_TEXT self) -> EDA_RECT"""
        return _pcbnew.PCB_TEXT_GetBoundingBox(self)

    def Clone(self) -> "EDA_ITEM *":
        r"""Clone(PCB_TEXT self) -> EDA_ITEM"""
        return _pcbnew.PCB_TEXT_Clone(self)

    def SwapData(self, aImage: "BOARD_ITEM") -> "void":
        r"""SwapData(PCB_TEXT self, BOARD_ITEM aImage)"""
        return _pcbnew.PCB_TEXT_SwapData(self, aImage)

# Register PCB_TEXT in _pcbnew:
_pcbnew.PCB_TEXT_swigregister(PCB_TEXT)
S_SEGMENT = cvar.S_SEGMENT
S_RECT = cvar.S_RECT
S_ARC = cvar.S_ARC
S_CIRCLE = cvar.S_CIRCLE
S_POLYGON = cvar.S_POLYGON
S_CURVE = cvar.S_CURVE

def PCB_TEXT_ClassOf(aItem: "EDA_ITEM") -> "bool":
    r"""PCB_TEXT_ClassOf(EDA_ITEM aItem) -> bool"""
    return _pcbnew.PCB_TEXT_ClassOf(aItem)

DIM_UNITS_FORMAT_NO_SUFFIX = _pcbnew.DIM_UNITS_FORMAT_NO_SUFFIX

DIM_UNITS_FORMAT_BARE_SUFFIX = _pcbnew.DIM_UNITS_FORMAT_BARE_SUFFIX

DIM_UNITS_FORMAT_PAREN_SUFFIX = _pcbnew.DIM_UNITS_FORMAT_PAREN_SUFFIX

DIM_TEXT_POSITION_OUTSIDE = _pcbnew.DIM_TEXT_POSITION_OUTSIDE

DIM_TEXT_POSITION_INLINE = _pcbnew.DIM_TEXT_POSITION_INLINE

DIM_TEXT_POSITION_MANUAL = _pcbnew.DIM_TEXT_POSITION_MANUAL

DIM_UNITS_MODE_INCHES = _pcbnew.DIM_UNITS_MODE_INCHES

DIM_UNITS_MODE_MILS = _pcbnew.DIM_UNITS_MODE_MILS

DIM_UNITS_MODE_MILLIMETRES = _pcbnew.DIM_UNITS_MODE_MILLIMETRES

DIM_UNITS_MODE_AUTOMATIC = _pcbnew.DIM_UNITS_MODE_AUTOMATIC

DIM_TEXT_FRAME_NONE = _pcbnew.DIM_TEXT_FRAME_NONE

DIM_TEXT_FRAME_RECTANGLE = _pcbnew.DIM_TEXT_FRAME_RECTANGLE

DIM_TEXT_FRAME_CIRCLE = _pcbnew.DIM_TEXT_FRAME_CIRCLE

DIM_TEXT_FRAME_ROUNDRECT = _pcbnew.DIM_TEXT_FRAME_ROUNDRECT

class PCB_DIMENSION_BASE(BOARD_ITEM):
    r"""Proxy of C++ PCB_DIMENSION_BASE 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 IsType(self, aScanTypes: "KICAD_T const []") -> "bool":
        r"""IsType(PCB_DIMENSION_BASE self, KICAD_T const [] aScanTypes) -> bool"""
        return _pcbnew.PCB_DIMENSION_BASE_IsType(self, aScanTypes)

    def SetParent(self, aParent: "EDA_ITEM") -> "void":
        r"""SetParent(PCB_DIMENSION_BASE self, EDA_ITEM aParent)"""
        return _pcbnew.PCB_DIMENSION_BASE_SetParent(self, aParent)

    def GetStart(self) -> "wxPoint const &":
        r"""GetStart(PCB_DIMENSION_BASE self) -> wxPoint"""
        return _pcbnew.PCB_DIMENSION_BASE_GetStart(self)

    def SetStart(self, aPoint: "wxPoint") -> "void":
        r"""SetStart(PCB_DIMENSION_BASE self, wxPoint aPoint)"""
        return _pcbnew.PCB_DIMENSION_BASE_SetStart(self, aPoint)

    def GetEnd(self) -> "wxPoint const &":
        r"""GetEnd(PCB_DIMENSION_BASE self) -> wxPoint"""
        return _pcbnew.PCB_DIMENSION_BASE_GetEnd(self)

    def SetEnd(self, aPoint: "wxPoint") -> "void":
        r"""SetEnd(PCB_DIMENSION_BASE self, wxPoint aPoint)"""
        return _pcbnew.PCB_DIMENSION_BASE_SetEnd(self, aPoint)

    def GetPosition(self) -> "wxPoint":
        r"""GetPosition(PCB_DIMENSION_BASE self) -> wxPoint"""
        return _pcbnew.PCB_DIMENSION_BASE_GetPosition(self)

    def SetPosition(self, aPos: "wxPoint") -> "void":
        r"""SetPosition(PCB_DIMENSION_BASE self, wxPoint aPos)"""
        return _pcbnew.PCB_DIMENSION_BASE_SetPosition(self, aPos)

    def GetOverrideTextEnabled(self) -> "bool":
        r"""GetOverrideTextEnabled(PCB_DIMENSION_BASE self) -> bool"""
        return _pcbnew.PCB_DIMENSION_BASE_GetOverrideTextEnabled(self)

    def SetOverrideTextEnabled(self, aOverride: "bool") -> "void":
        r"""SetOverrideTextEnabled(PCB_DIMENSION_BASE self, bool aOverride)"""
        return _pcbnew.PCB_DIMENSION_BASE_SetOverrideTextEnabled(self, aOverride)

    def GetOverrideText(self) -> "wxString":
        r"""GetOverrideText(PCB_DIMENSION_BASE self) -> wxString"""
        return _pcbnew.PCB_DIMENSION_BASE_GetOverrideText(self)

    def SetOverrideText(self, aValue: "wxString") -> "void":
        r"""SetOverrideText(PCB_DIMENSION_BASE self, wxString aValue)"""
        return _pcbnew.PCB_DIMENSION_BASE_SetOverrideText(self, aValue)

    def GetMeasuredValue(self) -> "int":
        r"""GetMeasuredValue(PCB_DIMENSION_BASE self) -> int"""
        return _pcbnew.PCB_DIMENSION_BASE_GetMeasuredValue(self)

    def SetMeasuredValue(self, aValue: "int") -> "void":
        r"""SetMeasuredValue(PCB_DIMENSION_BASE self, int aValue)"""
        return _pcbnew.PCB_DIMENSION_BASE_SetMeasuredValue(self, aValue)

    def GetValueText(self) -> "wxString":
        r"""GetValueText(PCB_DIMENSION_BASE self) -> wxString"""
        return _pcbnew.PCB_DIMENSION_BASE_GetValueText(self)

    def Update(self) -> "void":
        r"""Update(PCB_DIMENSION_BASE self)"""
        return _pcbnew.PCB_DIMENSION_BASE_Update(self)

    def GetPrefix(self) -> "wxString":
        r"""GetPrefix(PCB_DIMENSION_BASE self) -> wxString"""
        return _pcbnew.PCB_DIMENSION_BASE_GetPrefix(self)

    def SetPrefix(self, aPrefix: "wxString") -> "void":
        r"""SetPrefix(PCB_DIMENSION_BASE self, wxString aPrefix)"""
        return _pcbnew.PCB_DIMENSION_BASE_SetPrefix(self, aPrefix)

    def GetSuffix(self) -> "wxString":
        r"""GetSuffix(PCB_DIMENSION_BASE self) -> wxString"""
        return _pcbnew.PCB_DIMENSION_BASE_GetSuffix(self)

    def SetSuffix(self, aSuffix: "wxString") -> "void":
        r"""SetSuffix(PCB_DIMENSION_BASE self, wxString aSuffix)"""
        return _pcbnew.PCB_DIMENSION_BASE_SetSuffix(self, aSuffix)

    def GetUnits(self, aUnits: "EDA_UNITS &") -> "void":
        r"""GetUnits(PCB_DIMENSION_BASE self, EDA_UNITS & aUnits)"""
        return _pcbnew.PCB_DIMENSION_BASE_GetUnits(self, aUnits)

    def SetUnits(self, aUnits: "EDA_UNITS") -> "void":
        r"""SetUnits(PCB_DIMENSION_BASE self, EDA_UNITS aUnits)"""
        return _pcbnew.PCB_DIMENSION_BASE_SetUnits(self, aUnits)

    def GetUnitsMode(self) -> "DIM_UNITS_MODE":
        r"""GetUnitsMode(PCB_DIMENSION_BASE self) -> DIM_UNITS_MODE"""
        return _pcbnew.PCB_DIMENSION_BASE_GetUnitsMode(self)

    def SetUnitsMode(self, aMode: "DIM_UNITS_MODE") -> "void":
        r"""SetUnitsMode(PCB_DIMENSION_BASE self, DIM_UNITS_MODE aMode)"""
        return _pcbnew.PCB_DIMENSION_BASE_SetUnitsMode(self, aMode)

    def SetAutoUnits(self, aAuto: "bool"=True) -> "void":
        r"""SetAutoUnits(PCB_DIMENSION_BASE self, bool aAuto=True)"""
        return _pcbnew.PCB_DIMENSION_BASE_SetAutoUnits(self, aAuto)

    def GetUnitsFormat(self) -> "DIM_UNITS_FORMAT":
        r"""GetUnitsFormat(PCB_DIMENSION_BASE self) -> DIM_UNITS_FORMAT"""
        return _pcbnew.PCB_DIMENSION_BASE_GetUnitsFormat(self)

    def SetUnitsFormat(self, aFormat: "DIM_UNITS_FORMAT const") -> "void":
        r"""SetUnitsFormat(PCB_DIMENSION_BASE self, DIM_UNITS_FORMAT const aFormat)"""
        return _pcbnew.PCB_DIMENSION_BASE_SetUnitsFormat(self, aFormat)

    def GetPrecision(self) -> "int":
        r"""GetPrecision(PCB_DIMENSION_BASE self) -> int"""
        return _pcbnew.PCB_DIMENSION_BASE_GetPrecision(self)

    def SetPrecision(self, aPrecision: "int") -> "void":
        r"""SetPrecision(PCB_DIMENSION_BASE self, int aPrecision)"""
        return _pcbnew.PCB_DIMENSION_BASE_SetPrecision(self, aPrecision)

    def GetSuppressZeroes(self) -> "bool":
        r"""GetSuppressZeroes(PCB_DIMENSION_BASE self) -> bool"""
        return _pcbnew.PCB_DIMENSION_BASE_GetSuppressZeroes(self)

    def SetSuppressZeroes(self, aSuppress: "bool") -> "void":
        r"""SetSuppressZeroes(PCB_DIMENSION_BASE self, bool aSuppress)"""
        return _pcbnew.PCB_DIMENSION_BASE_SetSuppressZeroes(self, aSuppress)

    def GetKeepTextAligned(self) -> "bool":
        r"""GetKeepTextAligned(PCB_DIMENSION_BASE self) -> bool"""
        return _pcbnew.PCB_DIMENSION_BASE_GetKeepTextAligned(self)

    def SetKeepTextAligned(self, aKeepAligned: "bool") -> "void":
        r"""SetKeepTextAligned(PCB_DIMENSION_BASE self, bool aKeepAligned)"""
        return _pcbnew.PCB_DIMENSION_BASE_SetKeepTextAligned(self, aKeepAligned)

    def SetTextPositionMode(self, aMode: "DIM_TEXT_POSITION") -> "void":
        r"""SetTextPositionMode(PCB_DIMENSION_BASE self, DIM_TEXT_POSITION aMode)"""
        return _pcbnew.PCB_DIMENSION_BASE_SetTextPositionMode(self, aMode)

    def GetTextPositionMode(self) -> "DIM_TEXT_POSITION":
        r"""GetTextPositionMode(PCB_DIMENSION_BASE self) -> DIM_TEXT_POSITION"""
        return _pcbnew.PCB_DIMENSION_BASE_GetTextPositionMode(self)

    def GetArrowLength(self) -> "int":
        r"""GetArrowLength(PCB_DIMENSION_BASE self) -> int"""
        return _pcbnew.PCB_DIMENSION_BASE_GetArrowLength(self)

    def SetArrowLength(self, aLength: "int") -> "void":
        r"""SetArrowLength(PCB_DIMENSION_BASE self, int aLength)"""
        return _pcbnew.PCB_DIMENSION_BASE_SetArrowLength(self, aLength)

    def SetExtensionOffset(self, aOffset: "int") -> "void":
        r"""SetExtensionOffset(PCB_DIMENSION_BASE self, int aOffset)"""
        return _pcbnew.PCB_DIMENSION_BASE_SetExtensionOffset(self, aOffset)

    def GetExtensionOffset(self) -> "int":
        r"""GetExtensionOffset(PCB_DIMENSION_BASE self) -> int"""
        return _pcbnew.PCB_DIMENSION_BASE_GetExtensionOffset(self)

    def GetLineThickness(self) -> "int":
        r"""GetLineThickness(PCB_DIMENSION_BASE self) -> int"""
        return _pcbnew.PCB_DIMENSION_BASE_GetLineThickness(self)

    def SetLineThickness(self, aWidth: "int") -> "void":
        r"""SetLineThickness(PCB_DIMENSION_BASE self, int aWidth)"""
        return _pcbnew.PCB_DIMENSION_BASE_SetLineThickness(self, aWidth)

    def SetLayer(self, aLayer: "PCB_LAYER_ID") -> "void":
        r"""SetLayer(PCB_DIMENSION_BASE self, PCB_LAYER_ID aLayer)"""
        return _pcbnew.PCB_DIMENSION_BASE_SetLayer(self, aLayer)

    def SetTextSize(self, aTextSize: "wxSize") -> "void":
        r"""SetTextSize(PCB_DIMENSION_BASE self, wxSize aTextSize)"""
        return _pcbnew.PCB_DIMENSION_BASE_SetTextSize(self, aTextSize)

    def SetText(self, aNewText: "wxString") -> "void":
        r"""SetText(PCB_DIMENSION_BASE self, wxString aNewText)"""
        return _pcbnew.PCB_DIMENSION_BASE_SetText(self, aNewText)

    def GetText(self) -> "wxString const":
        r"""GetText(PCB_DIMENSION_BASE self) -> wxString"""
        return _pcbnew.PCB_DIMENSION_BASE_GetText(self)

    def Text(self, *args) -> "PCB_TEXT const &":
        r"""
        Text(PCB_DIMENSION_BASE self) -> PCB_TEXT
        Text(PCB_DIMENSION_BASE self) -> PCB_TEXT
        """
        return _pcbnew.PCB_DIMENSION_BASE_Text(self, *args)

    def GetShapes(self) -> "std::vector< std::shared_ptr< SHAPE >,std::allocator< std::shared_ptr< SHAPE > > > const &":
        r"""GetShapes(PCB_DIMENSION_BASE self) -> std::vector< std::shared_ptr< SHAPE >,std::allocator< std::shared_ptr< SHAPE > > > const &"""
        return _pcbnew.PCB_DIMENSION_BASE_GetShapes(self)

    def Move(self, offset: "wxPoint") -> "void":
        r"""Move(PCB_DIMENSION_BASE self, wxPoint offset)"""
        return _pcbnew.PCB_DIMENSION_BASE_Move(self, offset)

    def Rotate(self, aRotCentre: "wxPoint", aAngle: "double") -> "void":
        r"""Rotate(PCB_DIMENSION_BASE self, wxPoint aRotCentre, double aAngle)"""
        return _pcbnew.PCB_DIMENSION_BASE_Rotate(self, aRotCentre, aAngle)

    def Flip(self, aCentre: "wxPoint", aFlipLeftRight: "bool") -> "void":
        r"""Flip(PCB_DIMENSION_BASE self, wxPoint aCentre, bool aFlipLeftRight)"""
        return _pcbnew.PCB_DIMENSION_BASE_Flip(self, aCentre, aFlipLeftRight)

    def Mirror(self, axis_pos: "wxPoint", aMirrorLeftRight: "bool"=False) -> "void":
        r"""Mirror(PCB_DIMENSION_BASE self, wxPoint axis_pos, bool aMirrorLeftRight=False)"""
        return _pcbnew.PCB_DIMENSION_BASE_Mirror(self, axis_pos, aMirrorLeftRight)

    def GetMsgPanelInfo(self, aFrame: "EDA_DRAW_FRAME *", aList: "std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > &") -> "void":
        r"""GetMsgPanelInfo(PCB_DIMENSION_BASE self, EDA_DRAW_FRAME * aFrame, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.PCB_DIMENSION_BASE_GetMsgPanelInfo(self, aFrame, aList)

    def HitTest(self, *args) -> "bool":
        r"""
        HitTest(PCB_DIMENSION_BASE self, wxPoint aPosition, int aAccuracy) -> bool
        HitTest(PCB_DIMENSION_BASE self, EDA_RECT aRect, bool aContained, int aAccuracy=0) -> bool
        """
        return _pcbnew.PCB_DIMENSION_BASE_HitTest(self, *args)

    def GetBoundingBox(self) -> "EDA_RECT const":
        r"""GetBoundingBox(PCB_DIMENSION_BASE self) -> EDA_RECT"""
        return _pcbnew.PCB_DIMENSION_BASE_GetBoundingBox(self)

    def GetEffectiveShape(self, *args) -> "std::shared_ptr< SHAPE >":
        r"""GetEffectiveShape(PCB_DIMENSION_BASE self, PCB_LAYER_ID aLayer, FLASHING aFlash=DEFAULT) -> std::shared_ptr< SHAPE >"""
        return _pcbnew.PCB_DIMENSION_BASE_GetEffectiveShape(self, *args)

    def GetSelectMenuText(self, aUnits: "EDA_UNITS") -> "wxString":
        r"""GetSelectMenuText(PCB_DIMENSION_BASE self, EDA_UNITS aUnits) -> wxString"""
        return _pcbnew.PCB_DIMENSION_BASE_GetSelectMenuText(self, aUnits)

    def ViewBBox(self) -> "BOX2I const":
        r"""ViewBBox(PCB_DIMENSION_BASE self) -> BOX2I const"""
        return _pcbnew.PCB_DIMENSION_BASE_ViewBBox(self)

    def TransformShapeWithClearanceToPolygon(self, aCornerBuffer: "SHAPE_POLY_SET", aLayer: "PCB_LAYER_ID", aClearance: "int", aError: "int", aErrorLoc: "ERROR_LOC", aIgnoreLineWidth: "bool") -> "void":
        r"""TransformShapeWithClearanceToPolygon(PCB_DIMENSION_BASE self, SHAPE_POLY_SET aCornerBuffer, PCB_LAYER_ID aLayer, int aClearance, int aError, ERROR_LOC aErrorLoc, bool aIgnoreLineWidth)"""
        return _pcbnew.PCB_DIMENSION_BASE_TransformShapeWithClearanceToPolygon(self, aCornerBuffer, aLayer, aClearance, aError, aErrorLoc, aIgnoreLineWidth)
    __swig_destroy__ = _pcbnew.delete_PCB_DIMENSION_BASE

# Register PCB_DIMENSION_BASE in _pcbnew:
_pcbnew.PCB_DIMENSION_BASE_swigregister(PCB_DIMENSION_BASE)

class PCB_DIM_ALIGNED(PCB_DIMENSION_BASE):
    r"""Proxy of C++ PCB_DIM_ALIGNED 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, aParent: "BOARD_ITEM", aType: "KICAD_T"=PCB_DIM_ALIGNED_T):
        r"""__init__(PCB_DIM_ALIGNED self, BOARD_ITEM aParent, KICAD_T aType=PCB_DIM_ALIGNED_T) -> PCB_DIM_ALIGNED"""
        _pcbnew.PCB_DIM_ALIGNED_swiginit(self, _pcbnew.new_PCB_DIM_ALIGNED(aParent, aType))
    __swig_destroy__ = _pcbnew.delete_PCB_DIM_ALIGNED

    @staticmethod
    def ClassOf(aItem: "EDA_ITEM") -> "bool":
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.PCB_DIM_ALIGNED_ClassOf(aItem)

    def Clone(self) -> "EDA_ITEM *":
        r"""Clone(PCB_DIM_ALIGNED self) -> EDA_ITEM"""
        return _pcbnew.PCB_DIM_ALIGNED_Clone(self)

    def SwapData(self, aImage: "BOARD_ITEM") -> "void":
        r"""SwapData(PCB_DIM_ALIGNED self, BOARD_ITEM aImage)"""
        return _pcbnew.PCB_DIM_ALIGNED_SwapData(self, aImage)

    def GetMenuImage(self) -> "BITMAPS":
        r"""GetMenuImage(PCB_DIM_ALIGNED self) -> BITMAPS"""
        return _pcbnew.PCB_DIM_ALIGNED_GetMenuImage(self)

    def GetCrossbarStart(self) -> "wxPoint const &":
        r"""GetCrossbarStart(PCB_DIM_ALIGNED self) -> wxPoint"""
        return _pcbnew.PCB_DIM_ALIGNED_GetCrossbarStart(self)

    def GetCrossbarEnd(self) -> "wxPoint const &":
        r"""GetCrossbarEnd(PCB_DIM_ALIGNED self) -> wxPoint"""
        return _pcbnew.PCB_DIM_ALIGNED_GetCrossbarEnd(self)

    def SetHeight(self, aHeight: "int") -> "void":
        r"""SetHeight(PCB_DIM_ALIGNED self, int aHeight)"""
        return _pcbnew.PCB_DIM_ALIGNED_SetHeight(self, aHeight)

    def GetHeight(self) -> "int":
        r"""GetHeight(PCB_DIM_ALIGNED self) -> int"""
        return _pcbnew.PCB_DIM_ALIGNED_GetHeight(self)

    def UpdateHeight(self, aCrossbarStart: "wxPoint", aCrossbarEnd: "wxPoint") -> "void":
        r"""UpdateHeight(PCB_DIM_ALIGNED self, wxPoint aCrossbarStart, wxPoint aCrossbarEnd)"""
        return _pcbnew.PCB_DIM_ALIGNED_UpdateHeight(self, aCrossbarStart, aCrossbarEnd)

    def SetExtensionHeight(self, aHeight: "int") -> "void":
        r"""SetExtensionHeight(PCB_DIM_ALIGNED self, int aHeight)"""
        return _pcbnew.PCB_DIM_ALIGNED_SetExtensionHeight(self, aHeight)

    def GetExtensionHeight(self) -> "int":
        r"""GetExtensionHeight(PCB_DIM_ALIGNED self) -> int"""
        return _pcbnew.PCB_DIM_ALIGNED_GetExtensionHeight(self)

    def GetAngle(self) -> "double":
        r"""GetAngle(PCB_DIM_ALIGNED self) -> double"""
        return _pcbnew.PCB_DIM_ALIGNED_GetAngle(self)

    def GetClass(self) -> "wxString":
        r"""GetClass(PCB_DIM_ALIGNED self) -> wxString"""
        return _pcbnew.PCB_DIM_ALIGNED_GetClass(self)

    def GetMsgPanelInfo(self, aFrame: "EDA_DRAW_FRAME *", aList: "std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > &") -> "void":
        r"""GetMsgPanelInfo(PCB_DIM_ALIGNED self, EDA_DRAW_FRAME * aFrame, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.PCB_DIM_ALIGNED_GetMsgPanelInfo(self, aFrame, aList)

# Register PCB_DIM_ALIGNED in _pcbnew:
_pcbnew.PCB_DIM_ALIGNED_swigregister(PCB_DIM_ALIGNED)

def PCB_DIM_ALIGNED_ClassOf(aItem: "EDA_ITEM") -> "bool":
    r"""PCB_DIM_ALIGNED_ClassOf(EDA_ITEM aItem) -> bool"""
    return _pcbnew.PCB_DIM_ALIGNED_ClassOf(aItem)

class PCB_DIM_ORTHOGONAL(PCB_DIM_ALIGNED):
    r"""Proxy of C++ PCB_DIM_ORTHOGONAL class."""

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

    def __init__(self, aParent: "BOARD_ITEM"):
        r"""__init__(PCB_DIM_ORTHOGONAL self, BOARD_ITEM aParent) -> PCB_DIM_ORTHOGONAL"""
        _pcbnew.PCB_DIM_ORTHOGONAL_swiginit(self, _pcbnew.new_PCB_DIM_ORTHOGONAL(aParent))
    __swig_destroy__ = _pcbnew.delete_PCB_DIM_ORTHOGONAL

    @staticmethod
    def ClassOf(aItem: "EDA_ITEM") -> "bool":
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.PCB_DIM_ORTHOGONAL_ClassOf(aItem)

    def Clone(self) -> "EDA_ITEM *":
        r"""Clone(PCB_DIM_ORTHOGONAL self) -> EDA_ITEM"""
        return _pcbnew.PCB_DIM_ORTHOGONAL_Clone(self)

    def SwapData(self, aImage: "BOARD_ITEM") -> "void":
        r"""SwapData(PCB_DIM_ORTHOGONAL self, BOARD_ITEM aImage)"""
        return _pcbnew.PCB_DIM_ORTHOGONAL_SwapData(self, aImage)

    def GetMenuImage(self) -> "BITMAPS":
        r"""GetMenuImage(PCB_DIM_ORTHOGONAL self) -> BITMAPS"""
        return _pcbnew.PCB_DIM_ORTHOGONAL_GetMenuImage(self)

    def SetOrientation(self, aOrientation: "PCB_DIM_ORTHOGONAL::DIR") -> "void":
        r"""SetOrientation(PCB_DIM_ORTHOGONAL self, PCB_DIM_ORTHOGONAL::DIR aOrientation)"""
        return _pcbnew.PCB_DIM_ORTHOGONAL_SetOrientation(self, aOrientation)

    def GetOrientation(self) -> "PCB_DIM_ORTHOGONAL::DIR":
        r"""GetOrientation(PCB_DIM_ORTHOGONAL self) -> PCB_DIM_ORTHOGONAL::DIR"""
        return _pcbnew.PCB_DIM_ORTHOGONAL_GetOrientation(self)

    def GetClass(self) -> "wxString":
        r"""GetClass(PCB_DIM_ORTHOGONAL self) -> wxString"""
        return _pcbnew.PCB_DIM_ORTHOGONAL_GetClass(self)

    def Rotate(self, aRotCentre: "wxPoint", aAngle: "double") -> "void":
        r"""Rotate(PCB_DIM_ORTHOGONAL self, wxPoint aRotCentre, double aAngle)"""
        return _pcbnew.PCB_DIM_ORTHOGONAL_Rotate(self, aRotCentre, aAngle)

# Register PCB_DIM_ORTHOGONAL in _pcbnew:
_pcbnew.PCB_DIM_ORTHOGONAL_swigregister(PCB_DIM_ORTHOGONAL)

def PCB_DIM_ORTHOGONAL_ClassOf(aItem: "EDA_ITEM") -> "bool":
    r"""PCB_DIM_ORTHOGONAL_ClassOf(EDA_ITEM aItem) -> bool"""
    return _pcbnew.PCB_DIM_ORTHOGONAL_ClassOf(aItem)

class PCB_DIM_LEADER(PCB_DIMENSION_BASE):
    r"""Proxy of C++ PCB_DIM_LEADER 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, aParent: "BOARD_ITEM"):
        r"""__init__(PCB_DIM_LEADER self, BOARD_ITEM aParent) -> PCB_DIM_LEADER"""
        _pcbnew.PCB_DIM_LEADER_swiginit(self, _pcbnew.new_PCB_DIM_LEADER(aParent))

    @staticmethod
    def ClassOf(aItem: "EDA_ITEM") -> "bool":
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.PCB_DIM_LEADER_ClassOf(aItem)

    def Clone(self) -> "EDA_ITEM *":
        r"""Clone(PCB_DIM_LEADER self) -> EDA_ITEM"""
        return _pcbnew.PCB_DIM_LEADER_Clone(self)

    def SwapData(self, aImage: "BOARD_ITEM") -> "void":
        r"""SwapData(PCB_DIM_LEADER self, BOARD_ITEM aImage)"""
        return _pcbnew.PCB_DIM_LEADER_SwapData(self, aImage)

    def GetMenuImage(self) -> "BITMAPS":
        r"""GetMenuImage(PCB_DIM_LEADER self) -> BITMAPS"""
        return _pcbnew.PCB_DIM_LEADER_GetMenuImage(self)

    def GetClass(self) -> "wxString":
        r"""GetClass(PCB_DIM_LEADER self) -> wxString"""
        return _pcbnew.PCB_DIM_LEADER_GetClass(self)

    def SetTextFrame(self, aFrame: "DIM_TEXT_FRAME") -> "void":
        r"""SetTextFrame(PCB_DIM_LEADER self, DIM_TEXT_FRAME aFrame)"""
        return _pcbnew.PCB_DIM_LEADER_SetTextFrame(self, aFrame)

    def GetTextFrame(self) -> "DIM_TEXT_FRAME":
        r"""GetTextFrame(PCB_DIM_LEADER self) -> DIM_TEXT_FRAME"""
        return _pcbnew.PCB_DIM_LEADER_GetTextFrame(self)

    def GetMsgPanelInfo(self, aFrame: "EDA_DRAW_FRAME *", aList: "std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > &") -> "void":
        r"""GetMsgPanelInfo(PCB_DIM_LEADER self, EDA_DRAW_FRAME * aFrame, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.PCB_DIM_LEADER_GetMsgPanelInfo(self, aFrame, aList)
    __swig_destroy__ = _pcbnew.delete_PCB_DIM_LEADER

# Register PCB_DIM_LEADER in _pcbnew:
_pcbnew.PCB_DIM_LEADER_swigregister(PCB_DIM_LEADER)

def PCB_DIM_LEADER_ClassOf(aItem: "EDA_ITEM") -> "bool":
    r"""PCB_DIM_LEADER_ClassOf(EDA_ITEM aItem) -> bool"""
    return _pcbnew.PCB_DIM_LEADER_ClassOf(aItem)

class PCB_DIM_CENTER(PCB_DIMENSION_BASE):
    r"""Proxy of C++ PCB_DIM_CENTER 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, aParent: "BOARD_ITEM"):
        r"""__init__(PCB_DIM_CENTER self, BOARD_ITEM aParent) -> PCB_DIM_CENTER"""
        _pcbnew.PCB_DIM_CENTER_swiginit(self, _pcbnew.new_PCB_DIM_CENTER(aParent))

    @staticmethod
    def ClassOf(aItem: "EDA_ITEM") -> "bool":
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.PCB_DIM_CENTER_ClassOf(aItem)

    def Clone(self) -> "EDA_ITEM *":
        r"""Clone(PCB_DIM_CENTER self) -> EDA_ITEM"""
        return _pcbnew.PCB_DIM_CENTER_Clone(self)

    def SwapData(self, aImage: "BOARD_ITEM") -> "void":
        r"""SwapData(PCB_DIM_CENTER self, BOARD_ITEM aImage)"""
        return _pcbnew.PCB_DIM_CENTER_SwapData(self, aImage)

    def GetMenuImage(self) -> "BITMAPS":
        r"""GetMenuImage(PCB_DIM_CENTER self) -> BITMAPS"""
        return _pcbnew.PCB_DIM_CENTER_GetMenuImage(self)

    def GetClass(self) -> "wxString":
        r"""GetClass(PCB_DIM_CENTER self) -> wxString"""
        return _pcbnew.PCB_DIM_CENTER_GetClass(self)

    def GetBoundingBox(self) -> "EDA_RECT const":
        r"""GetBoundingBox(PCB_DIM_CENTER self) -> EDA_RECT"""
        return _pcbnew.PCB_DIM_CENTER_GetBoundingBox(self)

    def ViewBBox(self) -> "BOX2I const":
        r"""ViewBBox(PCB_DIM_CENTER self) -> BOX2I const"""
        return _pcbnew.PCB_DIM_CENTER_ViewBBox(self)
    __swig_destroy__ = _pcbnew.delete_PCB_DIM_CENTER

# Register PCB_DIM_CENTER in _pcbnew:
_pcbnew.PCB_DIM_CENTER_swigregister(PCB_DIM_CENTER)

def PCB_DIM_CENTER_ClassOf(aItem: "EDA_ITEM") -> "bool":
    r"""PCB_DIM_CENTER_ClassOf(EDA_ITEM aItem) -> bool"""
    return _pcbnew.PCB_DIM_CENTER_ClassOf(aItem)

MARKER_SHAPE_POINT_COUNT = _pcbnew.MARKER_SHAPE_POINT_COUNT

class PCB_MARKER(BOARD_ITEM, MARKER_BASE):
    r"""Proxy of C++ PCB_MARKER 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, aItem: "std::shared_ptr< RC_ITEM >", aPosition: "wxPoint"):
        r"""__init__(PCB_MARKER self, std::shared_ptr< RC_ITEM > aItem, wxPoint aPosition) -> PCB_MARKER"""
        _pcbnew.PCB_MARKER_swiginit(self, _pcbnew.new_PCB_MARKER(aItem, aPosition))
    __swig_destroy__ = _pcbnew.delete_PCB_MARKER

    @staticmethod
    def ClassOf(aItem: "EDA_ITEM") -> "bool":
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.PCB_MARKER_ClassOf(aItem)

    def GetUUID(self) -> "KIID const":
        r"""GetUUID(PCB_MARKER self) -> KIID"""
        return _pcbnew.PCB_MARKER_GetUUID(self)

    def Serialize(self) -> "wxString":
        r"""Serialize(PCB_MARKER self) -> wxString"""
        return _pcbnew.PCB_MARKER_Serialize(self)

    @staticmethod
    def Deserialize(data: "wxString") -> "PCB_MARKER *":
        r"""Deserialize(wxString data) -> PCB_MARKER"""
        return _pcbnew.PCB_MARKER_Deserialize(data)

    def Move(self, aMoveVector: "wxPoint") -> "void":
        r"""Move(PCB_MARKER self, wxPoint aMoveVector)"""
        return _pcbnew.PCB_MARKER_Move(self, aMoveVector)

    def Rotate(self, aRotCentre: "wxPoint", aAngle: "double") -> "void":
        r"""Rotate(PCB_MARKER self, wxPoint aRotCentre, double aAngle)"""
        return _pcbnew.PCB_MARKER_Rotate(self, aRotCentre, aAngle)

    def Flip(self, aCentre: "wxPoint", aFlipLeftRight: "bool") -> "void":
        r"""Flip(PCB_MARKER self, wxPoint aCentre, bool aFlipLeftRight)"""
        return _pcbnew.PCB_MARKER_Flip(self, aCentre, aFlipLeftRight)

    def GetPosition(self) -> "wxPoint":
        r"""GetPosition(PCB_MARKER self) -> wxPoint"""
        return _pcbnew.PCB_MARKER_GetPosition(self)

    def SetPosition(self, aPos: "wxPoint") -> "void":
        r"""SetPosition(PCB_MARKER self, wxPoint aPos)"""
        return _pcbnew.PCB_MARKER_SetPosition(self, aPos)

    def GetCenter(self) -> "wxPoint":
        r"""GetCenter(PCB_MARKER self) -> wxPoint"""
        return _pcbnew.PCB_MARKER_GetCenter(self)

    def HitTest(self, aPosition: "wxPoint", aAccuracy: "int"=0) -> "bool":
        r"""HitTest(PCB_MARKER self, wxPoint aPosition, int aAccuracy=0) -> bool"""
        return _pcbnew.PCB_MARKER_HitTest(self, aPosition, aAccuracy)

    def Clone(self) -> "EDA_ITEM *":
        r"""Clone(PCB_MARKER self) -> EDA_ITEM"""
        return _pcbnew.PCB_MARKER_Clone(self)

    def GetColorLayer(self) -> "GAL_LAYER_ID":
        r"""GetColorLayer(PCB_MARKER self) -> GAL_LAYER_ID"""
        return _pcbnew.PCB_MARKER_GetColorLayer(self)

    def GetEffectiveShape(self, *args) -> "std::shared_ptr< SHAPE >":
        r"""GetEffectiveShape(PCB_MARKER self, PCB_LAYER_ID aLayer, FLASHING aFlash=DEFAULT) -> std::shared_ptr< SHAPE >"""
        return _pcbnew.PCB_MARKER_GetEffectiveShape(self, *args)

    def GetMsgPanelInfo(self, aFrame: "EDA_DRAW_FRAME *", aList: "std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > &") -> "void":
        r"""GetMsgPanelInfo(PCB_MARKER self, EDA_DRAW_FRAME * aFrame, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.PCB_MARKER_GetMsgPanelInfo(self, aFrame, aList)

    def Matches(self, aSearchData: "wxFindReplaceData const &", aAuxData: "void *") -> "bool":
        r"""Matches(PCB_MARKER self, wxFindReplaceData const & aSearchData, void * aAuxData) -> bool"""
        return _pcbnew.PCB_MARKER_Matches(self, aSearchData, aAuxData)

    def GetSelectMenuText(self, aUnits: "EDA_UNITS") -> "wxString":
        r"""GetSelectMenuText(PCB_MARKER self, EDA_UNITS aUnits) -> wxString"""
        return _pcbnew.PCB_MARKER_GetSelectMenuText(self, aUnits)

    def GetMenuImage(self) -> "BITMAPS":
        r"""GetMenuImage(PCB_MARKER self) -> BITMAPS"""
        return _pcbnew.PCB_MARKER_GetMenuImage(self)

    def SetZoom(self, aZoomFactor: "double") -> "void":
        r"""SetZoom(PCB_MARKER self, double aZoomFactor)"""
        return _pcbnew.PCB_MARKER_SetZoom(self, aZoomFactor)

    def ViewBBox(self) -> "BOX2I const":
        r"""ViewBBox(PCB_MARKER self) -> BOX2I const"""
        return _pcbnew.PCB_MARKER_ViewBBox(self)

    def GetBoundingBox(self) -> "EDA_RECT const":
        r"""GetBoundingBox(PCB_MARKER self) -> EDA_RECT"""
        return _pcbnew.PCB_MARKER_GetBoundingBox(self)

    def ViewGetLayers(self, aLayers: "int []", aCount: "int &") -> "void":
        r"""ViewGetLayers(PCB_MARKER self, int [] aLayers, int & aCount)"""
        return _pcbnew.PCB_MARKER_ViewGetLayers(self, aLayers, aCount)

    def GetClass(self) -> "wxString":
        r"""GetClass(PCB_MARKER self) -> wxString"""
        return _pcbnew.PCB_MARKER_GetClass(self)

# Register PCB_MARKER in _pcbnew:
_pcbnew.PCB_MARKER_swigregister(PCB_MARKER)

def PCB_MARKER_ClassOf(aItem: "EDA_ITEM") -> "bool":
    r"""PCB_MARKER_ClassOf(EDA_ITEM aItem) -> bool"""
    return _pcbnew.PCB_MARKER_ClassOf(aItem)

def PCB_MARKER_Deserialize(data: "wxString") -> "PCB_MARKER *":
    r"""PCB_MARKER_Deserialize(wxString data) -> PCB_MARKER"""
    return _pcbnew.PCB_MARKER_Deserialize(data)

class PCB_TARGET(BOARD_ITEM):
    r"""Proxy of C++ PCB_TARGET 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__(PCB_TARGET self, BOARD_ITEM aParent) -> PCB_TARGET
        __init__(PCB_TARGET self, BOARD_ITEM aParent, int aShape, PCB_LAYER_ID aLayer, wxPoint aPos, int aSize, int aWidth) -> PCB_TARGET
        """
        _pcbnew.PCB_TARGET_swiginit(self, _pcbnew.new_PCB_TARGET(*args))
    __swig_destroy__ = _pcbnew.delete_PCB_TARGET

    @staticmethod
    def ClassOf(aItem: "EDA_ITEM") -> "bool":
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.PCB_TARGET_ClassOf(aItem)

    def SetPosition(self, aPos: "wxPoint") -> "void":
        r"""SetPosition(PCB_TARGET self, wxPoint aPos)"""
        return _pcbnew.PCB_TARGET_SetPosition(self, aPos)

    def GetPosition(self) -> "wxPoint":
        r"""GetPosition(PCB_TARGET self) -> wxPoint"""
        return _pcbnew.PCB_TARGET_GetPosition(self)

    def SetShape(self, aShape: "int") -> "void":
        r"""SetShape(PCB_TARGET self, int aShape)"""
        return _pcbnew.PCB_TARGET_SetShape(self, aShape)

    def GetShape(self) -> "int":
        r"""GetShape(PCB_TARGET self) -> int"""
        return _pcbnew.PCB_TARGET_GetShape(self)

    def SetSize(self, aSize: "int") -> "void":
        r"""SetSize(PCB_TARGET self, int aSize)"""
        return _pcbnew.PCB_TARGET_SetSize(self, aSize)

    def GetSize(self) -> "int":
        r"""GetSize(PCB_TARGET self) -> int"""
        return _pcbnew.PCB_TARGET_GetSize(self)

    def SetWidth(self, aWidth: "int") -> "void":
        r"""SetWidth(PCB_TARGET self, int aWidth)"""
        return _pcbnew.PCB_TARGET_SetWidth(self, aWidth)

    def GetWidth(self) -> "int":
        r"""GetWidth(PCB_TARGET self) -> int"""
        return _pcbnew.PCB_TARGET_GetWidth(self)

    def Move(self, aMoveVector: "wxPoint") -> "void":
        r"""Move(PCB_TARGET self, wxPoint aMoveVector)"""
        return _pcbnew.PCB_TARGET_Move(self, aMoveVector)

    def Rotate(self, aRotCentre: "wxPoint", aAngle: "double") -> "void":
        r"""Rotate(PCB_TARGET self, wxPoint aRotCentre, double aAngle)"""
        return _pcbnew.PCB_TARGET_Rotate(self, aRotCentre, aAngle)

    def Flip(self, aCentre: "wxPoint", aFlipLeftRight: "bool") -> "void":
        r"""Flip(PCB_TARGET self, wxPoint aCentre, bool aFlipLeftRight)"""
        return _pcbnew.PCB_TARGET_Flip(self, aCentre, aFlipLeftRight)

    def GetClass(self) -> "wxString":
        r"""GetClass(PCB_TARGET self) -> wxString"""
        return _pcbnew.PCB_TARGET_GetClass(self)

    def HitTest(self, *args) -> "bool":
        r"""
        HitTest(PCB_TARGET self, wxPoint aPosition, int aAccuracy=0) -> bool
        HitTest(PCB_TARGET self, EDA_RECT aRect, bool aContained, int aAccuracy=0) -> bool
        """
        return _pcbnew.PCB_TARGET_HitTest(self, *args)

    def GetBoundingBox(self) -> "EDA_RECT const":
        r"""GetBoundingBox(PCB_TARGET self) -> EDA_RECT"""
        return _pcbnew.PCB_TARGET_GetBoundingBox(self)

    def GetEffectiveShape(self, *args) -> "std::shared_ptr< SHAPE >":
        r"""GetEffectiveShape(PCB_TARGET self, PCB_LAYER_ID aLayer, FLASHING aFlash=DEFAULT) -> std::shared_ptr< SHAPE >"""
        return _pcbnew.PCB_TARGET_GetEffectiveShape(self, *args)

    def GetSelectMenuText(self, aUnits: "EDA_UNITS") -> "wxString":
        r"""GetSelectMenuText(PCB_TARGET self, EDA_UNITS aUnits) -> wxString"""
        return _pcbnew.PCB_TARGET_GetSelectMenuText(self, aUnits)

    def GetMenuImage(self) -> "BITMAPS":
        r"""GetMenuImage(PCB_TARGET self) -> BITMAPS"""
        return _pcbnew.PCB_TARGET_GetMenuImage(self)

    def Clone(self) -> "EDA_ITEM *":
        r"""Clone(PCB_TARGET self) -> EDA_ITEM"""
        return _pcbnew.PCB_TARGET_Clone(self)

    def SwapData(self, aImage: "BOARD_ITEM") -> "void":
        r"""SwapData(PCB_TARGET self, BOARD_ITEM aImage)"""
        return _pcbnew.PCB_TARGET_SwapData(self, aImage)

    def GetMsgPanelInfo(self, aFrame: "EDA_DRAW_FRAME *", aList: "std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > &") -> "void":
        r"""GetMsgPanelInfo(PCB_TARGET self, EDA_DRAW_FRAME * aFrame, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.PCB_TARGET_GetMsgPanelInfo(self, aFrame, aList)

    def TransformShapeWithClearanceToPolygon(self, aCornerBuffer: "SHAPE_POLY_SET", aLayer: "PCB_LAYER_ID", aClearanceValue: "int", aError: "int", aErrorLoc: "ERROR_LOC", ignoreLineWidth: "bool"=False) -> "void":
        r"""TransformShapeWithClearanceToPolygon(PCB_TARGET self, SHAPE_POLY_SET aCornerBuffer, PCB_LAYER_ID aLayer, int aClearanceValue, int aError, ERROR_LOC aErrorLoc, bool ignoreLineWidth=False)"""
        return _pcbnew.PCB_TARGET_TransformShapeWithClearanceToPolygon(self, aCornerBuffer, aLayer, aClearanceValue, aError, aErrorLoc, ignoreLineWidth)

# Register PCB_TARGET in _pcbnew:
_pcbnew.PCB_TARGET_swigregister(PCB_TARGET)

def PCB_TARGET_ClassOf(aItem: "EDA_ITEM") -> "bool":
    r"""PCB_TARGET_ClassOf(EDA_ITEM aItem) -> bool"""
    return _pcbnew.PCB_TARGET_ClassOf(aItem)

class FP_SHAPE(PCB_SHAPE):
    r"""Proxy of C++ FP_SHAPE 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__(FP_SHAPE self, FOOTPRINT parent, SHAPE_T aShape=SEGMENT) -> FP_SHAPE"""
        _pcbnew.FP_SHAPE_swiginit(self, _pcbnew.new_FP_SHAPE(*args))
    __swig_destroy__ = _pcbnew.delete_FP_SHAPE

    @staticmethod
    def ClassOf(aItem: "EDA_ITEM") -> "bool":
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.FP_SHAPE_ClassOf(aItem)

    def IsType(self, aScanTypes: "KICAD_T const []") -> "bool":
        r"""IsType(FP_SHAPE self, KICAD_T const [] aScanTypes) -> bool"""
        return _pcbnew.FP_SHAPE_IsType(self, aScanTypes)

    def SetArcAngleAndEnd0(self, aAngle: "double", aCheckNegativeAngle: "bool"=False) -> "void":
        r"""SetArcAngleAndEnd0(FP_SHAPE self, double aAngle, bool aCheckNegativeAngle=False)"""
        return _pcbnew.FP_SHAPE_SetArcAngleAndEnd0(self, aAngle, aCheckNegativeAngle)

    def SetArcGeometry0(self, aStart: "wxPoint", aMid: "wxPoint", aEnd: "wxPoint") -> "void":
        r"""SetArcGeometry0(FP_SHAPE self, wxPoint aStart, wxPoint aMid, wxPoint aEnd)"""
        return _pcbnew.FP_SHAPE_SetArcGeometry0(self, aStart, aMid, aEnd)

    def Move(self, aMoveVector: "wxPoint") -> "void":
        r"""Move(FP_SHAPE self, wxPoint aMoveVector)"""
        return _pcbnew.FP_SHAPE_Move(self, aMoveVector)

    def Mirror(self, aCentre: "wxPoint", aMirrorAroundXAxis: "bool") -> "void":
        r"""Mirror(FP_SHAPE self, wxPoint aCentre, bool aMirrorAroundXAxis)"""
        return _pcbnew.FP_SHAPE_Mirror(self, aCentre, aMirrorAroundXAxis)

    def Rotate(self, aRotCentre: "wxPoint", aAngle: "double") -> "void":
        r"""Rotate(FP_SHAPE self, wxPoint aRotCentre, double aAngle)"""
        return _pcbnew.FP_SHAPE_Rotate(self, aRotCentre, aAngle)

    def Flip(self, aCentre: "wxPoint", aFlipLeftRight: "bool") -> "void":
        r"""Flip(FP_SHAPE self, wxPoint aCentre, bool aFlipLeftRight)"""
        return _pcbnew.FP_SHAPE_Flip(self, aCentre, aFlipLeftRight)

    def IsParentFlipped(self) -> "bool":
        r"""IsParentFlipped(FP_SHAPE self) -> bool"""
        return _pcbnew.FP_SHAPE_IsParentFlipped(self)

    def SetStart0(self, aPoint: "wxPoint") -> "void":
        r"""SetStart0(FP_SHAPE self, wxPoint aPoint)"""
        return _pcbnew.FP_SHAPE_SetStart0(self, aPoint)

    def GetStart0(self) -> "wxPoint const &":
        r"""GetStart0(FP_SHAPE self) -> wxPoint"""
        return _pcbnew.FP_SHAPE_GetStart0(self)

    def SetEnd0(self, aPoint: "wxPoint") -> "void":
        r"""SetEnd0(FP_SHAPE self, wxPoint aPoint)"""
        return _pcbnew.FP_SHAPE_SetEnd0(self, aPoint)

    def GetEnd0(self) -> "wxPoint const &":
        r"""GetEnd0(FP_SHAPE self) -> wxPoint"""
        return _pcbnew.FP_SHAPE_GetEnd0(self)

    def SetBezierC1_0(self, aPoint: "wxPoint") -> "void":
        r"""SetBezierC1_0(FP_SHAPE self, wxPoint aPoint)"""
        return _pcbnew.FP_SHAPE_SetBezierC1_0(self, aPoint)

    def GetBezierC1_0(self) -> "wxPoint const &":
        r"""GetBezierC1_0(FP_SHAPE self) -> wxPoint"""
        return _pcbnew.FP_SHAPE_GetBezierC1_0(self)

    def SetBezierC2_0(self, aPoint: "wxPoint") -> "void":
        r"""SetBezierC2_0(FP_SHAPE self, wxPoint aPoint)"""
        return _pcbnew.FP_SHAPE_SetBezierC2_0(self, aPoint)

    def GetBezierC2_0(self) -> "wxPoint const &":
        r"""GetBezierC2_0(FP_SHAPE self) -> wxPoint"""
        return _pcbnew.FP_SHAPE_GetBezierC2_0(self)

    def GetCenter0(self) -> "wxPoint":
        r"""GetCenter0(FP_SHAPE self) -> wxPoint"""
        return _pcbnew.FP_SHAPE_GetCenter0(self)

    def SetCenter0(self, aPt: "wxPoint") -> "void":
        r"""SetCenter0(FP_SHAPE self, wxPoint aPt)"""
        return _pcbnew.FP_SHAPE_SetCenter0(self, aPt)

    def GetArcMid0(self) -> "wxPoint":
        r"""GetArcMid0(FP_SHAPE self) -> wxPoint"""
        return _pcbnew.FP_SHAPE_GetArcMid0(self)

    def SetLocalCoord(self) -> "void":
        r"""SetLocalCoord(FP_SHAPE self)"""
        return _pcbnew.FP_SHAPE_SetLocalCoord(self)

    def SetDrawCoord(self) -> "void":
        r"""SetDrawCoord(FP_SHAPE self)"""
        return _pcbnew.FP_SHAPE_SetDrawCoord(self)

    def GetMsgPanelInfo(self, aFrame: "EDA_DRAW_FRAME *", aList: "std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > &") -> "void":
        r"""GetMsgPanelInfo(FP_SHAPE self, EDA_DRAW_FRAME * aFrame, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.FP_SHAPE_GetMsgPanelInfo(self, aFrame, aList)

    def GetClass(self) -> "wxString":
        r"""GetClass(FP_SHAPE self) -> wxString"""
        return _pcbnew.FP_SHAPE_GetClass(self)

    def GetParentAsString(self) -> "wxString":
        r"""GetParentAsString(FP_SHAPE self) -> wxString"""
        return _pcbnew.FP_SHAPE_GetParentAsString(self)

    def GetSelectMenuText(self, aUnits: "EDA_UNITS") -> "wxString":
        r"""GetSelectMenuText(FP_SHAPE self, EDA_UNITS aUnits) -> wxString"""
        return _pcbnew.FP_SHAPE_GetSelectMenuText(self, aUnits)

    def GetMenuImage(self) -> "BITMAPS":
        r"""GetMenuImage(FP_SHAPE self) -> BITMAPS"""
        return _pcbnew.FP_SHAPE_GetMenuImage(self)

    def Clone(self) -> "EDA_ITEM *":
        r"""Clone(FP_SHAPE self) -> EDA_ITEM"""
        return _pcbnew.FP_SHAPE_Clone(self)

    def ViewGetLOD(self, aLayer: "int", aView: "KIGFX::VIEW *") -> "double":
        r"""ViewGetLOD(FP_SHAPE self, int aLayer, KIGFX::VIEW * aView) -> double"""
        return _pcbnew.FP_SHAPE_ViewGetLOD(self, aLayer, aView)

# Register FP_SHAPE in _pcbnew:
_pcbnew.FP_SHAPE_swigregister(FP_SHAPE)

def FP_SHAPE_ClassOf(aItem: "EDA_ITEM") -> "bool":
    r"""FP_SHAPE_ClassOf(EDA_ITEM aItem) -> bool"""
    return _pcbnew.FP_SHAPE_ClassOf(aItem)

class FP_TEXT(BOARD_ITEM, EDA_TEXT):
    r"""Proxy of C++ FP_TEXT class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    TEXT_is_REFERENCE = _pcbnew.FP_TEXT_TEXT_is_REFERENCE
    
    TEXT_is_VALUE = _pcbnew.FP_TEXT_TEXT_is_VALUE
    
    TEXT_is_DIVERS = _pcbnew.FP_TEXT_TEXT_is_DIVERS
    

    def __init__(self, *args):
        r"""__init__(FP_TEXT self, FOOTPRINT aParentFootprint, FP_TEXT::TEXT_TYPE text_type=TEXT_is_DIVERS) -> FP_TEXT"""
        _pcbnew.FP_TEXT_swiginit(self, _pcbnew.new_FP_TEXT(*args))
    __swig_destroy__ = _pcbnew.delete_FP_TEXT

    @staticmethod
    def ClassOf(aItem: "EDA_ITEM") -> "bool":
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.FP_TEXT_ClassOf(aItem)

    def IsType(self, aScanTypes: "KICAD_T const []") -> "bool":
        r"""IsType(FP_TEXT self, KICAD_T const [] aScanTypes) -> bool"""
        return _pcbnew.FP_TEXT_IsType(self, aScanTypes)

    def GetParentAsString(self) -> "wxString":
        r"""GetParentAsString(FP_TEXT self) -> wxString"""
        return _pcbnew.FP_TEXT_GetParentAsString(self)

    def Matches(self, aSearchData: "wxFindReplaceData const &", aAuxData: "void *") -> "bool":
        r"""Matches(FP_TEXT self, wxFindReplaceData const & aSearchData, void * aAuxData) -> bool"""
        return _pcbnew.FP_TEXT_Matches(self, aSearchData, aAuxData)

    def GetPosition(self) -> "wxPoint":
        r"""GetPosition(FP_TEXT self) -> wxPoint"""
        return _pcbnew.FP_TEXT_GetPosition(self)

    def SetPosition(self, aPos: "wxPoint") -> "void":
        r"""SetPosition(FP_TEXT self, wxPoint aPos)"""
        return _pcbnew.FP_TEXT_SetPosition(self, aPos)

    def SetTextAngle(self, aAngle: "double") -> "void":
        r"""SetTextAngle(FP_TEXT self, double aAngle)"""
        return _pcbnew.FP_TEXT_SetTextAngle(self, aAngle)

    def KeepUpright(self, aOldOrientation: "double", aNewOrientation: "double") -> "void":
        r"""KeepUpright(FP_TEXT self, double aOldOrientation, double aNewOrientation)"""
        return _pcbnew.FP_TEXT_KeepUpright(self, aOldOrientation, aNewOrientation)

    def IsKeepUpright(self) -> "bool":
        r"""IsKeepUpright(FP_TEXT self) -> bool"""
        return _pcbnew.FP_TEXT_IsKeepUpright(self)

    def SetKeepUpright(self, aKeepUpright: "bool") -> "void":
        r"""SetKeepUpright(FP_TEXT self, bool aKeepUpright)"""
        return _pcbnew.FP_TEXT_SetKeepUpright(self, aKeepUpright)

    def Rotate(self, aOffset: "wxPoint", aAngle: "double") -> "void":
        r"""Rotate(FP_TEXT self, wxPoint aOffset, double aAngle)"""
        return _pcbnew.FP_TEXT_Rotate(self, aOffset, aAngle)

    def Flip(self, aCentre: "wxPoint", aFlipLeftRight: "bool") -> "void":
        r"""Flip(FP_TEXT self, wxPoint aCentre, bool aFlipLeftRight)"""
        return _pcbnew.FP_TEXT_Flip(self, aCentre, aFlipLeftRight)

    def IsParentFlipped(self) -> "bool":
        r"""IsParentFlipped(FP_TEXT self) -> bool"""
        return _pcbnew.FP_TEXT_IsParentFlipped(self)

    def Mirror(self, aCentre: "wxPoint", aMirrorAroundXAxis: "bool") -> "void":
        r"""Mirror(FP_TEXT self, wxPoint aCentre, bool aMirrorAroundXAxis)"""
        return _pcbnew.FP_TEXT_Mirror(self, aCentre, aMirrorAroundXAxis)

    def Move(self, aMoveVector: "wxPoint") -> "void":
        r"""Move(FP_TEXT self, wxPoint aMoveVector)"""
        return _pcbnew.FP_TEXT_Move(self, aMoveVector)

    def SetType(self, aType: "FP_TEXT::TEXT_TYPE") -> "void":
        r"""SetType(FP_TEXT self, FP_TEXT::TEXT_TYPE aType)"""
        return _pcbnew.FP_TEXT_SetType(self, aType)

    def GetType(self) -> "FP_TEXT::TEXT_TYPE":
        r"""GetType(FP_TEXT self) -> FP_TEXT::TEXT_TYPE"""
        return _pcbnew.FP_TEXT_GetType(self)

    def SetEffects(self, aSrc: "FP_TEXT") -> "void":
        r"""SetEffects(FP_TEXT self, FP_TEXT aSrc)"""
        return _pcbnew.FP_TEXT_SetEffects(self, aSrc)

    def SwapEffects(self, aTradingPartner: "FP_TEXT") -> "void":
        r"""SwapEffects(FP_TEXT self, FP_TEXT aTradingPartner)"""
        return _pcbnew.FP_TEXT_SwapEffects(self, aTradingPartner)

    def SetPos0(self, aPos: "wxPoint") -> "void":
        r"""SetPos0(FP_TEXT self, wxPoint aPos)"""
        return _pcbnew.FP_TEXT_SetPos0(self, aPos)

    def GetPos0(self) -> "wxPoint const &":
        r"""GetPos0(FP_TEXT self) -> wxPoint"""
        return _pcbnew.FP_TEXT_GetPos0(self)

    def GetLength(self) -> "int":
        r"""GetLength(FP_TEXT self) -> int"""
        return _pcbnew.FP_TEXT_GetLength(self)

    def GetDrawRotation(self) -> "double":
        r"""GetDrawRotation(FP_TEXT self) -> double"""
        return _pcbnew.FP_TEXT_GetDrawRotation(self)

    def GetDrawRotationRadians(self) -> "double":
        r"""GetDrawRotationRadians(FP_TEXT self) -> double"""
        return _pcbnew.FP_TEXT_GetDrawRotationRadians(self)

    def GetBoundingBox(self) -> "EDA_RECT const":
        r"""GetBoundingBox(FP_TEXT self) -> EDA_RECT"""
        return _pcbnew.FP_TEXT_GetBoundingBox(self)

    def SetDrawCoord(self) -> "void":
        r"""SetDrawCoord(FP_TEXT self)"""
        return _pcbnew.FP_TEXT_SetDrawCoord(self)

    def SetLocalCoord(self) -> "void":
        r"""SetLocalCoord(FP_TEXT self)"""
        return _pcbnew.FP_TEXT_SetLocalCoord(self)

    def GetMsgPanelInfo(self, aFrame: "EDA_DRAW_FRAME *", aList: "std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > &") -> "void":
        r"""GetMsgPanelInfo(FP_TEXT self, EDA_DRAW_FRAME * aFrame, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.FP_TEXT_GetMsgPanelInfo(self, aFrame, aList)

    def TextHitTest(self, *args) -> "bool":
        r"""
        TextHitTest(FP_TEXT self, wxPoint aPoint, int aAccuracy=0) -> bool
        TextHitTest(FP_TEXT self, EDA_RECT aRect, bool aContains, int aAccuracy=0) -> bool
        """
        return _pcbnew.FP_TEXT_TextHitTest(self, *args)

    def HitTest(self, *args) -> "bool":
        r"""
        HitTest(FP_TEXT self, wxPoint aPosition, int aAccuracy) -> bool
        HitTest(FP_TEXT self, EDA_RECT aRect, bool aContained, int aAccuracy=0) -> bool
        """
        return _pcbnew.FP_TEXT_HitTest(self, *args)

    def TransformShapeWithClearanceToPolygon(self, aCornerBuffer: "SHAPE_POLY_SET", aLayer: "PCB_LAYER_ID", aClearance: "int", aError: "int", aErrorLoc: "ERROR_LOC", aIgnoreLineWidth: "bool") -> "void":
        r"""TransformShapeWithClearanceToPolygon(FP_TEXT self, SHAPE_POLY_SET aCornerBuffer, PCB_LAYER_ID aLayer, int aClearance, int aError, ERROR_LOC aErrorLoc, bool aIgnoreLineWidth)"""
        return _pcbnew.FP_TEXT_TransformShapeWithClearanceToPolygon(self, aCornerBuffer, aLayer, aClearance, aError, aErrorLoc, aIgnoreLineWidth)

    def TransformTextShapeWithClearanceToPolygon(self, aCornerBuffer: "SHAPE_POLY_SET", aLayer: "PCB_LAYER_ID", aClearanceValue: "int", aError: "int", aErrorLoc: "ERROR_LOC") -> "void":
        r"""TransformTextShapeWithClearanceToPolygon(FP_TEXT self, SHAPE_POLY_SET aCornerBuffer, PCB_LAYER_ID aLayer, int aClearanceValue, int aError, ERROR_LOC aErrorLoc)"""
        return _pcbnew.FP_TEXT_TransformTextShapeWithClearanceToPolygon(self, aCornerBuffer, aLayer, aClearanceValue, aError, aErrorLoc)

    def GetEffectiveShape(self, *args) -> "std::shared_ptr< SHAPE >":
        r"""GetEffectiveShape(FP_TEXT self, PCB_LAYER_ID aLayer=UNDEFINED_LAYER, FLASHING aFlash=DEFAULT) -> std::shared_ptr< SHAPE >"""
        return _pcbnew.FP_TEXT_GetEffectiveShape(self, *args)

    def GetClass(self) -> "wxString":
        r"""GetClass(FP_TEXT self) -> wxString"""
        return _pcbnew.FP_TEXT_GetClass(self)

    def GetSelectMenuText(self, aUnits: "EDA_UNITS") -> "wxString":
        r"""GetSelectMenuText(FP_TEXT self, EDA_UNITS aUnits) -> wxString"""
        return _pcbnew.FP_TEXT_GetSelectMenuText(self, aUnits)

    def GetMenuImage(self) -> "BITMAPS":
        r"""GetMenuImage(FP_TEXT self) -> BITMAPS"""
        return _pcbnew.FP_TEXT_GetMenuImage(self)

    def Clone(self) -> "EDA_ITEM *":
        r"""Clone(FP_TEXT self) -> EDA_ITEM"""
        return _pcbnew.FP_TEXT_Clone(self)

    def GetShownText(self, aDepth: "int"=0) -> "wxString":
        r"""GetShownText(FP_TEXT self, int aDepth=0) -> wxString"""
        return _pcbnew.FP_TEXT_GetShownText(self, aDepth)

    def ViewBBox(self) -> "BOX2I const":
        r"""ViewBBox(FP_TEXT self) -> BOX2I const"""
        return _pcbnew.FP_TEXT_ViewBBox(self)

    def ViewGetLayers(self, aLayers: "int []", aCount: "int &") -> "void":
        r"""ViewGetLayers(FP_TEXT self, int [] aLayers, int & aCount)"""
        return _pcbnew.FP_TEXT_ViewGetLayers(self, aLayers, aCount)

    def ViewGetLOD(self, aLayer: "int", aView: "KIGFX::VIEW *") -> "double":
        r"""ViewGetLOD(FP_TEXT self, int aLayer, KIGFX::VIEW * aView) -> double"""
        return _pcbnew.FP_TEXT_ViewGetLOD(self, aLayer, aView)

# Register FP_TEXT in _pcbnew:
_pcbnew.FP_TEXT_swigregister(FP_TEXT)

def FP_TEXT_ClassOf(aItem: "EDA_ITEM") -> "bool":
    r"""FP_TEXT_ClassOf(EDA_ITEM aItem) -> bool"""
    return _pcbnew.FP_TEXT_ClassOf(aItem)

CH_VISIBLE = _pcbnew.CH_VISIBLE

CH_UNROUTABLE = _pcbnew.CH_UNROUTABLE

CH_ROUTE_REQ = _pcbnew.CH_ROUTE_REQ

CH_ACTIF = _pcbnew.CH_ACTIF

LOCAL_RATSNEST_ITEM = _pcbnew.LOCAL_RATSNEST_ITEM

class PADS_VEC(object):
    r"""Proxy of C++ std::vector< PAD * > 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) -> "swig::SwigPyIterator *":
        r"""iterator(PADS_VEC self) -> SwigPyIterator"""
        return _pcbnew.PADS_VEC_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(PADS_VEC self) -> bool"""
        return _pcbnew.PADS_VEC___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(PADS_VEC self) -> bool"""
        return _pcbnew.PADS_VEC___bool__(self)

    def __len__(self) -> "std::vector< PAD * >::size_type":
        r"""__len__(PADS_VEC self) -> std::vector< PAD * >::size_type"""
        return _pcbnew.PADS_VEC___len__(self)

    def __getslice__(self, i: "std::vector< PAD * >::difference_type", j: "std::vector< PAD * >::difference_type") -> "std::vector< PAD *,std::allocator< PAD * > > *":
        r"""__getslice__(PADS_VEC self, std::vector< PAD * >::difference_type i, std::vector< PAD * >::difference_type j) -> PADS_VEC"""
        return _pcbnew.PADS_VEC___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        r"""
        __setslice__(PADS_VEC self, std::vector< PAD * >::difference_type i, std::vector< PAD * >::difference_type j)
        __setslice__(PADS_VEC self, std::vector< PAD * >::difference_type i, std::vector< PAD * >::difference_type j, PADS_VEC v)
        """
        return _pcbnew.PADS_VEC___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< PAD * >::difference_type", j: "std::vector< PAD * >::difference_type") -> "void":
        r"""__delslice__(PADS_VEC self, std::vector< PAD * >::difference_type i, std::vector< PAD * >::difference_type j)"""
        return _pcbnew.PADS_VEC___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        r"""
        __delitem__(PADS_VEC self, std::vector< PAD * >::difference_type i)
        __delitem__(PADS_VEC self, PySliceObject * slice)
        """
        return _pcbnew.PADS_VEC___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< PAD * >::value_type":
        r"""
        __getitem__(PADS_VEC self, PySliceObject * slice) -> PADS_VEC
        __getitem__(PADS_VEC self, std::vector< PAD * >::difference_type i) -> PAD
        """
        return _pcbnew.PADS_VEC___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(PADS_VEC self, PySliceObject * slice, PADS_VEC v)
        __setitem__(PADS_VEC self, PySliceObject * slice)
        __setitem__(PADS_VEC self, std::vector< PAD * >::difference_type i, PAD x)
        """
        return _pcbnew.PADS_VEC___setitem__(self, *args)

    def pop(self) -> "std::vector< PAD * >::value_type":
        r"""pop(PADS_VEC self) -> PAD"""
        return _pcbnew.PADS_VEC_pop(self)

    def append(self, x: "PAD") -> "void":
        r"""append(PADS_VEC self, PAD x)"""
        return _pcbnew.PADS_VEC_append(self, x)

    def empty(self) -> "bool":
        r"""empty(PADS_VEC self) -> bool"""
        return _pcbnew.PADS_VEC_empty(self)

    def size(self) -> "std::vector< PAD * >::size_type":
        r"""size(PADS_VEC self) -> std::vector< PAD * >::size_type"""
        return _pcbnew.PADS_VEC_size(self)

    def swap(self, v: "PADS_VEC") -> "void":
        r"""swap(PADS_VEC self, PADS_VEC v)"""
        return _pcbnew.PADS_VEC_swap(self, v)

    def begin(self) -> "std::vector< PAD * >::iterator":
        r"""begin(PADS_VEC self) -> std::vector< PAD * >::iterator"""
        return _pcbnew.PADS_VEC_begin(self)

    def end(self) -> "std::vector< PAD * >::iterator":
        r"""end(PADS_VEC self) -> std::vector< PAD * >::iterator"""
        return _pcbnew.PADS_VEC_end(self)

    def rbegin(self) -> "std::vector< PAD * >::reverse_iterator":
        r"""rbegin(PADS_VEC self) -> std::vector< PAD * >::reverse_iterator"""
        return _pcbnew.PADS_VEC_rbegin(self)

    def rend(self) -> "std::vector< PAD * >::reverse_iterator":
        r"""rend(PADS_VEC self) -> std::vector< PAD * >::reverse_iterator"""
        return _pcbnew.PADS_VEC_rend(self)

    def clear(self) -> "void":
        r"""clear(PADS_VEC self)"""
        return _pcbnew.PADS_VEC_clear(self)

    def get_allocator(self) -> "std::vector< PAD * >::allocator_type":
        r"""get_allocator(PADS_VEC self) -> std::vector< PAD * >::allocator_type"""
        return _pcbnew.PADS_VEC_get_allocator(self)

    def pop_back(self) -> "void":
        r"""pop_back(PADS_VEC self)"""
        return _pcbnew.PADS_VEC_pop_back(self)

    def erase(self, *args) -> "std::vector< PAD * >::iterator":
        r"""
        erase(PADS_VEC self, std::vector< PAD * >::iterator pos) -> std::vector< PAD * >::iterator
        erase(PADS_VEC self, std::vector< PAD * >::iterator first, std::vector< PAD * >::iterator last) -> std::vector< PAD * >::iterator
        """
        return _pcbnew.PADS_VEC_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(PADS_VEC self) -> PADS_VEC
        __init__(PADS_VEC self, PADS_VEC other) -> PADS_VEC
        __init__(PADS_VEC self, std::vector< PAD * >::size_type size) -> PADS_VEC
        __init__(PADS_VEC self, std::vector< PAD * >::size_type size, PAD value) -> PADS_VEC
        """
        _pcbnew.PADS_VEC_swiginit(self, _pcbnew.new_PADS_VEC(*args))

    def push_back(self, x: "PAD") -> "void":
        r"""push_back(PADS_VEC self, PAD x)"""
        return _pcbnew.PADS_VEC_push_back(self, x)

    def front(self) -> "std::vector< PAD * >::value_type":
        r"""front(PADS_VEC self) -> PAD"""
        return _pcbnew.PADS_VEC_front(self)

    def back(self) -> "std::vector< PAD * >::value_type":
        r"""back(PADS_VEC self) -> PAD"""
        return _pcbnew.PADS_VEC_back(self)

    def assign(self, n: "std::vector< PAD * >::size_type", x: "PAD") -> "void":
        r"""assign(PADS_VEC self, std::vector< PAD * >::size_type n, PAD x)"""
        return _pcbnew.PADS_VEC_assign(self, n, x)

    def resize(self, *args) -> "void":
        r"""
        resize(PADS_VEC self, std::vector< PAD * >::size_type new_size)
        resize(PADS_VEC self, std::vector< PAD * >::size_type new_size, PAD x)
        """
        return _pcbnew.PADS_VEC_resize(self, *args)

    def insert(self, *args) -> "void":
        r"""
        insert(PADS_VEC self, std::vector< PAD * >::iterator pos, PAD x) -> std::vector< PAD * >::iterator
        insert(PADS_VEC self, std::vector< PAD * >::iterator pos, std::vector< PAD * >::size_type n, PAD x)
        """
        return _pcbnew.PADS_VEC_insert(self, *args)

    def reserve(self, n: "std::vector< PAD * >::size_type") -> "void":
        r"""reserve(PADS_VEC self, std::vector< PAD * >::size_type n)"""
        return _pcbnew.PADS_VEC_reserve(self, n)

    def capacity(self) -> "std::vector< PAD * >::size_type":
        r"""capacity(PADS_VEC self) -> std::vector< PAD * >::size_type"""
        return _pcbnew.PADS_VEC_capacity(self)
    __swig_destroy__ = _pcbnew.delete_PADS_VEC

# Register PADS_VEC in _pcbnew:
_pcbnew.PADS_VEC_swigregister(PADS_VEC)

class TRACKS_VEC(object):
    r"""Proxy of C++ std::vector< PCB_TRACK * > 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) -> "swig::SwigPyIterator *":
        r"""iterator(TRACKS_VEC self) -> SwigPyIterator"""
        return _pcbnew.TRACKS_VEC_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(TRACKS_VEC self) -> bool"""
        return _pcbnew.TRACKS_VEC___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(TRACKS_VEC self) -> bool"""
        return _pcbnew.TRACKS_VEC___bool__(self)

    def __len__(self) -> "std::vector< PCB_TRACK * >::size_type":
        r"""__len__(TRACKS_VEC self) -> std::vector< PCB_TRACK * >::size_type"""
        return _pcbnew.TRACKS_VEC___len__(self)

    def __getslice__(self, i: "std::vector< PCB_TRACK * >::difference_type", j: "std::vector< PCB_TRACK * >::difference_type") -> "std::vector< PCB_TRACK *,std::allocator< PCB_TRACK * > > *":
        r"""__getslice__(TRACKS_VEC self, std::vector< PCB_TRACK * >::difference_type i, std::vector< PCB_TRACK * >::difference_type j) -> TRACKS_VEC"""
        return _pcbnew.TRACKS_VEC___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        r"""
        __setslice__(TRACKS_VEC self, std::vector< PCB_TRACK * >::difference_type i, std::vector< PCB_TRACK * >::difference_type j)
        __setslice__(TRACKS_VEC self, std::vector< PCB_TRACK * >::difference_type i, std::vector< PCB_TRACK * >::difference_type j, TRACKS_VEC v)
        """
        return _pcbnew.TRACKS_VEC___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< PCB_TRACK * >::difference_type", j: "std::vector< PCB_TRACK * >::difference_type") -> "void":
        r"""__delslice__(TRACKS_VEC self, std::vector< PCB_TRACK * >::difference_type i, std::vector< PCB_TRACK * >::difference_type j)"""
        return _pcbnew.TRACKS_VEC___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        r"""
        __delitem__(TRACKS_VEC self, std::vector< PCB_TRACK * >::difference_type i)
        __delitem__(TRACKS_VEC self, PySliceObject * slice)
        """
        return _pcbnew.TRACKS_VEC___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< PCB_TRACK * >::value_type":
        r"""
        __getitem__(TRACKS_VEC self, PySliceObject * slice) -> TRACKS_VEC
        __getitem__(TRACKS_VEC self, std::vector< PCB_TRACK * >::difference_type i) -> PCB_TRACK
        """
        return _pcbnew.TRACKS_VEC___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(TRACKS_VEC self, PySliceObject * slice, TRACKS_VEC v)
        __setitem__(TRACKS_VEC self, PySliceObject * slice)
        __setitem__(TRACKS_VEC self, std::vector< PCB_TRACK * >::difference_type i, PCB_TRACK x)
        """
        return _pcbnew.TRACKS_VEC___setitem__(self, *args)

    def pop(self) -> "std::vector< PCB_TRACK * >::value_type":
        r"""pop(TRACKS_VEC self) -> PCB_TRACK"""
        return _pcbnew.TRACKS_VEC_pop(self)

    def append(self, x: "PCB_TRACK") -> "void":
        r"""append(TRACKS_VEC self, PCB_TRACK x)"""
        return _pcbnew.TRACKS_VEC_append(self, x)

    def empty(self) -> "bool":
        r"""empty(TRACKS_VEC self) -> bool"""
        return _pcbnew.TRACKS_VEC_empty(self)

    def size(self) -> "std::vector< PCB_TRACK * >::size_type":
        r"""size(TRACKS_VEC self) -> std::vector< PCB_TRACK * >::size_type"""
        return _pcbnew.TRACKS_VEC_size(self)

    def swap(self, v: "TRACKS_VEC") -> "void":
        r"""swap(TRACKS_VEC self, TRACKS_VEC v)"""
        return _pcbnew.TRACKS_VEC_swap(self, v)

    def begin(self) -> "std::vector< PCB_TRACK * >::iterator":
        r"""begin(TRACKS_VEC self) -> std::vector< PCB_TRACK * >::iterator"""
        return _pcbnew.TRACKS_VEC_begin(self)

    def end(self) -> "std::vector< PCB_TRACK * >::iterator":
        r"""end(TRACKS_VEC self) -> std::vector< PCB_TRACK * >::iterator"""
        return _pcbnew.TRACKS_VEC_end(self)

    def rbegin(self) -> "std::vector< PCB_TRACK * >::reverse_iterator":
        r"""rbegin(TRACKS_VEC self) -> std::vector< PCB_TRACK * >::reverse_iterator"""
        return _pcbnew.TRACKS_VEC_rbegin(self)

    def rend(self) -> "std::vector< PCB_TRACK * >::reverse_iterator":
        r"""rend(TRACKS_VEC self) -> std::vector< PCB_TRACK * >::reverse_iterator"""
        return _pcbnew.TRACKS_VEC_rend(self)

    def clear(self) -> "void":
        r"""clear(TRACKS_VEC self)"""
        return _pcbnew.TRACKS_VEC_clear(self)

    def get_allocator(self) -> "std::vector< PCB_TRACK * >::allocator_type":
        r"""get_allocator(TRACKS_VEC self) -> std::vector< PCB_TRACK * >::allocator_type"""
        return _pcbnew.TRACKS_VEC_get_allocator(self)

    def pop_back(self) -> "void":
        r"""pop_back(TRACKS_VEC self)"""
        return _pcbnew.TRACKS_VEC_pop_back(self)

    def erase(self, *args) -> "std::vector< PCB_TRACK * >::iterator":
        r"""
        erase(TRACKS_VEC self, std::vector< PCB_TRACK * >::iterator pos) -> std::vector< PCB_TRACK * >::iterator
        erase(TRACKS_VEC self, std::vector< PCB_TRACK * >::iterator first, std::vector< PCB_TRACK * >::iterator last) -> std::vector< PCB_TRACK * >::iterator
        """
        return _pcbnew.TRACKS_VEC_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(TRACKS_VEC self) -> TRACKS_VEC
        __init__(TRACKS_VEC self, TRACKS_VEC other) -> TRACKS_VEC
        __init__(TRACKS_VEC self, std::vector< PCB_TRACK * >::size_type size) -> TRACKS_VEC
        __init__(TRACKS_VEC self, std::vector< PCB_TRACK * >::size_type size, PCB_TRACK value) -> TRACKS_VEC
        """
        _pcbnew.TRACKS_VEC_swiginit(self, _pcbnew.new_TRACKS_VEC(*args))

    def push_back(self, x: "PCB_TRACK") -> "void":
        r"""push_back(TRACKS_VEC self, PCB_TRACK x)"""
        return _pcbnew.TRACKS_VEC_push_back(self, x)

    def front(self) -> "std::vector< PCB_TRACK * >::value_type":
        r"""front(TRACKS_VEC self) -> PCB_TRACK"""
        return _pcbnew.TRACKS_VEC_front(self)

    def back(self) -> "std::vector< PCB_TRACK * >::value_type":
        r"""back(TRACKS_VEC self) -> PCB_TRACK"""
        return _pcbnew.TRACKS_VEC_back(self)

    def assign(self, n: "std::vector< PCB_TRACK * >::size_type", x: "PCB_TRACK") -> "void":
        r"""assign(TRACKS_VEC self, std::vector< PCB_TRACK * >::size_type n, PCB_TRACK x)"""
        return _pcbnew.TRACKS_VEC_assign(self, n, x)

    def resize(self, *args) -> "void":
        r"""
        resize(TRACKS_VEC self, std::vector< PCB_TRACK * >::size_type new_size)
        resize(TRACKS_VEC self, std::vector< PCB_TRACK * >::size_type new_size, PCB_TRACK x)
        """
        return _pcbnew.TRACKS_VEC_resize(self, *args)

    def insert(self, *args) -> "void":
        r"""
        insert(TRACKS_VEC self, std::vector< PCB_TRACK * >::iterator pos, PCB_TRACK x) -> std::vector< PCB_TRACK * >::iterator
        insert(TRACKS_VEC self, std::vector< PCB_TRACK * >::iterator pos, std::vector< PCB_TRACK * >::size_type n, PCB_TRACK x)
        """
        return _pcbnew.TRACKS_VEC_insert(self, *args)

    def reserve(self, n: "std::vector< PCB_TRACK * >::size_type") -> "void":
        r"""reserve(TRACKS_VEC self, std::vector< PCB_TRACK * >::size_type n)"""
        return _pcbnew.TRACKS_VEC_reserve(self, n)

    def capacity(self) -> "std::vector< PCB_TRACK * >::size_type":
        r"""capacity(TRACKS_VEC self) -> std::vector< PCB_TRACK * >::size_type"""
        return _pcbnew.TRACKS_VEC_capacity(self)
    __swig_destroy__ = _pcbnew.delete_TRACKS_VEC

# Register TRACKS_VEC in _pcbnew:
_pcbnew.TRACKS_VEC_swigregister(TRACKS_VEC)

class NETINFO_ITEM(BOARD_ITEM):
    r"""Proxy of C++ NETINFO_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__(NETINFO_ITEM self, BOARD aParent, wxString aNetName=wxEmptyString, int aNetCode=-1) -> NETINFO_ITEM"""
        _pcbnew.NETINFO_ITEM_swiginit(self, _pcbnew.new_NETINFO_ITEM(*args))
    __swig_destroy__ = _pcbnew.delete_NETINFO_ITEM

    @staticmethod
    def ClassOf(aItem: "EDA_ITEM") -> "bool":
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.NETINFO_ITEM_ClassOf(aItem)

    def GetClass(self) -> "wxString":
        r"""GetClass(NETINFO_ITEM self) -> wxString"""
        return _pcbnew.NETINFO_ITEM_GetClass(self)

    def GetPosition(self) -> "wxPoint":
        r"""GetPosition(NETINFO_ITEM self) -> wxPoint"""
        return _pcbnew.NETINFO_ITEM_GetPosition(self)

    def SetPosition(self, aPos: "wxPoint") -> "void":
        r"""SetPosition(NETINFO_ITEM self, wxPoint aPos)"""
        return _pcbnew.NETINFO_ITEM_SetPosition(self, aPos)

    def Clone(self) -> "EDA_ITEM *":
        r"""Clone(NETINFO_ITEM self) -> EDA_ITEM"""
        return _pcbnew.NETINFO_ITEM_Clone(self)

    def SetNetClass(self, aNetClass: "NETCLASSPTR const &") -> "void":
        r"""SetNetClass(NETINFO_ITEM self, NETCLASSPTR const & aNetClass)"""
        return _pcbnew.NETINFO_ITEM_SetNetClass(self, aNetClass)

    def GetNetClass(self) -> "NETCLASS *":
        r"""GetNetClass(NETINFO_ITEM self) -> NETCLASS *"""
        return _pcbnew.NETINFO_ITEM_GetNetClass(self)

    def GetNetClassName(self) -> "wxString":
        r"""GetNetClassName(NETINFO_ITEM self) -> wxString"""
        return _pcbnew.NETINFO_ITEM_GetNetClassName(self)

    def GetNetCode(self) -> "int":
        r"""GetNetCode(NETINFO_ITEM self) -> int"""
        return _pcbnew.NETINFO_ITEM_GetNetCode(self)

    def SetNetCode(self, aNetCode: "int") -> "void":
        r"""SetNetCode(NETINFO_ITEM self, int aNetCode)"""
        return _pcbnew.NETINFO_ITEM_SetNetCode(self, aNetCode)

    def GetNetname(self) -> "wxString const &":
        r"""GetNetname(NETINFO_ITEM self) -> wxString"""
        return _pcbnew.NETINFO_ITEM_GetNetname(self)

    def GetShortNetname(self) -> "wxString const &":
        r"""GetShortNetname(NETINFO_ITEM self) -> wxString"""
        return _pcbnew.NETINFO_ITEM_GetShortNetname(self)

    def SetNetname(self, aNewName: "wxString") -> "void":
        r"""SetNetname(NETINFO_ITEM self, wxString aNewName)"""
        return _pcbnew.NETINFO_ITEM_SetNetname(self, aNewName)

    def IsCurrent(self) -> "bool":
        r"""IsCurrent(NETINFO_ITEM self) -> bool"""
        return _pcbnew.NETINFO_ITEM_IsCurrent(self)

    def SetIsCurrent(self, isCurrent: "bool") -> "void":
        r"""SetIsCurrent(NETINFO_ITEM self, bool isCurrent)"""
        return _pcbnew.NETINFO_ITEM_SetIsCurrent(self, isCurrent)

    def GetMsgPanelInfo(self, aFrame: "EDA_DRAW_FRAME *", aList: "std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > &") -> "void":
        r"""GetMsgPanelInfo(NETINFO_ITEM self, EDA_DRAW_FRAME * aFrame, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.NETINFO_ITEM_GetMsgPanelInfo(self, aFrame, aList)

    def Clear(self) -> "void":
        r"""Clear(NETINFO_ITEM self)"""
        return _pcbnew.NETINFO_ITEM_Clear(self)

    def GetParent(self) -> "BOARD *":
        r"""GetParent(NETINFO_ITEM self) -> BOARD"""
        return _pcbnew.NETINFO_ITEM_GetParent(self)

# Register NETINFO_ITEM in _pcbnew:
_pcbnew.NETINFO_ITEM_swigregister(NETINFO_ITEM)

def NETINFO_ITEM_ClassOf(aItem: "EDA_ITEM") -> "bool":
    r"""NETINFO_ITEM_ClassOf(EDA_ITEM aItem) -> bool"""
    return _pcbnew.NETINFO_ITEM_ClassOf(aItem)

class NETNAMES_MAP(object):
    r"""Proxy of C++ std::map< wxString,NETINFO_ITEM * > 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) -> "swig::SwigPyIterator *":
        r"""iterator(NETNAMES_MAP self) -> SwigPyIterator"""
        return _pcbnew.NETNAMES_MAP_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(NETNAMES_MAP self) -> bool"""
        return _pcbnew.NETNAMES_MAP___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(NETNAMES_MAP self) -> bool"""
        return _pcbnew.NETNAMES_MAP___bool__(self)

    def __len__(self) -> "std::map< wxString,NETINFO_ITEM * >::size_type":
        r"""__len__(NETNAMES_MAP self) -> std::map< wxString,NETINFO_ITEM * >::size_type"""
        return _pcbnew.NETNAMES_MAP___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "wxString") -> "std::map< wxString,NETINFO_ITEM * >::mapped_type const &":
        r"""__getitem__(NETNAMES_MAP self, wxString key) -> NETINFO_ITEM"""
        return _pcbnew.NETNAMES_MAP___getitem__(self, key)

    def __delitem__(self, key: "wxString") -> "void":
        r"""__delitem__(NETNAMES_MAP self, wxString key)"""
        return _pcbnew.NETNAMES_MAP___delitem__(self, key)

    def has_key(self, key: "wxString") -> "bool":
        r"""has_key(NETNAMES_MAP self, wxString key) -> bool"""
        return _pcbnew.NETNAMES_MAP_has_key(self, key)

    def keys(self) -> "PyObject *":
        r"""keys(NETNAMES_MAP self) -> PyObject *"""
        return _pcbnew.NETNAMES_MAP_keys(self)

    def values(self) -> "PyObject *":
        r"""values(NETNAMES_MAP self) -> PyObject *"""
        return _pcbnew.NETNAMES_MAP_values(self)

    def items(self) -> "PyObject *":
        r"""items(NETNAMES_MAP self) -> PyObject *"""
        return _pcbnew.NETNAMES_MAP_items(self)

    def __contains__(self, key: "wxString") -> "bool":
        r"""__contains__(NETNAMES_MAP self, wxString key) -> bool"""
        return _pcbnew.NETNAMES_MAP___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        r"""key_iterator(NETNAMES_MAP self) -> SwigPyIterator"""
        return _pcbnew.NETNAMES_MAP_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        r"""value_iterator(NETNAMES_MAP self) -> SwigPyIterator"""
        return _pcbnew.NETNAMES_MAP_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(NETNAMES_MAP self, wxString key)
        __setitem__(NETNAMES_MAP self, wxString key, NETINFO_ITEM x)
        """
        return _pcbnew.NETNAMES_MAP___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        r"""asdict(NETNAMES_MAP self) -> PyObject *"""
        return _pcbnew.NETNAMES_MAP_asdict(self)

    def __init__(self, *args):
        r"""
        __init__(NETNAMES_MAP self, std::less< wxString > const & other) -> NETNAMES_MAP
        __init__(NETNAMES_MAP self) -> NETNAMES_MAP
        __init__(NETNAMES_MAP self, NETNAMES_MAP other) -> NETNAMES_MAP
        """
        _pcbnew.NETNAMES_MAP_swiginit(self, _pcbnew.new_NETNAMES_MAP(*args))

    def empty(self) -> "bool":
        r"""empty(NETNAMES_MAP self) -> bool"""
        return _pcbnew.NETNAMES_MAP_empty(self)

    def size(self) -> "std::map< wxString,NETINFO_ITEM * >::size_type":
        r"""size(NETNAMES_MAP self) -> std::map< wxString,NETINFO_ITEM * >::size_type"""
        return _pcbnew.NETNAMES_MAP_size(self)

    def swap(self, v: "NETNAMES_MAP") -> "void":
        r"""swap(NETNAMES_MAP self, NETNAMES_MAP v)"""
        return _pcbnew.NETNAMES_MAP_swap(self, v)

    def begin(self) -> "std::map< wxString,NETINFO_ITEM * >::iterator":
        r"""begin(NETNAMES_MAP self) -> std::map< wxString,NETINFO_ITEM * >::iterator"""
        return _pcbnew.NETNAMES_MAP_begin(self)

    def end(self) -> "std::map< wxString,NETINFO_ITEM * >::iterator":
        r"""end(NETNAMES_MAP self) -> std::map< wxString,NETINFO_ITEM * >::iterator"""
        return _pcbnew.NETNAMES_MAP_end(self)

    def rbegin(self) -> "std::map< wxString,NETINFO_ITEM * >::reverse_iterator":
        r"""rbegin(NETNAMES_MAP self) -> std::map< wxString,NETINFO_ITEM * >::reverse_iterator"""
        return _pcbnew.NETNAMES_MAP_rbegin(self)

    def rend(self) -> "std::map< wxString,NETINFO_ITEM * >::reverse_iterator":
        r"""rend(NETNAMES_MAP self) -> std::map< wxString,NETINFO_ITEM * >::reverse_iterator"""
        return _pcbnew.NETNAMES_MAP_rend(self)

    def clear(self) -> "void":
        r"""clear(NETNAMES_MAP self)"""
        return _pcbnew.NETNAMES_MAP_clear(self)

    def get_allocator(self) -> "std::map< wxString,NETINFO_ITEM * >::allocator_type":
        r"""get_allocator(NETNAMES_MAP self) -> std::map< wxString,NETINFO_ITEM * >::allocator_type"""
        return _pcbnew.NETNAMES_MAP_get_allocator(self)

    def count(self, x: "wxString") -> "std::map< wxString,NETINFO_ITEM * >::size_type":
        r"""count(NETNAMES_MAP self, wxString x) -> std::map< wxString,NETINFO_ITEM * >::size_type"""
        return _pcbnew.NETNAMES_MAP_count(self, x)

    def erase(self, *args) -> "void":
        r"""
        erase(NETNAMES_MAP self, wxString x) -> std::map< wxString,NETINFO_ITEM * >::size_type
        erase(NETNAMES_MAP self, std::map< wxString,NETINFO_ITEM * >::iterator position)
        erase(NETNAMES_MAP self, std::map< wxString,NETINFO_ITEM * >::iterator first, std::map< wxString,NETINFO_ITEM * >::iterator last)
        """
        return _pcbnew.NETNAMES_MAP_erase(self, *args)

    def find(self, x: "wxString") -> "std::map< wxString,NETINFO_ITEM * >::iterator":
        r"""find(NETNAMES_MAP self, wxString x) -> std::map< wxString,NETINFO_ITEM * >::iterator"""
        return _pcbnew.NETNAMES_MAP_find(self, x)

    def lower_bound(self, x: "wxString") -> "std::map< wxString,NETINFO_ITEM * >::iterator":
        r"""lower_bound(NETNAMES_MAP self, wxString x) -> std::map< wxString,NETINFO_ITEM * >::iterator"""
        return _pcbnew.NETNAMES_MAP_lower_bound(self, x)

    def upper_bound(self, x: "wxString") -> "std::map< wxString,NETINFO_ITEM * >::iterator":
        r"""upper_bound(NETNAMES_MAP self, wxString x) -> std::map< wxString,NETINFO_ITEM * >::iterator"""
        return _pcbnew.NETNAMES_MAP_upper_bound(self, x)
    __swig_destroy__ = _pcbnew.delete_NETNAMES_MAP

# Register NETNAMES_MAP in _pcbnew:
_pcbnew.NETNAMES_MAP_swigregister(NETNAMES_MAP)

class NETCODES_MAP(object):
    r"""Proxy of C++ std::map< int,NETINFO_ITEM * > 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) -> "swig::SwigPyIterator *":
        r"""iterator(NETCODES_MAP self) -> SwigPyIterator"""
        return _pcbnew.NETCODES_MAP_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(NETCODES_MAP self) -> bool"""
        return _pcbnew.NETCODES_MAP___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(NETCODES_MAP self) -> bool"""
        return _pcbnew.NETCODES_MAP___bool__(self)

    def __len__(self) -> "std::map< int,NETINFO_ITEM * >::size_type":
        r"""__len__(NETCODES_MAP self) -> std::map< int,NETINFO_ITEM * >::size_type"""
        return _pcbnew.NETCODES_MAP___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::map< int,NETINFO_ITEM * >::key_type const &") -> "std::map< int,NETINFO_ITEM * >::mapped_type const &":
        r"""__getitem__(NETCODES_MAP self, std::map< int,NETINFO_ITEM * >::key_type const & key) -> NETINFO_ITEM"""
        return _pcbnew.NETCODES_MAP___getitem__(self, key)

    def __delitem__(self, key: "std::map< int,NETINFO_ITEM * >::key_type const &") -> "void":
        r"""__delitem__(NETCODES_MAP self, std::map< int,NETINFO_ITEM * >::key_type const & key)"""
        return _pcbnew.NETCODES_MAP___delitem__(self, key)

    def has_key(self, key: "std::map< int,NETINFO_ITEM * >::key_type const &") -> "bool":
        r"""has_key(NETCODES_MAP self, std::map< int,NETINFO_ITEM * >::key_type const & key) -> bool"""
        return _pcbnew.NETCODES_MAP_has_key(self, key)

    def keys(self) -> "PyObject *":
        r"""keys(NETCODES_MAP self) -> PyObject *"""
        return _pcbnew.NETCODES_MAP_keys(self)

    def values(self) -> "PyObject *":
        r"""values(NETCODES_MAP self) -> PyObject *"""
        return _pcbnew.NETCODES_MAP_values(self)

    def items(self) -> "PyObject *":
        r"""items(NETCODES_MAP self) -> PyObject *"""
        return _pcbnew.NETCODES_MAP_items(self)

    def __contains__(self, key: "std::map< int,NETINFO_ITEM * >::key_type const &") -> "bool":
        r"""__contains__(NETCODES_MAP self, std::map< int,NETINFO_ITEM * >::key_type const & key) -> bool"""
        return _pcbnew.NETCODES_MAP___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        r"""key_iterator(NETCODES_MAP self) -> SwigPyIterator"""
        return _pcbnew.NETCODES_MAP_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        r"""value_iterator(NETCODES_MAP self) -> SwigPyIterator"""
        return _pcbnew.NETCODES_MAP_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(NETCODES_MAP self, std::map< int,NETINFO_ITEM * >::key_type const & key)
        __setitem__(NETCODES_MAP self, std::map< int,NETINFO_ITEM * >::key_type const & key, NETINFO_ITEM x)
        """
        return _pcbnew.NETCODES_MAP___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        r"""asdict(NETCODES_MAP self) -> PyObject *"""
        return _pcbnew.NETCODES_MAP_asdict(self)

    def __init__(self, *args):
        r"""
        __init__(NETCODES_MAP self, std::less< int > const & other) -> NETCODES_MAP
        __init__(NETCODES_MAP self) -> NETCODES_MAP
        __init__(NETCODES_MAP self, NETCODES_MAP other) -> NETCODES_MAP
        """
        _pcbnew.NETCODES_MAP_swiginit(self, _pcbnew.new_NETCODES_MAP(*args))

    def empty(self) -> "bool":
        r"""empty(NETCODES_MAP self) -> bool"""
        return _pcbnew.NETCODES_MAP_empty(self)

    def size(self) -> "std::map< int,NETINFO_ITEM * >::size_type":
        r"""size(NETCODES_MAP self) -> std::map< int,NETINFO_ITEM * >::size_type"""
        return _pcbnew.NETCODES_MAP_size(self)

    def swap(self, v: "NETCODES_MAP") -> "void":
        r"""swap(NETCODES_MAP self, NETCODES_MAP v)"""
        return _pcbnew.NETCODES_MAP_swap(self, v)

    def begin(self) -> "std::map< int,NETINFO_ITEM * >::iterator":
        r"""begin(NETCODES_MAP self) -> std::map< int,NETINFO_ITEM * >::iterator"""
        return _pcbnew.NETCODES_MAP_begin(self)

    def end(self) -> "std::map< int,NETINFO_ITEM * >::iterator":
        r"""end(NETCODES_MAP self) -> std::map< int,NETINFO_ITEM * >::iterator"""
        return _pcbnew.NETCODES_MAP_end(self)

    def rbegin(self) -> "std::map< int,NETINFO_ITEM * >::reverse_iterator":
        r"""rbegin(NETCODES_MAP self) -> std::map< int,NETINFO_ITEM * >::reverse_iterator"""
        return _pcbnew.NETCODES_MAP_rbegin(self)

    def rend(self) -> "std::map< int,NETINFO_ITEM * >::reverse_iterator":
        r"""rend(NETCODES_MAP self) -> std::map< int,NETINFO_ITEM * >::reverse_iterator"""
        return _pcbnew.NETCODES_MAP_rend(self)

    def clear(self) -> "void":
        r"""clear(NETCODES_MAP self)"""
        return _pcbnew.NETCODES_MAP_clear(self)

    def get_allocator(self) -> "std::map< int,NETINFO_ITEM * >::allocator_type":
        r"""get_allocator(NETCODES_MAP self) -> std::map< int,NETINFO_ITEM * >::allocator_type"""
        return _pcbnew.NETCODES_MAP_get_allocator(self)

    def count(self, x: "std::map< int,NETINFO_ITEM * >::key_type const &") -> "std::map< int,NETINFO_ITEM * >::size_type":
        r"""count(NETCODES_MAP self, std::map< int,NETINFO_ITEM * >::key_type const & x) -> std::map< int,NETINFO_ITEM * >::size_type"""
        return _pcbnew.NETCODES_MAP_count(self, x)

    def erase(self, *args) -> "void":
        r"""
        erase(NETCODES_MAP self, std::map< int,NETINFO_ITEM * >::key_type const & x) -> std::map< int,NETINFO_ITEM * >::size_type
        erase(NETCODES_MAP self, std::map< int,NETINFO_ITEM * >::iterator position)
        erase(NETCODES_MAP self, std::map< int,NETINFO_ITEM * >::iterator first, std::map< int,NETINFO_ITEM * >::iterator last)
        """
        return _pcbnew.NETCODES_MAP_erase(self, *args)

    def find(self, x: "std::map< int,NETINFO_ITEM * >::key_type const &") -> "std::map< int,NETINFO_ITEM * >::iterator":
        r"""find(NETCODES_MAP self, std::map< int,NETINFO_ITEM * >::key_type const & x) -> std::map< int,NETINFO_ITEM * >::iterator"""
        return _pcbnew.NETCODES_MAP_find(self, x)

    def lower_bound(self, x: "std::map< int,NETINFO_ITEM * >::key_type const &") -> "std::map< int,NETINFO_ITEM * >::iterator":
        r"""lower_bound(NETCODES_MAP self, std::map< int,NETINFO_ITEM * >::key_type const & x) -> std::map< int,NETINFO_ITEM * >::iterator"""
        return _pcbnew.NETCODES_MAP_lower_bound(self, x)

    def upper_bound(self, x: "std::map< int,NETINFO_ITEM * >::key_type const &") -> "std::map< int,NETINFO_ITEM * >::iterator":
        r"""upper_bound(NETCODES_MAP self, std::map< int,NETINFO_ITEM * >::key_type const & x) -> std::map< int,NETINFO_ITEM * >::iterator"""
        return _pcbnew.NETCODES_MAP_upper_bound(self, x)
    __swig_destroy__ = _pcbnew.delete_NETCODES_MAP

# Register NETCODES_MAP in _pcbnew:
_pcbnew.NETCODES_MAP_swigregister(NETCODES_MAP)

class NETINFO_LIST(object):
    r"""Proxy of C++ NETINFO_LIST 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, aParent: "BOARD"):
        r"""__init__(NETINFO_LIST self, BOARD aParent) -> NETINFO_LIST"""
        _pcbnew.NETINFO_LIST_swiginit(self, _pcbnew.new_NETINFO_LIST(aParent))
    __swig_destroy__ = _pcbnew.delete_NETINFO_LIST

    def GetNetItem(self, *args) -> "NETINFO_ITEM *":
        r"""
        GetNetItem(NETINFO_LIST self, int aNetCode) -> NETINFO_ITEM
        GetNetItem(NETINFO_LIST self, wxString aNetName) -> NETINFO_ITEM
        """
        return _pcbnew.NETINFO_LIST_GetNetItem(self, *args)

    def GetNetCount(self) -> "unsigned int":
        r"""GetNetCount(NETINFO_LIST self) -> unsigned int"""
        return _pcbnew.NETINFO_LIST_GetNetCount(self)

    def AppendNet(self, aNewElement: "NETINFO_ITEM") -> "void":
        r"""AppendNet(NETINFO_LIST self, NETINFO_ITEM aNewElement)"""
        return _pcbnew.NETINFO_LIST_AppendNet(self, aNewElement)

    def RemoveNet(self, aNet: "NETINFO_ITEM") -> "void":
        r"""RemoveNet(NETINFO_LIST self, NETINFO_ITEM aNet)"""
        return _pcbnew.NETINFO_LIST_RemoveNet(self, aNet)

    def RemoveUnusedNets(self) -> "void":
        r"""RemoveUnusedNets(NETINFO_LIST self)"""
        return _pcbnew.NETINFO_LIST_RemoveUnusedNets(self)

    def NetsByName(self) -> "NETNAMES_MAP const &":
        r"""NetsByName(NETINFO_LIST self) -> NETNAMES_MAP"""
        return _pcbnew.NETINFO_LIST_NetsByName(self)

    def NetsByNetcode(self) -> "NETCODES_MAP const &":
        r"""NetsByNetcode(NETINFO_LIST self) -> NETCODES_MAP"""
        return _pcbnew.NETINFO_LIST_NetsByNetcode(self)

    @staticmethod
    def OrphanedItem() -> "NETINFO_ITEM *":
        r"""OrphanedItem() -> NETINFO_ITEM"""
        return _pcbnew.NETINFO_LIST_OrphanedItem()

    def GetParent(self) -> "BOARD *":
        r"""GetParent(NETINFO_LIST self) -> BOARD"""
        return _pcbnew.NETINFO_LIST_GetParent(self)

# Register NETINFO_LIST in _pcbnew:
_pcbnew.NETINFO_LIST_swigregister(NETINFO_LIST)
NETINFO_LIST.UNCONNECTED = _pcbnew.cvar.NETINFO_LIST_UNCONNECTED
NETINFO_LIST.ORPHANED = _pcbnew.cvar.NETINFO_LIST_ORPHANED

def NETINFO_LIST_OrphanedItem() -> "NETINFO_ITEM *":
    r"""NETINFO_LIST_OrphanedItem() -> NETINFO_ITEM"""
    return _pcbnew.NETINFO_LIST_OrphanedItem()

class STRINGSET(object):
    r"""Proxy of C++ std::set< wxString > 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) -> "swig::SwigPyIterator *":
        r"""iterator(STRINGSET self) -> SwigPyIterator"""
        return _pcbnew.STRINGSET_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(STRINGSET self) -> bool"""
        return _pcbnew.STRINGSET___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(STRINGSET self) -> bool"""
        return _pcbnew.STRINGSET___bool__(self)

    def __len__(self) -> "std::set< wxString >::size_type":
        r"""__len__(STRINGSET self) -> std::set< wxString >::size_type"""
        return _pcbnew.STRINGSET___len__(self)

    def append(self, x: "wxString") -> "void":
        r"""append(STRINGSET self, wxString x)"""
        return _pcbnew.STRINGSET_append(self, x)

    def __contains__(self, x: "wxString") -> "bool":
        r"""__contains__(STRINGSET self, wxString x) -> bool"""
        return _pcbnew.STRINGSET___contains__(self, x)

    def __getitem__(self, i: "std::set< wxString >::difference_type") -> "std::set< wxString >::value_type":
        r"""__getitem__(STRINGSET self, std::set< wxString >::difference_type i) -> wxString"""
        return _pcbnew.STRINGSET___getitem__(self, i)

    def add(self, x: "wxString") -> "void":
        r"""add(STRINGSET self, wxString x)"""
        return _pcbnew.STRINGSET_add(self, x)

    def discard(self, x: "wxString") -> "void":
        r"""discard(STRINGSET self, wxString x)"""
        return _pcbnew.STRINGSET_discard(self, x)

    def __init__(self, *args):
        r"""
        __init__(STRINGSET self, std::less< wxString > const & other) -> STRINGSET
        __init__(STRINGSET self) -> STRINGSET
        __init__(STRINGSET self, STRINGSET other) -> STRINGSET
        """
        _pcbnew.STRINGSET_swiginit(self, _pcbnew.new_STRINGSET(*args))

    def empty(self) -> "bool":
        r"""empty(STRINGSET self) -> bool"""
        return _pcbnew.STRINGSET_empty(self)

    def size(self) -> "std::set< wxString >::size_type":
        r"""size(STRINGSET self) -> std::set< wxString >::size_type"""
        return _pcbnew.STRINGSET_size(self)

    def clear(self) -> "void":
        r"""clear(STRINGSET self)"""
        return _pcbnew.STRINGSET_clear(self)

    def swap(self, v: "STRINGSET") -> "void":
        r"""swap(STRINGSET self, STRINGSET v)"""
        return _pcbnew.STRINGSET_swap(self, v)

    def count(self, x: "wxString") -> "std::set< wxString >::size_type":
        r"""count(STRINGSET self, wxString x) -> std::set< wxString >::size_type"""
        return _pcbnew.STRINGSET_count(self, x)

    def begin(self) -> "std::set< wxString >::iterator":
        r"""begin(STRINGSET self) -> std::set< wxString >::iterator"""
        return _pcbnew.STRINGSET_begin(self)

    def end(self) -> "std::set< wxString >::iterator":
        r"""end(STRINGSET self) -> std::set< wxString >::iterator"""
        return _pcbnew.STRINGSET_end(self)

    def rbegin(self) -> "std::set< wxString >::reverse_iterator":
        r"""rbegin(STRINGSET self) -> std::set< wxString >::reverse_iterator"""
        return _pcbnew.STRINGSET_rbegin(self)

    def rend(self) -> "std::set< wxString >::reverse_iterator":
        r"""rend(STRINGSET self) -> std::set< wxString >::reverse_iterator"""
        return _pcbnew.STRINGSET_rend(self)

    def erase(self, *args) -> "void":
        r"""
        erase(STRINGSET self, wxString x) -> std::set< wxString >::size_type
        erase(STRINGSET self, std::set< wxString >::iterator pos)
        erase(STRINGSET self, std::set< wxString >::iterator first, std::set< wxString >::iterator last)
        """
        return _pcbnew.STRINGSET_erase(self, *args)

    def find(self, x: "wxString") -> "std::set< wxString >::iterator":
        r"""find(STRINGSET self, wxString x) -> std::set< wxString >::iterator"""
        return _pcbnew.STRINGSET_find(self, x)

    def lower_bound(self, x: "wxString") -> "std::set< wxString >::iterator":
        r"""lower_bound(STRINGSET self, wxString x) -> std::set< wxString >::iterator"""
        return _pcbnew.STRINGSET_lower_bound(self, x)

    def upper_bound(self, x: "wxString") -> "std::set< wxString >::iterator":
        r"""upper_bound(STRINGSET self, wxString x) -> std::set< wxString >::iterator"""
        return _pcbnew.STRINGSET_upper_bound(self, x)

    def equal_range(self, x: "wxString") -> "std::pair< std::set< wxString >::iterator,std::set< wxString >::iterator >":
        r"""equal_range(STRINGSET self, wxString x) -> std::pair< std::set< wxString >::iterator,std::set< wxString >::iterator >"""
        return _pcbnew.STRINGSET_equal_range(self, x)

    def insert(self, __x: "wxString") -> "std::pair< std::set< wxString >::iterator,bool >":
        r"""insert(STRINGSET self, wxString __x) -> std::pair< std::set< wxString >::iterator,bool >"""
        return _pcbnew.STRINGSET_insert(self, __x)
    __swig_destroy__ = _pcbnew.delete_STRINGSET

# Register STRINGSET in _pcbnew:
_pcbnew.STRINGSET_swigregister(STRINGSET)

class NETCLASSPTR(object):
    r"""Proxy of C++ std::shared_ptr< NETCLASS > 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: "string"):
        r"""__init__(NETCLASSPTR self, string name) -> NETCLASSPTR"""
        _pcbnew.NETCLASSPTR_swiginit(self, _pcbnew.new_NETCLASSPTR(name))

    def NetNames(self) -> "STRINGSET &":
        r"""NetNames(NETCLASSPTR self) -> STRINGSET"""
        return _pcbnew.NETCLASSPTR_NetNames(self)

    def GetName(self) -> "wxString const &":
        r"""GetName(NETCLASSPTR self) -> wxString"""
        return _pcbnew.NETCLASSPTR_GetName(self)

    def GetCount(self) -> "unsigned int":
        r"""GetCount(NETCLASSPTR self) -> unsigned int"""
        return _pcbnew.NETCLASSPTR_GetCount(self)

    def GetDescription(self) -> "wxString const &":
        r"""GetDescription(NETCLASSPTR self) -> wxString"""
        return _pcbnew.NETCLASSPTR_GetDescription(self)

    def SetDescription(self, aDesc: "wxString") -> "void":
        r"""SetDescription(NETCLASSPTR self, wxString aDesc)"""
        return _pcbnew.NETCLASSPTR_SetDescription(self, aDesc)

    def GetClearance(self) -> "int":
        r"""GetClearance(NETCLASSPTR self) -> int"""
        return _pcbnew.NETCLASSPTR_GetClearance(self)

    def SetClearance(self, aClearance: "int") -> "void":
        r"""SetClearance(NETCLASSPTR self, int aClearance)"""
        return _pcbnew.NETCLASSPTR_SetClearance(self, aClearance)

    def GetTrackWidth(self) -> "int":
        r"""GetTrackWidth(NETCLASSPTR self) -> int"""
        return _pcbnew.NETCLASSPTR_GetTrackWidth(self)

    def SetTrackWidth(self, aWidth: "int") -> "void":
        r"""SetTrackWidth(NETCLASSPTR self, int aWidth)"""
        return _pcbnew.NETCLASSPTR_SetTrackWidth(self, aWidth)

    def GetViaDiameter(self) -> "int":
        r"""GetViaDiameter(NETCLASSPTR self) -> int"""
        return _pcbnew.NETCLASSPTR_GetViaDiameter(self)

    def SetViaDiameter(self, aDia: "int") -> "void":
        r"""SetViaDiameter(NETCLASSPTR self, int aDia)"""
        return _pcbnew.NETCLASSPTR_SetViaDiameter(self, aDia)

    def GetViaDrill(self) -> "int":
        r"""GetViaDrill(NETCLASSPTR self) -> int"""
        return _pcbnew.NETCLASSPTR_GetViaDrill(self)

    def SetViaDrill(self, aSize: "int") -> "void":
        r"""SetViaDrill(NETCLASSPTR self, int aSize)"""
        return _pcbnew.NETCLASSPTR_SetViaDrill(self, aSize)

    def GetuViaDiameter(self) -> "int":
        r"""GetuViaDiameter(NETCLASSPTR self) -> int"""
        return _pcbnew.NETCLASSPTR_GetuViaDiameter(self)

    def SetuViaDiameter(self, aSize: "int") -> "void":
        r"""SetuViaDiameter(NETCLASSPTR self, int aSize)"""
        return _pcbnew.NETCLASSPTR_SetuViaDiameter(self, aSize)

    def GetuViaDrill(self) -> "int":
        r"""GetuViaDrill(NETCLASSPTR self) -> int"""
        return _pcbnew.NETCLASSPTR_GetuViaDrill(self)

    def SetuViaDrill(self, aSize: "int") -> "void":
        r"""SetuViaDrill(NETCLASSPTR self, int aSize)"""
        return _pcbnew.NETCLASSPTR_SetuViaDrill(self, aSize)

    def GetDiffPairWidth(self) -> "int":
        r"""GetDiffPairWidth(NETCLASSPTR self) -> int"""
        return _pcbnew.NETCLASSPTR_GetDiffPairWidth(self)

    def SetDiffPairWidth(self, aSize: "int") -> "void":
        r"""SetDiffPairWidth(NETCLASSPTR self, int aSize)"""
        return _pcbnew.NETCLASSPTR_SetDiffPairWidth(self, aSize)

    def GetDiffPairGap(self) -> "int":
        r"""GetDiffPairGap(NETCLASSPTR self) -> int"""
        return _pcbnew.NETCLASSPTR_GetDiffPairGap(self)

    def SetDiffPairGap(self, aSize: "int") -> "void":
        r"""SetDiffPairGap(NETCLASSPTR self, int aSize)"""
        return _pcbnew.NETCLASSPTR_SetDiffPairGap(self, aSize)
    __swig_destroy__ = _pcbnew.delete_NETCLASSPTR

# Register NETCLASSPTR in _pcbnew:
_pcbnew.NETCLASSPTR_swigregister(NETCLASSPTR)

class NETCLASS_MAP(object):
    r"""Proxy of C++ std::map< wxString,NETCLASSPTR > 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) -> "swig::SwigPyIterator *":
        r"""iterator(NETCLASS_MAP self) -> SwigPyIterator"""
        return _pcbnew.NETCLASS_MAP_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(NETCLASS_MAP self) -> bool"""
        return _pcbnew.NETCLASS_MAP___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(NETCLASS_MAP self) -> bool"""
        return _pcbnew.NETCLASS_MAP___bool__(self)

    def __len__(self) -> "std::map< wxString,std::shared_ptr< NETCLASS > >::size_type":
        r"""__len__(NETCLASS_MAP self) -> std::map< wxString,std::shared_ptr< NETCLASS > >::size_type"""
        return _pcbnew.NETCLASS_MAP___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "wxString") -> "std::map< wxString,std::shared_ptr< NETCLASS > >::mapped_type const &":
        r"""__getitem__(NETCLASS_MAP self, wxString key) -> std::map< wxString,std::shared_ptr< NETCLASS > >::mapped_type const &"""
        return _pcbnew.NETCLASS_MAP___getitem__(self, key)

    def __delitem__(self, key: "wxString") -> "void":
        r"""__delitem__(NETCLASS_MAP self, wxString key)"""
        return _pcbnew.NETCLASS_MAP___delitem__(self, key)

    def has_key(self, key: "wxString") -> "bool":
        r"""has_key(NETCLASS_MAP self, wxString key) -> bool"""
        return _pcbnew.NETCLASS_MAP_has_key(self, key)

    def keys(self) -> "PyObject *":
        r"""keys(NETCLASS_MAP self) -> PyObject *"""
        return _pcbnew.NETCLASS_MAP_keys(self)

    def values(self) -> "PyObject *":
        r"""values(NETCLASS_MAP self) -> PyObject *"""
        return _pcbnew.NETCLASS_MAP_values(self)

    def items(self) -> "PyObject *":
        r"""items(NETCLASS_MAP self) -> PyObject *"""
        return _pcbnew.NETCLASS_MAP_items(self)

    def __contains__(self, key: "wxString") -> "bool":
        r"""__contains__(NETCLASS_MAP self, wxString key) -> bool"""
        return _pcbnew.NETCLASS_MAP___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        r"""key_iterator(NETCLASS_MAP self) -> SwigPyIterator"""
        return _pcbnew.NETCLASS_MAP_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        r"""value_iterator(NETCLASS_MAP self) -> SwigPyIterator"""
        return _pcbnew.NETCLASS_MAP_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(NETCLASS_MAP self, wxString key)
        __setitem__(NETCLASS_MAP self, wxString key, std::map< wxString,std::shared_ptr< NETCLASS > >::mapped_type const & x)
        """
        return _pcbnew.NETCLASS_MAP___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        r"""asdict(NETCLASS_MAP self) -> PyObject *"""
        return _pcbnew.NETCLASS_MAP_asdict(self)

    def __init__(self, *args):
        r"""
        __init__(NETCLASS_MAP self, std::less< wxString > const & other) -> NETCLASS_MAP
        __init__(NETCLASS_MAP self) -> NETCLASS_MAP
        __init__(NETCLASS_MAP self, NETCLASS_MAP other) -> NETCLASS_MAP
        """
        _pcbnew.NETCLASS_MAP_swiginit(self, _pcbnew.new_NETCLASS_MAP(*args))

    def empty(self) -> "bool":
        r"""empty(NETCLASS_MAP self) -> bool"""
        return _pcbnew.NETCLASS_MAP_empty(self)

    def size(self) -> "std::map< wxString,std::shared_ptr< NETCLASS > >::size_type":
        r"""size(NETCLASS_MAP self) -> std::map< wxString,std::shared_ptr< NETCLASS > >::size_type"""
        return _pcbnew.NETCLASS_MAP_size(self)

    def swap(self, v: "NETCLASS_MAP") -> "void":
        r"""swap(NETCLASS_MAP self, NETCLASS_MAP v)"""
        return _pcbnew.NETCLASS_MAP_swap(self, v)

    def begin(self) -> "std::map< wxString,std::shared_ptr< NETCLASS > >::iterator":
        r"""begin(NETCLASS_MAP self) -> std::map< wxString,std::shared_ptr< NETCLASS > >::iterator"""
        return _pcbnew.NETCLASS_MAP_begin(self)

    def end(self) -> "std::map< wxString,std::shared_ptr< NETCLASS > >::iterator":
        r"""end(NETCLASS_MAP self) -> std::map< wxString,std::shared_ptr< NETCLASS > >::iterator"""
        return _pcbnew.NETCLASS_MAP_end(self)

    def rbegin(self) -> "std::map< wxString,std::shared_ptr< NETCLASS > >::reverse_iterator":
        r"""rbegin(NETCLASS_MAP self) -> std::map< wxString,std::shared_ptr< NETCLASS > >::reverse_iterator"""
        return _pcbnew.NETCLASS_MAP_rbegin(self)

    def rend(self) -> "std::map< wxString,std::shared_ptr< NETCLASS > >::reverse_iterator":
        r"""rend(NETCLASS_MAP self) -> std::map< wxString,std::shared_ptr< NETCLASS > >::reverse_iterator"""
        return _pcbnew.NETCLASS_MAP_rend(self)

    def clear(self) -> "void":
        r"""clear(NETCLASS_MAP self)"""
        return _pcbnew.NETCLASS_MAP_clear(self)

    def get_allocator(self) -> "std::map< wxString,std::shared_ptr< NETCLASS > >::allocator_type":
        r"""get_allocator(NETCLASS_MAP self) -> std::map< wxString,std::shared_ptr< NETCLASS > >::allocator_type"""
        return _pcbnew.NETCLASS_MAP_get_allocator(self)

    def count(self, x: "wxString") -> "std::map< wxString,std::shared_ptr< NETCLASS > >::size_type":
        r"""count(NETCLASS_MAP self, wxString x) -> std::map< wxString,std::shared_ptr< NETCLASS > >::size_type"""
        return _pcbnew.NETCLASS_MAP_count(self, x)

    def erase(self, *args) -> "void":
        r"""
        erase(NETCLASS_MAP self, wxString x) -> std::map< wxString,std::shared_ptr< NETCLASS > >::size_type
        erase(NETCLASS_MAP self, std::map< wxString,std::shared_ptr< NETCLASS > >::iterator position)
        erase(NETCLASS_MAP self, std::map< wxString,std::shared_ptr< NETCLASS > >::iterator first, std::map< wxString,std::shared_ptr< NETCLASS > >::iterator last)
        """
        return _pcbnew.NETCLASS_MAP_erase(self, *args)

    def find(self, x: "wxString") -> "std::map< wxString,std::shared_ptr< NETCLASS > >::iterator":
        r"""find(NETCLASS_MAP self, wxString x) -> std::map< wxString,std::shared_ptr< NETCLASS > >::iterator"""
        return _pcbnew.NETCLASS_MAP_find(self, x)

    def lower_bound(self, x: "wxString") -> "std::map< wxString,std::shared_ptr< NETCLASS > >::iterator":
        r"""lower_bound(NETCLASS_MAP self, wxString x) -> std::map< wxString,std::shared_ptr< NETCLASS > >::iterator"""
        return _pcbnew.NETCLASS_MAP_lower_bound(self, x)

    def upper_bound(self, x: "wxString") -> "std::map< wxString,std::shared_ptr< NETCLASS > >::iterator":
        r"""upper_bound(NETCLASS_MAP self, wxString x) -> std::map< wxString,std::shared_ptr< NETCLASS > >::iterator"""
        return _pcbnew.NETCLASS_MAP_upper_bound(self, x)
    __swig_destroy__ = _pcbnew.delete_NETCLASS_MAP

# Register NETCLASS_MAP in _pcbnew:
_pcbnew.NETCLASS_MAP_swigregister(NETCLASS_MAP)

class NETCLASSES(object):
    r"""Proxy of C++ NETCLASSES 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__(NETCLASSES self) -> NETCLASSES"""
        _pcbnew.NETCLASSES_swiginit(self, _pcbnew.new_NETCLASSES())
    __swig_destroy__ = _pcbnew.delete_NETCLASSES

    def Clear(self) -> "void":
        r"""Clear(NETCLASSES self)"""
        return _pcbnew.NETCLASSES_Clear(self)

    def begin(self, *args) -> "NETCLASSES::const_iterator":
        r"""
        begin(NETCLASSES self) -> NETCLASSES::iterator
        begin(NETCLASSES self) -> NETCLASSES::const_iterator
        """
        return _pcbnew.NETCLASSES_begin(self, *args)

    def end(self, *args) -> "NETCLASSES::const_iterator":
        r"""
        end(NETCLASSES self) -> NETCLASSES::iterator
        end(NETCLASSES self) -> NETCLASSES::const_iterator
        """
        return _pcbnew.NETCLASSES_end(self, *args)

    def GetCount(self) -> "unsigned int":
        r"""GetCount(NETCLASSES self) -> unsigned int"""
        return _pcbnew.NETCLASSES_GetCount(self)

    def GetDefault(self) -> "NETCLASSPTR":
        r"""GetDefault(NETCLASSES self) -> NETCLASSPTR"""
        return _pcbnew.NETCLASSES_GetDefault(self)

    def GetDefaultPtr(self) -> "NETCLASS *":
        r"""GetDefaultPtr(NETCLASSES self) -> NETCLASS *"""
        return _pcbnew.NETCLASSES_GetDefaultPtr(self)

    def Add(self, aNetclass: "NETCLASSPTR const &") -> "bool":
        r"""Add(NETCLASSES self, NETCLASSPTR const & aNetclass) -> bool"""
        return _pcbnew.NETCLASSES_Add(self, aNetclass)

    def Remove(self, aNetName: "wxString") -> "NETCLASSPTR":
        r"""Remove(NETCLASSES self, wxString aNetName) -> NETCLASSPTR"""
        return _pcbnew.NETCLASSES_Remove(self, aNetName)

    def Find(self, aName: "wxString") -> "NETCLASSPTR":
        r"""Find(NETCLASSES self, wxString aName) -> NETCLASSPTR"""
        return _pcbnew.NETCLASSES_Find(self, aName)

    def NetClasses(self) -> "NETCLASS_MAP &":
        r"""NetClasses(NETCLASSES self) -> NETCLASS_MAP"""
        return _pcbnew.NETCLASSES_NetClasses(self)

# Register NETCLASSES in _pcbnew:
_pcbnew.NETCLASSES_swigregister(NETCLASSES)

class PCB_GROUP(BOARD_ITEM):
    r"""Proxy of C++ PCB_GROUP 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, aParent: "BOARD_ITEM"):
        r"""__init__(PCB_GROUP self, BOARD_ITEM aParent) -> PCB_GROUP"""
        _pcbnew.PCB_GROUP_swiginit(self, _pcbnew.new_PCB_GROUP(aParent))

    @staticmethod
    def ClassOf(aItem: "EDA_ITEM") -> "bool":
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.PCB_GROUP_ClassOf(aItem)

    def GetClass(self) -> "wxString":
        r"""GetClass(PCB_GROUP self) -> wxString"""
        return _pcbnew.PCB_GROUP_GetClass(self)

    def GetName(self) -> "wxString":
        r"""GetName(PCB_GROUP self) -> wxString"""
        return _pcbnew.PCB_GROUP_GetName(self)

    def SetName(self, aName: "wxString") -> "void":
        r"""SetName(PCB_GROUP self, wxString aName)"""
        return _pcbnew.PCB_GROUP_SetName(self, aName)

    def GetItems(self, *args) -> "std::unordered_set< BOARD_ITEM * > const &":
        r"""
        GetItems(PCB_GROUP self) -> std::unordered_set< BOARD_ITEM * >
        GetItems(PCB_GROUP self) -> std::unordered_set< BOARD_ITEM * > const &
        """
        return _pcbnew.PCB_GROUP_GetItems(self, *args)

    def AddItem(self, aItem: "BOARD_ITEM") -> "bool":
        r"""AddItem(PCB_GROUP self, BOARD_ITEM aItem) -> bool"""
        return _pcbnew.PCB_GROUP_AddItem(self, aItem)

    def RemoveItem(self, aItem: "BOARD_ITEM") -> "bool":
        r"""RemoveItem(PCB_GROUP self, BOARD_ITEM aItem) -> bool"""
        return _pcbnew.PCB_GROUP_RemoveItem(self, aItem)

    def RemoveAll(self) -> "void":
        r"""RemoveAll(PCB_GROUP self)"""
        return _pcbnew.PCB_GROUP_RemoveAll(self)

    @staticmethod
    def TopLevelGroup(aItem: "BOARD_ITEM", aScope: "PCB_GROUP", isFootprintEditor: "bool") -> "PCB_GROUP *":
        r"""TopLevelGroup(BOARD_ITEM aItem, PCB_GROUP aScope, bool isFootprintEditor) -> PCB_GROUP"""
        return _pcbnew.PCB_GROUP_TopLevelGroup(aItem, aScope, isFootprintEditor)

    @staticmethod
    def WithinScope(aItem: "BOARD_ITEM", aScope: "PCB_GROUP", isFootprintEditor: "bool") -> "bool":
        r"""WithinScope(BOARD_ITEM aItem, PCB_GROUP aScope, bool isFootprintEditor) -> bool"""
        return _pcbnew.PCB_GROUP_WithinScope(aItem, aScope, isFootprintEditor)

    def GetPosition(self) -> "wxPoint":
        r"""GetPosition(PCB_GROUP self) -> wxPoint"""
        return _pcbnew.PCB_GROUP_GetPosition(self)

    def SetPosition(self, aNewpos: "wxPoint") -> "void":
        r"""SetPosition(PCB_GROUP self, wxPoint aNewpos)"""
        return _pcbnew.PCB_GROUP_SetPosition(self, aNewpos)

    def GetLayerSet(self) -> "LSET":
        r"""GetLayerSet(PCB_GROUP self) -> LSET"""
        return _pcbnew.PCB_GROUP_GetLayerSet(self)

    def SetLayer(self, aLayer: "PCB_LAYER_ID") -> "void":
        r"""SetLayer(PCB_GROUP self, PCB_LAYER_ID aLayer)"""
        return _pcbnew.PCB_GROUP_SetLayer(self, aLayer)

    def SetLayerRecursive(self, aLayer: "PCB_LAYER_ID", aDepth: "int") -> "void":
        r"""SetLayerRecursive(PCB_GROUP self, PCB_LAYER_ID aLayer, int aDepth)"""
        return _pcbnew.PCB_GROUP_SetLayerRecursive(self, aLayer, aDepth)

    def SetLocked(self, aLocked: "bool") -> "void":
        r"""SetLocked(PCB_GROUP self, bool aLocked)"""
        return _pcbnew.PCB_GROUP_SetLocked(self, aLocked)

    def Clone(self) -> "EDA_ITEM *":
        r"""Clone(PCB_GROUP self) -> EDA_ITEM"""
        return _pcbnew.PCB_GROUP_Clone(self)

    def DeepClone(self) -> "PCB_GROUP *":
        r"""DeepClone(PCB_GROUP self) -> PCB_GROUP"""
        return _pcbnew.PCB_GROUP_DeepClone(self)

    def DeepDuplicate(self) -> "PCB_GROUP *":
        r"""DeepDuplicate(PCB_GROUP self) -> PCB_GROUP"""
        return _pcbnew.PCB_GROUP_DeepDuplicate(self)

    def SwapData(self, aImage: "BOARD_ITEM") -> "void":
        r"""SwapData(PCB_GROUP self, BOARD_ITEM aImage)"""
        return _pcbnew.PCB_GROUP_SwapData(self, aImage)

    def IsOnLayer(self, aLayer: "PCB_LAYER_ID") -> "bool":
        r"""IsOnLayer(PCB_GROUP self, PCB_LAYER_ID aLayer) -> bool"""
        return _pcbnew.PCB_GROUP_IsOnLayer(self, aLayer)

    def HitTest(self, *args) -> "bool":
        r"""
        HitTest(PCB_GROUP self, wxPoint aPosition, int aAccuracy=0) -> bool
        HitTest(PCB_GROUP self, EDA_RECT aRect, bool aContained, int aAccuracy=0) -> bool
        """
        return _pcbnew.PCB_GROUP_HitTest(self, *args)

    def GetBoundingBox(self) -> "EDA_RECT const":
        r"""GetBoundingBox(PCB_GROUP self) -> EDA_RECT"""
        return _pcbnew.PCB_GROUP_GetBoundingBox(self)

    def Visit(self, aInspector: "INSPECTOR", aTestData: "void *", aScanTypes: "KICAD_T const []") -> "SEARCH_RESULT":
        r"""Visit(PCB_GROUP self, INSPECTOR aInspector, void * aTestData, KICAD_T const [] aScanTypes) -> SEARCH_RESULT"""
        return _pcbnew.PCB_GROUP_Visit(self, aInspector, aTestData, aScanTypes)

    def ViewGetLayers(self, aLayers: "int []", aCount: "int &") -> "void":
        r"""ViewGetLayers(PCB_GROUP self, int [] aLayers, int & aCount)"""
        return _pcbnew.PCB_GROUP_ViewGetLayers(self, aLayers, aCount)

    def ViewGetLOD(self, aLayer: "int", aView: "KIGFX::VIEW *") -> "double":
        r"""ViewGetLOD(PCB_GROUP self, int aLayer, KIGFX::VIEW * aView) -> double"""
        return _pcbnew.PCB_GROUP_ViewGetLOD(self, aLayer, aView)

    def Move(self, aMoveVector: "wxPoint") -> "void":
        r"""Move(PCB_GROUP self, wxPoint aMoveVector)"""
        return _pcbnew.PCB_GROUP_Move(self, aMoveVector)

    def Rotate(self, aRotCentre: "wxPoint", aAngle: "double") -> "void":
        r"""Rotate(PCB_GROUP self, wxPoint aRotCentre, double aAngle)"""
        return _pcbnew.PCB_GROUP_Rotate(self, aRotCentre, aAngle)

    def Flip(self, aCentre: "wxPoint", aFlipLeftRight: "bool") -> "void":
        r"""Flip(PCB_GROUP self, wxPoint aCentre, bool aFlipLeftRight)"""
        return _pcbnew.PCB_GROUP_Flip(self, aCentre, aFlipLeftRight)

    def GetSelectMenuText(self, aUnits: "EDA_UNITS") -> "wxString":
        r"""GetSelectMenuText(PCB_GROUP self, EDA_UNITS aUnits) -> wxString"""
        return _pcbnew.PCB_GROUP_GetSelectMenuText(self, aUnits)

    def GetMenuImage(self) -> "BITMAPS":
        r"""GetMenuImage(PCB_GROUP self) -> BITMAPS"""
        return _pcbnew.PCB_GROUP_GetMenuImage(self)

    def AddChildrenToCommit(self, aCommit: "BOARD_COMMIT &") -> "void":
        r"""AddChildrenToCommit(PCB_GROUP self, BOARD_COMMIT & aCommit)"""
        return _pcbnew.PCB_GROUP_AddChildrenToCommit(self, aCommit)

    def GetMsgPanelInfo(self, aFrame: "EDA_DRAW_FRAME *", aList: "std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > &") -> "void":
        r"""GetMsgPanelInfo(PCB_GROUP self, EDA_DRAW_FRAME * aFrame, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.PCB_GROUP_GetMsgPanelInfo(self, aFrame, aList)

    def RunOnChildren(self, aFunction: "std::function< void (BOARD_ITEM *) > const &") -> "void":
        r"""RunOnChildren(PCB_GROUP self, std::function< void (BOARD_ITEM *) > const & aFunction)"""
        return _pcbnew.PCB_GROUP_RunOnChildren(self, aFunction)

    def RunOnDescendants(self, aFunction: "std::function< void (BOARD_ITEM *) > const &") -> "void":
        r"""RunOnDescendants(PCB_GROUP self, std::function< void (BOARD_ITEM *) > const & aFunction)"""
        return _pcbnew.PCB_GROUP_RunOnDescendants(self, aFunction)
    __swig_destroy__ = _pcbnew.delete_PCB_GROUP

# Register PCB_GROUP in _pcbnew:
_pcbnew.PCB_GROUP_swigregister(PCB_GROUP)

def PCB_GROUP_ClassOf(aItem: "EDA_ITEM") -> "bool":
    r"""PCB_GROUP_ClassOf(EDA_ITEM aItem) -> bool"""
    return _pcbnew.PCB_GROUP_ClassOf(aItem)

def PCB_GROUP_TopLevelGroup(aItem: "BOARD_ITEM", aScope: "PCB_GROUP", isFootprintEditor: "bool") -> "PCB_GROUP *":
    r"""PCB_GROUP_TopLevelGroup(BOARD_ITEM aItem, PCB_GROUP aScope, bool isFootprintEditor) -> PCB_GROUP"""
    return _pcbnew.PCB_GROUP_TopLevelGroup(aItem, aScope, isFootprintEditor)

def PCB_GROUP_WithinScope(aItem: "BOARD_ITEM", aScope: "PCB_GROUP", isFootprintEditor: "bool") -> "bool":
    r"""PCB_GROUP_WithinScope(BOARD_ITEM aItem, PCB_GROUP aScope, bool isFootprintEditor) -> bool"""
    return _pcbnew.PCB_GROUP_WithinScope(aItem, aScope, isFootprintEditor)

class VIA_DIMENSION_Vector(object):
    r"""Proxy of C++ std::vector< VIA_DIMENSION > 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) -> "swig::SwigPyIterator *":
        r"""iterator(VIA_DIMENSION_Vector self) -> SwigPyIterator"""
        return _pcbnew.VIA_DIMENSION_Vector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(VIA_DIMENSION_Vector self) -> bool"""
        return _pcbnew.VIA_DIMENSION_Vector___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(VIA_DIMENSION_Vector self) -> bool"""
        return _pcbnew.VIA_DIMENSION_Vector___bool__(self)

    def __len__(self) -> "std::vector< VIA_DIMENSION >::size_type":
        r"""__len__(VIA_DIMENSION_Vector self) -> std::vector< VIA_DIMENSION >::size_type"""
        return _pcbnew.VIA_DIMENSION_Vector___len__(self)

    def __getslice__(self, i: "std::vector< VIA_DIMENSION >::difference_type", j: "std::vector< VIA_DIMENSION >::difference_type") -> "std::vector< VIA_DIMENSION,std::allocator< VIA_DIMENSION > > *":
        r"""__getslice__(VIA_DIMENSION_Vector self, std::vector< VIA_DIMENSION >::difference_type i, std::vector< VIA_DIMENSION >::difference_type j) -> VIA_DIMENSION_Vector"""
        return _pcbnew.VIA_DIMENSION_Vector___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        r"""
        __setslice__(VIA_DIMENSION_Vector self, std::vector< VIA_DIMENSION >::difference_type i, std::vector< VIA_DIMENSION >::difference_type j)
        __setslice__(VIA_DIMENSION_Vector self, std::vector< VIA_DIMENSION >::difference_type i, std::vector< VIA_DIMENSION >::difference_type j, VIA_DIMENSION_Vector v)
        """
        return _pcbnew.VIA_DIMENSION_Vector___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< VIA_DIMENSION >::difference_type", j: "std::vector< VIA_DIMENSION >::difference_type") -> "void":
        r"""__delslice__(VIA_DIMENSION_Vector self, std::vector< VIA_DIMENSION >::difference_type i, std::vector< VIA_DIMENSION >::difference_type j)"""
        return _pcbnew.VIA_DIMENSION_Vector___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        r"""
        __delitem__(VIA_DIMENSION_Vector self, std::vector< VIA_DIMENSION >::difference_type i)
        __delitem__(VIA_DIMENSION_Vector self, PySliceObject * slice)
        """
        return _pcbnew.VIA_DIMENSION_Vector___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< VIA_DIMENSION >::value_type const &":
        r"""
        __getitem__(VIA_DIMENSION_Vector self, PySliceObject * slice) -> VIA_DIMENSION_Vector
        __getitem__(VIA_DIMENSION_Vector self, std::vector< VIA_DIMENSION >::difference_type i) -> VIA_DIMENSION
        """
        return _pcbnew.VIA_DIMENSION_Vector___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(VIA_DIMENSION_Vector self, PySliceObject * slice, VIA_DIMENSION_Vector v)
        __setitem__(VIA_DIMENSION_Vector self, PySliceObject * slice)
        __setitem__(VIA_DIMENSION_Vector self, std::vector< VIA_DIMENSION >::difference_type i, VIA_DIMENSION x)
        """
        return _pcbnew.VIA_DIMENSION_Vector___setitem__(self, *args)

    def pop(self) -> "std::vector< VIA_DIMENSION >::value_type":
        r"""pop(VIA_DIMENSION_Vector self) -> VIA_DIMENSION"""
        return _pcbnew.VIA_DIMENSION_Vector_pop(self)

    def append(self, x: "VIA_DIMENSION") -> "void":
        r"""append(VIA_DIMENSION_Vector self, VIA_DIMENSION x)"""
        return _pcbnew.VIA_DIMENSION_Vector_append(self, x)

    def empty(self) -> "bool":
        r"""empty(VIA_DIMENSION_Vector self) -> bool"""
        return _pcbnew.VIA_DIMENSION_Vector_empty(self)

    def size(self) -> "std::vector< VIA_DIMENSION >::size_type":
        r"""size(VIA_DIMENSION_Vector self) -> std::vector< VIA_DIMENSION >::size_type"""
        return _pcbnew.VIA_DIMENSION_Vector_size(self)

    def swap(self, v: "VIA_DIMENSION_Vector") -> "void":
        r"""swap(VIA_DIMENSION_Vector self, VIA_DIMENSION_Vector v)"""
        return _pcbnew.VIA_DIMENSION_Vector_swap(self, v)

    def begin(self) -> "std::vector< VIA_DIMENSION >::iterator":
        r"""begin(VIA_DIMENSION_Vector self) -> std::vector< VIA_DIMENSION >::iterator"""
        return _pcbnew.VIA_DIMENSION_Vector_begin(self)

    def end(self) -> "std::vector< VIA_DIMENSION >::iterator":
        r"""end(VIA_DIMENSION_Vector self) -> std::vector< VIA_DIMENSION >::iterator"""
        return _pcbnew.VIA_DIMENSION_Vector_end(self)

    def rbegin(self) -> "std::vector< VIA_DIMENSION >::reverse_iterator":
        r"""rbegin(VIA_DIMENSION_Vector self) -> std::vector< VIA_DIMENSION >::reverse_iterator"""
        return _pcbnew.VIA_DIMENSION_Vector_rbegin(self)

    def rend(self) -> "std::vector< VIA_DIMENSION >::reverse_iterator":
        r"""rend(VIA_DIMENSION_Vector self) -> std::vector< VIA_DIMENSION >::reverse_iterator"""
        return _pcbnew.VIA_DIMENSION_Vector_rend(self)

    def clear(self) -> "void":
        r"""clear(VIA_DIMENSION_Vector self)"""
        return _pcbnew.VIA_DIMENSION_Vector_clear(self)

    def get_allocator(self) -> "std::vector< VIA_DIMENSION >::allocator_type":
        r"""get_allocator(VIA_DIMENSION_Vector self) -> std::vector< VIA_DIMENSION >::allocator_type"""
        return _pcbnew.VIA_DIMENSION_Vector_get_allocator(self)

    def pop_back(self) -> "void":
        r"""pop_back(VIA_DIMENSION_Vector self)"""
        return _pcbnew.VIA_DIMENSION_Vector_pop_back(self)

    def erase(self, *args) -> "std::vector< VIA_DIMENSION >::iterator":
        r"""
        erase(VIA_DIMENSION_Vector self, std::vector< VIA_DIMENSION >::iterator pos) -> std::vector< VIA_DIMENSION >::iterator
        erase(VIA_DIMENSION_Vector self, std::vector< VIA_DIMENSION >::iterator first, std::vector< VIA_DIMENSION >::iterator last) -> std::vector< VIA_DIMENSION >::iterator
        """
        return _pcbnew.VIA_DIMENSION_Vector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(VIA_DIMENSION_Vector self) -> VIA_DIMENSION_Vector
        __init__(VIA_DIMENSION_Vector self, VIA_DIMENSION_Vector other) -> VIA_DIMENSION_Vector
        __init__(VIA_DIMENSION_Vector self, std::vector< VIA_DIMENSION >::size_type size) -> VIA_DIMENSION_Vector
        __init__(VIA_DIMENSION_Vector self, std::vector< VIA_DIMENSION >::size_type size, VIA_DIMENSION value) -> VIA_DIMENSION_Vector
        """
        _pcbnew.VIA_DIMENSION_Vector_swiginit(self, _pcbnew.new_VIA_DIMENSION_Vector(*args))

    def push_back(self, x: "VIA_DIMENSION") -> "void":
        r"""push_back(VIA_DIMENSION_Vector self, VIA_DIMENSION x)"""
        return _pcbnew.VIA_DIMENSION_Vector_push_back(self, x)

    def front(self) -> "std::vector< VIA_DIMENSION >::value_type const &":
        r"""front(VIA_DIMENSION_Vector self) -> VIA_DIMENSION"""
        return _pcbnew.VIA_DIMENSION_Vector_front(self)

    def back(self) -> "std::vector< VIA_DIMENSION >::value_type const &":
        r"""back(VIA_DIMENSION_Vector self) -> VIA_DIMENSION"""
        return _pcbnew.VIA_DIMENSION_Vector_back(self)

    def assign(self, n: "std::vector< VIA_DIMENSION >::size_type", x: "VIA_DIMENSION") -> "void":
        r"""assign(VIA_DIMENSION_Vector self, std::vector< VIA_DIMENSION >::size_type n, VIA_DIMENSION x)"""
        return _pcbnew.VIA_DIMENSION_Vector_assign(self, n, x)

    def resize(self, *args) -> "void":
        r"""
        resize(VIA_DIMENSION_Vector self, std::vector< VIA_DIMENSION >::size_type new_size)
        resize(VIA_DIMENSION_Vector self, std::vector< VIA_DIMENSION >::size_type new_size, VIA_DIMENSION x)
        """
        return _pcbnew.VIA_DIMENSION_Vector_resize(self, *args)

    def insert(self, *args) -> "void":
        r"""
        insert(VIA_DIMENSION_Vector self, std::vector< VIA_DIMENSION >::iterator pos, VIA_DIMENSION x) -> std::vector< VIA_DIMENSION >::iterator
        insert(VIA_DIMENSION_Vector self, std::vector< VIA_DIMENSION >::iterator pos, std::vector< VIA_DIMENSION >::size_type n, VIA_DIMENSION x)
        """
        return _pcbnew.VIA_DIMENSION_Vector_insert(self, *args)

    def reserve(self, n: "std::vector< VIA_DIMENSION >::size_type") -> "void":
        r"""reserve(VIA_DIMENSION_Vector self, std::vector< VIA_DIMENSION >::size_type n)"""
        return _pcbnew.VIA_DIMENSION_Vector_reserve(self, n)

    def capacity(self) -> "std::vector< VIA_DIMENSION >::size_type":
        r"""capacity(VIA_DIMENSION_Vector self) -> std::vector< VIA_DIMENSION >::size_type"""
        return _pcbnew.VIA_DIMENSION_Vector_capacity(self)
    __swig_destroy__ = _pcbnew.delete_VIA_DIMENSION_Vector

# Register VIA_DIMENSION_Vector in _pcbnew:
_pcbnew.VIA_DIMENSION_Vector_swigregister(VIA_DIMENSION_Vector)

LT_UNDEFINED = _pcbnew.LT_UNDEFINED

LT_SIGNAL = _pcbnew.LT_SIGNAL

LT_POWER = _pcbnew.LT_POWER

LT_MIXED = _pcbnew.LT_MIXED

LT_JUMPER = _pcbnew.LT_JUMPER

class LAYER(object):
    r"""Proxy of C++ LAYER 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__(LAYER self) -> LAYER"""
        _pcbnew.LAYER_swiginit(self, _pcbnew.new_LAYER())

    def clear(self) -> "void":
        r"""clear(LAYER self)"""
        return _pcbnew.LAYER_clear(self)
    m_name = property(_pcbnew.LAYER_m_name_get, _pcbnew.LAYER_m_name_set, doc=r"""m_name : wxString""")
    m_userName = property(_pcbnew.LAYER_m_userName_get, _pcbnew.LAYER_m_userName_set, doc=r"""m_userName : wxString""")
    m_type = property(_pcbnew.LAYER_m_type_get, _pcbnew.LAYER_m_type_set, doc=r"""m_type : LAYER_T""")
    m_visible = property(_pcbnew.LAYER_m_visible_get, _pcbnew.LAYER_m_visible_set, doc=r"""m_visible : bool""")
    m_number = property(_pcbnew.LAYER_m_number_get, _pcbnew.LAYER_m_number_set, doc=r"""m_number : int""")

    @staticmethod
    def ShowType(aType: "LAYER_T") -> "char const *":
        r"""ShowType(LAYER_T aType) -> char const *"""
        return _pcbnew.LAYER_ShowType(aType)

    @staticmethod
    def ParseType(aType: "char const *") -> "LAYER_T":
        r"""ParseType(char const * aType) -> LAYER_T"""
        return _pcbnew.LAYER_ParseType(aType)
    __swig_destroy__ = _pcbnew.delete_LAYER

# Register LAYER in _pcbnew:
_pcbnew.LAYER_swigregister(LAYER)

def LAYER_ShowType(aType: "LAYER_T") -> "char const *":
    r"""LAYER_ShowType(LAYER_T aType) -> char const *"""
    return _pcbnew.LAYER_ShowType(aType)

def LAYER_ParseType(aType: "char const *") -> "LAYER_T":
    r"""LAYER_ParseType(char const * aType) -> LAYER_T"""
    return _pcbnew.LAYER_ParseType(aType)

class HIGH_LIGHT_INFO(object):
    r"""Proxy of C++ HIGH_LIGHT_INFO 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__ = _pcbnew.delete_HIGH_LIGHT_INFO

# Register HIGH_LIGHT_INFO in _pcbnew:
_pcbnew.HIGH_LIGHT_INFO_swigregister(HIGH_LIGHT_INFO)

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

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

    def OnBoardItemAdded(self, aBoard: "BOARD", aBoardItem: "BOARD_ITEM") -> "void":
        r"""OnBoardItemAdded(BOARD_LISTENER self, BOARD aBoard, BOARD_ITEM aBoardItem)"""
        return _pcbnew.BOARD_LISTENER_OnBoardItemAdded(self, aBoard, aBoardItem)

    def OnBoardItemsAdded(self, aBoard: "BOARD", aBoardItem: "std::vector< BOARD_ITEM *,std::allocator< BOARD_ITEM * > > &") -> "void":
        r"""OnBoardItemsAdded(BOARD_LISTENER self, BOARD aBoard, std::vector< BOARD_ITEM *,std::allocator< BOARD_ITEM * > > & aBoardItem)"""
        return _pcbnew.BOARD_LISTENER_OnBoardItemsAdded(self, aBoard, aBoardItem)

    def OnBoardItemRemoved(self, aBoard: "BOARD", aBoardItem: "BOARD_ITEM") -> "void":
        r"""OnBoardItemRemoved(BOARD_LISTENER self, BOARD aBoard, BOARD_ITEM aBoardItem)"""
        return _pcbnew.BOARD_LISTENER_OnBoardItemRemoved(self, aBoard, aBoardItem)

    def OnBoardItemsRemoved(self, aBoard: "BOARD", aBoardItem: "std::vector< BOARD_ITEM *,std::allocator< BOARD_ITEM * > > &") -> "void":
        r"""OnBoardItemsRemoved(BOARD_LISTENER self, BOARD aBoard, std::vector< BOARD_ITEM *,std::allocator< BOARD_ITEM * > > & aBoardItem)"""
        return _pcbnew.BOARD_LISTENER_OnBoardItemsRemoved(self, aBoard, aBoardItem)

    def OnBoardNetSettingsChanged(self, aBoard: "BOARD") -> "void":
        r"""OnBoardNetSettingsChanged(BOARD_LISTENER self, BOARD aBoard)"""
        return _pcbnew.BOARD_LISTENER_OnBoardNetSettingsChanged(self, aBoard)

    def OnBoardItemChanged(self, aBoard: "BOARD", aBoardItem: "BOARD_ITEM") -> "void":
        r"""OnBoardItemChanged(BOARD_LISTENER self, BOARD aBoard, BOARD_ITEM aBoardItem)"""
        return _pcbnew.BOARD_LISTENER_OnBoardItemChanged(self, aBoard, aBoardItem)

    def OnBoardItemsChanged(self, aBoard: "BOARD", aBoardItem: "std::vector< BOARD_ITEM *,std::allocator< BOARD_ITEM * > > &") -> "void":
        r"""OnBoardItemsChanged(BOARD_LISTENER self, BOARD aBoard, std::vector< BOARD_ITEM *,std::allocator< BOARD_ITEM * > > & aBoardItem)"""
        return _pcbnew.BOARD_LISTENER_OnBoardItemsChanged(self, aBoard, aBoardItem)

    def OnBoardHighlightNetChanged(self, aBoard: "BOARD") -> "void":
        r"""OnBoardHighlightNetChanged(BOARD_LISTENER self, BOARD aBoard)"""
        return _pcbnew.BOARD_LISTENER_OnBoardHighlightNetChanged(self, aBoard)

    def __init__(self):
        r"""__init__(BOARD_LISTENER self) -> BOARD_LISTENER"""
        _pcbnew.BOARD_LISTENER_swiginit(self, _pcbnew.new_BOARD_LISTENER())

# Register BOARD_LISTENER in _pcbnew:
_pcbnew.BOARD_LISTENER_swigregister(BOARD_LISTENER)

BOARD_USE_NORMAL = _pcbnew.BOARD_USE_NORMAL

BOARD_USE_FPHOLDER = _pcbnew.BOARD_USE_FPHOLDER

class BOARD(BOARD_ITEM_CONTAINER):
    r"""Proxy of C++ BOARD 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

    @staticmethod
    def ClassOf(aItem: "EDA_ITEM") -> "bool":
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.BOARD_ClassOf(aItem)

    def SetBoardUse(self, aUse: "BOARD_USE") -> "void":
        r"""SetBoardUse(BOARD self, BOARD_USE aUse)"""
        return _pcbnew.BOARD_SetBoardUse(self, aUse)

    def GetBoardUse(self) -> "BOARD_USE":
        r"""GetBoardUse(BOARD self) -> BOARD_USE"""
        return _pcbnew.BOARD_GetBoardUse(self)

    def IncrementTimeStamp(self) -> "void":
        r"""IncrementTimeStamp(BOARD self)"""
        return _pcbnew.BOARD_IncrementTimeStamp(self)

    def GetTimeStamp(self) -> "int":
        r"""GetTimeStamp(BOARD self) -> int"""
        return _pcbnew.BOARD_GetTimeStamp(self)

    def IsFootprintHolder(self) -> "bool":
        r"""IsFootprintHolder(BOARD self) -> bool"""
        return _pcbnew.BOARD_IsFootprintHolder(self)

    def SetFileName(self, aFileName: "wxString") -> "void":
        r"""SetFileName(BOARD self, wxString aFileName)"""
        return _pcbnew.BOARD_SetFileName(self, aFileName)

    def GetFileName(self) -> "wxString const &":
        r"""GetFileName(BOARD self) -> wxString"""
        return _pcbnew.BOARD_GetFileName(self)

    def Tracks(self, *args) -> "TRACKS const &":
        r"""
        Tracks(BOARD self) -> TRACKS
        Tracks(BOARD self) -> TRACKS
        """
        return _pcbnew.BOARD_Tracks(self, *args)

    def Footprints(self, *args) -> "FOOTPRINTS const &":
        r"""
        Footprints(BOARD self) -> FOOTPRINTS
        Footprints(BOARD self) -> FOOTPRINTS
        """
        return _pcbnew.BOARD_Footprints(self, *args)

    def Drawings(self, *args) -> "DRAWINGS const &":
        r"""
        Drawings(BOARD self) -> DRAWINGS
        Drawings(BOARD self) -> DRAWINGS
        """
        return _pcbnew.BOARD_Drawings(self, *args)

    def Zones(self, *args) -> "ZONES const &":
        r"""
        Zones(BOARD self) -> ZONES
        Zones(BOARD self) -> ZONES
        """
        return _pcbnew.BOARD_Zones(self, *args)

    def Markers(self, *args) -> "MARKERS const &":
        r"""
        Markers(BOARD self) -> MARKERS
        Markers(BOARD self) -> MARKERS
        """
        return _pcbnew.BOARD_Markers(self, *args)

    def Groups(self, *args) -> "GROUPS const &":
        r"""
        Groups(BOARD self) -> GROUPS
        Groups(BOARD self) -> GROUPS
        """
        return _pcbnew.BOARD_Groups(self, *args)

    def AllConnectedItems(self) -> "std::vector< BOARD_CONNECTED_ITEM *,std::allocator< BOARD_CONNECTED_ITEM * > > const":
        r"""AllConnectedItems(BOARD self) -> std::vector< BOARD_CONNECTED_ITEM *,std::allocator< BOARD_CONNECTED_ITEM * > > const"""
        return _pcbnew.BOARD_AllConnectedItems(self)

    def GetProperties(self) -> "std::map< wxString,wxString,std::less< wxString >,std::allocator< std::pair< wxString const,wxString > > > const &":
        r"""GetProperties(BOARD self) -> MAP_STRING_STRING"""
        return _pcbnew.BOARD_GetProperties(self)

    def SetProperties(self, aProps: "MAP_STRING_STRING") -> "void":
        r"""SetProperties(BOARD self, MAP_STRING_STRING aProps)"""
        return _pcbnew.BOARD_SetProperties(self, aProps)

    def ResolveTextVar(self, token: "wxString", aDepth: "int") -> "bool":
        r"""ResolveTextVar(BOARD self, wxString token, int aDepth) -> bool"""
        return _pcbnew.BOARD_ResolveTextVar(self, token, aDepth)
    m_LegacyVisibleLayers = property(_pcbnew.BOARD_m_LegacyVisibleLayers_get, _pcbnew.BOARD_m_LegacyVisibleLayers_set, doc=r"""m_LegacyVisibleLayers : LSET""")
    m_LegacyVisibleItems = property(_pcbnew.BOARD_m_LegacyVisibleItems_get, _pcbnew.BOARD_m_LegacyVisibleItems_set, doc=r"""m_LegacyVisibleItems : GAL_SET""")
    m_LegacyDesignSettingsLoaded = property(_pcbnew.BOARD_m_LegacyDesignSettingsLoaded_get, _pcbnew.BOARD_m_LegacyDesignSettingsLoaded_set, doc=r"""m_LegacyDesignSettingsLoaded : bool""")
    m_LegacyCopperEdgeClearanceLoaded = property(_pcbnew.BOARD_m_LegacyCopperEdgeClearanceLoaded_get, _pcbnew.BOARD_m_LegacyCopperEdgeClearanceLoaded_set, doc=r"""m_LegacyCopperEdgeClearanceLoaded : bool""")
    m_LegacyNetclassesLoaded = property(_pcbnew.BOARD_m_LegacyNetclassesLoaded_get, _pcbnew.BOARD_m_LegacyNetclassesLoaded_set, doc=r"""m_LegacyNetclassesLoaded : bool""")
    __swig_destroy__ = _pcbnew.delete_BOARD

    def GetPosition(self) -> "wxPoint":
        r"""GetPosition(BOARD self) -> wxPoint"""
        return _pcbnew.BOARD_GetPosition(self)

    def SetPosition(self, aPos: "wxPoint") -> "void":
        r"""SetPosition(BOARD self, wxPoint aPos)"""
        return _pcbnew.BOARD_SetPosition(self, aPos)

    def GetFocusPosition(self) -> "wxPoint const":
        r"""GetFocusPosition(BOARD self) -> wxPoint"""
        return _pcbnew.BOARD_GetFocusPosition(self)

    def IsEmpty(self) -> "bool":
        r"""IsEmpty(BOARD self) -> bool"""
        return _pcbnew.BOARD_IsEmpty(self)

    def Move(self, aMoveVector: "wxPoint") -> "void":
        r"""Move(BOARD self, wxPoint aMoveVector)"""
        return _pcbnew.BOARD_Move(self, aMoveVector)

    def SetFileFormatVersionAtLoad(self, aVersion: "int") -> "void":
        r"""SetFileFormatVersionAtLoad(BOARD self, int aVersion)"""
        return _pcbnew.BOARD_SetFileFormatVersionAtLoad(self, aVersion)

    def GetFileFormatVersionAtLoad(self) -> "int":
        r"""GetFileFormatVersionAtLoad(BOARD self) -> int"""
        return _pcbnew.BOARD_GetFileFormatVersionAtLoad(self)

    def SetGenerator(self, aGenerator: "wxString") -> "void":
        r"""SetGenerator(BOARD self, wxString aGenerator)"""
        return _pcbnew.BOARD_SetGenerator(self, aGenerator)

    def GetGenerator(self) -> "wxString const &":
        r"""GetGenerator(BOARD self) -> wxString"""
        return _pcbnew.BOARD_GetGenerator(self)

    def AddNative(self, *args) -> "void":
        r"""AddNative(BOARD self, BOARD_ITEM aItem, ADD_MODE aMode=INSERT)"""
        return _pcbnew.BOARD_AddNative(self, *args)

    def RemoveNative(self, *args) -> "void":
        r"""RemoveNative(BOARD self, BOARD_ITEM aBoardItem, REMOVE_MODE aMode=NORMAL)"""
        return _pcbnew.BOARD_RemoveNative(self, *args)

    def FinalizeBulkAdd(self, aNewItems: "std::vector< BOARD_ITEM *,std::allocator< BOARD_ITEM * > > &") -> "void":
        r"""FinalizeBulkAdd(BOARD self, std::vector< BOARD_ITEM *,std::allocator< BOARD_ITEM * > > & aNewItems)"""
        return _pcbnew.BOARD_FinalizeBulkAdd(self, aNewItems)

    def FinalizeBulkRemove(self, aRemovedItems: "std::vector< BOARD_ITEM *,std::allocator< BOARD_ITEM * > > &") -> "void":
        r"""FinalizeBulkRemove(BOARD self, std::vector< BOARD_ITEM *,std::allocator< BOARD_ITEM * > > & aRemovedItems)"""
        return _pcbnew.BOARD_FinalizeBulkRemove(self, aRemovedItems)

    def GetFirstFootprint(self) -> "FOOTPRINT *":
        r"""GetFirstFootprint(BOARD self) -> FOOTPRINT"""
        return _pcbnew.BOARD_GetFirstFootprint(self)

    def DeleteAllFootprints(self) -> "void":
        r"""DeleteAllFootprints(BOARD self)"""
        return _pcbnew.BOARD_DeleteAllFootprints(self)

    def GetItem(self, aID: "KIID") -> "BOARD_ITEM *":
        r"""GetItem(BOARD self, KIID aID) -> BOARD_ITEM"""
        return _pcbnew.BOARD_GetItem(self, aID)

    def FillItemMap(self, aMap: "std::map< KIID,EDA_ITEM *,std::less< KIID >,std::allocator< std::pair< KIID const,EDA_ITEM * > > > &") -> "void":
        r"""FillItemMap(BOARD self, std::map< KIID,EDA_ITEM *,std::less< KIID >,std::allocator< std::pair< KIID const,EDA_ITEM * > > > & aMap)"""
        return _pcbnew.BOARD_FillItemMap(self, aMap)

    def ConvertCrossReferencesToKIIDs(self, aSource: "wxString") -> "wxString":
        r"""ConvertCrossReferencesToKIIDs(BOARD self, wxString aSource) -> wxString"""
        return _pcbnew.BOARD_ConvertCrossReferencesToKIIDs(self, aSource)

    def ConvertKIIDsToCrossReferences(self, aSource: "wxString") -> "wxString":
        r"""ConvertKIIDsToCrossReferences(BOARD self, wxString aSource) -> wxString"""
        return _pcbnew.BOARD_ConvertKIIDsToCrossReferences(self, aSource)

    def GetConnectivity(self) -> "std::shared_ptr< CONNECTIVITY_DATA >":
        r"""GetConnectivity(BOARD self) -> std::shared_ptr< CONNECTIVITY_DATA >"""
        return _pcbnew.BOARD_GetConnectivity(self)

    def BuildConnectivity(self, aReporter: "PROGRESS_REPORTER *"=None) -> "void":
        r"""BuildConnectivity(BOARD self, PROGRESS_REPORTER * aReporter=None)"""
        return _pcbnew.BOARD_BuildConnectivity(self, aReporter)

    def DeleteMARKERs(self, *args) -> "void":
        r"""
        DeleteMARKERs(BOARD self)
        DeleteMARKERs(BOARD self, bool aWarningsAndErrors, bool aExclusions)
        """
        return _pcbnew.BOARD_DeleteMARKERs(self, *args)

    def GetProject(self) -> "PROJECT *":
        r"""GetProject(BOARD self) -> PROJECT *"""
        return _pcbnew.BOARD_GetProject(self)

    def SetProject(self, aProject: "PROJECT *") -> "void":
        r"""SetProject(BOARD self, PROJECT * aProject)"""
        return _pcbnew.BOARD_SetProject(self, aProject)

    def ClearProject(self) -> "void":
        r"""ClearProject(BOARD self)"""
        return _pcbnew.BOARD_ClearProject(self)

    def ResolveDRCExclusions(self) -> "std::vector< PCB_MARKER *,std::allocator< PCB_MARKER * > >":
        r"""ResolveDRCExclusions(BOARD self) -> MARKERS"""
        return _pcbnew.BOARD_ResolveDRCExclusions(self)

    def ResetNetHighLight(self) -> "void":
        r"""ResetNetHighLight(BOARD self)"""
        return _pcbnew.BOARD_ResetNetHighLight(self)

    def GetHighLightNetCodes(self) -> "std::set< int,std::less< int >,std::allocator< int > > const &":
        r"""GetHighLightNetCodes(BOARD self) -> std::set< int,std::less< int >,std::allocator< int > > const &"""
        return _pcbnew.BOARD_GetHighLightNetCodes(self)

    def SetHighLightNet(self, aNetCode: "int", aMulti: "bool"=False) -> "void":
        r"""SetHighLightNet(BOARD self, int aNetCode, bool aMulti=False)"""
        return _pcbnew.BOARD_SetHighLightNet(self, aNetCode, aMulti)

    def IsHighLightNetON(self) -> "bool":
        r"""IsHighLightNetON(BOARD self) -> bool"""
        return _pcbnew.BOARD_IsHighLightNetON(self)

    def HighLightON(self, aValue: "bool"=True) -> "void":
        r"""HighLightON(BOARD self, bool aValue=True)"""
        return _pcbnew.BOARD_HighLightON(self, aValue)

    def HighLightOFF(self) -> "void":
        r"""HighLightOFF(BOARD self)"""
        return _pcbnew.BOARD_HighLightOFF(self)

    def GetCopperLayerCount(self) -> "int":
        r"""GetCopperLayerCount(BOARD self) -> int"""
        return _pcbnew.BOARD_GetCopperLayerCount(self)

    def SetCopperLayerCount(self, aCount: "int") -> "void":
        r"""SetCopperLayerCount(BOARD self, int aCount)"""
        return _pcbnew.BOARD_SetCopperLayerCount(self, aCount)

    def GetEnabledLayers(self) -> "LSET":
        r"""GetEnabledLayers(BOARD self) -> LSET"""
        return _pcbnew.BOARD_GetEnabledLayers(self)

    def SetEnabledLayers(self, aLayerMask: "LSET") -> "void":
        r"""SetEnabledLayers(BOARD self, LSET aLayerMask)"""
        return _pcbnew.BOARD_SetEnabledLayers(self, aLayerMask)

    def IsLayerEnabled(self, aLayer: "PCB_LAYER_ID") -> "bool":
        r"""IsLayerEnabled(BOARD self, PCB_LAYER_ID aLayer) -> bool"""
        return _pcbnew.BOARD_IsLayerEnabled(self, aLayer)

    def IsLayerVisible(self, aLayer: "PCB_LAYER_ID") -> "bool":
        r"""IsLayerVisible(BOARD self, PCB_LAYER_ID aLayer) -> bool"""
        return _pcbnew.BOARD_IsLayerVisible(self, aLayer)

    def GetVisibleLayers(self) -> "LSET":
        r"""GetVisibleLayers(BOARD self) -> LSET"""
        return _pcbnew.BOARD_GetVisibleLayers(self)

    def SetVisibleLayers(self, aLayerMask: "LSET") -> "void":
        r"""SetVisibleLayers(BOARD self, LSET aLayerMask)"""
        return _pcbnew.BOARD_SetVisibleLayers(self, aLayerMask)

    def GetVisibleElements(self) -> "GAL_SET":
        r"""GetVisibleElements(BOARD self) -> GAL_SET"""
        return _pcbnew.BOARD_GetVisibleElements(self)

    def SetVisibleElements(self, aMask: "GAL_SET") -> "void":
        r"""SetVisibleElements(BOARD self, GAL_SET aMask)"""
        return _pcbnew.BOARD_SetVisibleElements(self, aMask)

    def SetVisibleAlls(self) -> "void":
        r"""SetVisibleAlls(BOARD self)"""
        return _pcbnew.BOARD_SetVisibleAlls(self)

    def IsElementVisible(self, aLayer: "GAL_LAYER_ID") -> "bool":
        r"""IsElementVisible(BOARD self, GAL_LAYER_ID aLayer) -> bool"""
        return _pcbnew.BOARD_IsElementVisible(self, aLayer)

    def SetElementVisibility(self, aLayer: "GAL_LAYER_ID", aNewState: "bool") -> "void":
        r"""SetElementVisibility(BOARD self, GAL_LAYER_ID aLayer, bool aNewState)"""
        return _pcbnew.BOARD_SetElementVisibility(self, aLayer, aNewState)

    def IsFootprintLayerVisible(self, aLayer: "PCB_LAYER_ID") -> "bool":
        r"""IsFootprintLayerVisible(BOARD self, PCB_LAYER_ID aLayer) -> bool"""
        return _pcbnew.BOARD_IsFootprintLayerVisible(self, aLayer)

    def GetDesignSettings(self) -> "BOARD_DESIGN_SETTINGS &":
        r"""GetDesignSettings(BOARD self) -> BOARD_DESIGN_SETTINGS"""
        return _pcbnew.BOARD_GetDesignSettings(self)

    def GetZoneSettings(self) -> "ZONE_SETTINGS const &":
        r"""GetZoneSettings(BOARD self) -> ZONE_SETTINGS"""
        return _pcbnew.BOARD_GetZoneSettings(self)

    def SetZoneSettings(self, aSettings: "ZONE_SETTINGS") -> "void":
        r"""SetZoneSettings(BOARD self, ZONE_SETTINGS aSettings)"""
        return _pcbnew.BOARD_SetZoneSettings(self, aSettings)

    def GetPageSettings(self) -> "PAGE_INFO const &":
        r"""GetPageSettings(BOARD self) -> PAGE_INFO const &"""
        return _pcbnew.BOARD_GetPageSettings(self)

    def SetPageSettings(self, aPageSettings: "PAGE_INFO const &") -> "void":
        r"""SetPageSettings(BOARD self, PAGE_INFO const & aPageSettings)"""
        return _pcbnew.BOARD_SetPageSettings(self, aPageSettings)

    def GetPlotOptions(self) -> "PCB_PLOT_PARAMS const &":
        r"""GetPlotOptions(BOARD self) -> PCB_PLOT_PARAMS"""
        return _pcbnew.BOARD_GetPlotOptions(self)

    def SetPlotOptions(self, aOptions: "PCB_PLOT_PARAMS") -> "void":
        r"""SetPlotOptions(BOARD self, PCB_PLOT_PARAMS aOptions)"""
        return _pcbnew.BOARD_SetPlotOptions(self, aOptions)

    def GetTitleBlock(self, *args) -> "TITLE_BLOCK const &":
        r"""
        GetTitleBlock(BOARD self) -> TITLE_BLOCK
        GetTitleBlock(BOARD self) -> TITLE_BLOCK
        """
        return _pcbnew.BOARD_GetTitleBlock(self, *args)

    def SetTitleBlock(self, aTitleBlock: "TITLE_BLOCK") -> "void":
        r"""SetTitleBlock(BOARD self, TITLE_BLOCK aTitleBlock)"""
        return _pcbnew.BOARD_SetTitleBlock(self, aTitleBlock)

    def GetSelectMenuText(self, aUnits: "EDA_UNITS") -> "wxString":
        r"""GetSelectMenuText(BOARD self, EDA_UNITS aUnits) -> wxString"""
        return _pcbnew.BOARD_GetSelectMenuText(self, aUnits)

    def GetBoardPolygonOutlines(self, aOutlines: "SHAPE_POLY_SET", aErrorHandler: "OUTLINE_ERROR_HANDLER *"=None) -> "bool":
        r"""GetBoardPolygonOutlines(BOARD self, SHAPE_POLY_SET aOutlines, OUTLINE_ERROR_HANDLER * aErrorHandler=None) -> bool"""
        return _pcbnew.BOARD_GetBoardPolygonOutlines(self, aOutlines, aErrorHandler)

    def ConvertBrdLayerToPolygonalContours(self, aLayer: "PCB_LAYER_ID", aOutlines: "SHAPE_POLY_SET") -> "void":
        r"""ConvertBrdLayerToPolygonalContours(BOARD self, PCB_LAYER_ID aLayer, SHAPE_POLY_SET aOutlines)"""
        return _pcbnew.BOARD_ConvertBrdLayerToPolygonalContours(self, aLayer, aOutlines)

    def GetLayerID(self, aLayerName: "wxString") -> "PCB_LAYER_ID const":
        r"""GetLayerID(BOARD self, wxString aLayerName) -> PCB_LAYER_ID const"""
        return _pcbnew.BOARD_GetLayerID(self, aLayerName)

    def GetLayerName(self, aLayer: "PCB_LAYER_ID") -> "wxString const":
        r"""GetLayerName(BOARD self, PCB_LAYER_ID aLayer) -> wxString"""
        return _pcbnew.BOARD_GetLayerName(self, aLayer)

    def SetLayerName(self, aLayer: "PCB_LAYER_ID", aLayerName: "wxString") -> "bool":
        r"""SetLayerName(BOARD self, PCB_LAYER_ID aLayer, wxString aLayerName) -> bool"""
        return _pcbnew.BOARD_SetLayerName(self, aLayer, aLayerName)

    @staticmethod
    def GetStandardLayerName(aLayerId: "PCB_LAYER_ID") -> "wxString":
        r"""GetStandardLayerName(PCB_LAYER_ID aLayerId) -> wxString"""
        return _pcbnew.BOARD_GetStandardLayerName(aLayerId)

    def SetLayerDescr(self, aIndex: "PCB_LAYER_ID", aLayer: "LAYER") -> "bool":
        r"""SetLayerDescr(BOARD self, PCB_LAYER_ID aIndex, LAYER aLayer) -> bool"""
        return _pcbnew.BOARD_SetLayerDescr(self, aIndex, aLayer)

    def GetLayerType(self, aLayer: "PCB_LAYER_ID") -> "LAYER_T":
        r"""GetLayerType(BOARD self, PCB_LAYER_ID aLayer) -> LAYER_T"""
        return _pcbnew.BOARD_GetLayerType(self, aLayer)

    def SetLayerType(self, aLayer: "PCB_LAYER_ID", aLayerType: "LAYER_T") -> "bool":
        r"""SetLayerType(BOARD self, PCB_LAYER_ID aLayer, LAYER_T aLayerType) -> bool"""
        return _pcbnew.BOARD_SetLayerType(self, aLayer, aLayerType)

    def GetNodesCount(self, aNet: "int"=-1) -> "unsigned int":
        r"""GetNodesCount(BOARD self, int aNet=-1) -> unsigned int"""
        return _pcbnew.BOARD_GetNodesCount(self, aNet)

    def GetUnconnectedNetCount(self) -> "unsigned int":
        r"""GetUnconnectedNetCount(BOARD self) -> unsigned int"""
        return _pcbnew.BOARD_GetUnconnectedNetCount(self)

    def GetPads(self) -> "std::vector< PAD *,std::allocator< PAD * > > const":
        r"""GetPads(BOARD self) -> PADS_VEC"""
        return _pcbnew.BOARD_GetPads(self)

    def BuildListOfNets(self) -> "void":
        r"""BuildListOfNets(BOARD self)"""
        return _pcbnew.BOARD_BuildListOfNets(self)

    def FindNet(self, *args) -> "NETINFO_ITEM *":
        r"""
        FindNet(BOARD self, int aNetcode) -> NETINFO_ITEM
        FindNet(BOARD self, wxString aNetname) -> NETINFO_ITEM
        """
        return _pcbnew.BOARD_FindNet(self, *args)

    def GetNetInfo(self, *args) -> "NETINFO_LIST &":
        r"""
        GetNetInfo(BOARD self) -> NETINFO_LIST
        GetNetInfo(BOARD self) -> NETINFO_LIST
        """
        return _pcbnew.BOARD_GetNetInfo(self, *args)

    def GetNetCount(self) -> "unsigned int":
        r"""GetNetCount(BOARD self) -> unsigned int"""
        return _pcbnew.BOARD_GetNetCount(self)

    def ComputeBoundingBox(self, aBoardEdgesOnly: "bool"=False) -> "EDA_RECT":
        r"""ComputeBoundingBox(BOARD self, bool aBoardEdgesOnly=False) -> EDA_RECT"""
        return _pcbnew.BOARD_ComputeBoundingBox(self, aBoardEdgesOnly)

    def GetBoundingBox(self) -> "EDA_RECT const":
        r"""GetBoundingBox(BOARD self) -> EDA_RECT"""
        return _pcbnew.BOARD_GetBoundingBox(self)

    def GetBoardEdgesBoundingBox(self) -> "EDA_RECT const":
        r"""GetBoardEdgesBoundingBox(BOARD self) -> EDA_RECT"""
        return _pcbnew.BOARD_GetBoardEdgesBoundingBox(self)

    def GetMsgPanelInfo(self, aFrame: "EDA_DRAW_FRAME *", aList: "std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > &") -> "void":
        r"""GetMsgPanelInfo(BOARD self, EDA_DRAW_FRAME * aFrame, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.BOARD_GetMsgPanelInfo(self, aFrame, aList)

    def Visit(self, inspector: "INSPECTOR", testData: "void *", scanTypes: "KICAD_T const []") -> "SEARCH_RESULT":
        r"""Visit(BOARD self, INSPECTOR inspector, void * testData, KICAD_T const [] scanTypes) -> SEARCH_RESULT"""
        return _pcbnew.BOARD_Visit(self, inspector, testData, scanTypes)

    def FindFootprintByReference(self, aReference: "wxString") -> "FOOTPRINT *":
        r"""FindFootprintByReference(BOARD self, wxString aReference) -> FOOTPRINT"""
        return _pcbnew.BOARD_FindFootprintByReference(self, aReference)

    def FindFootprintByPath(self, aPath: "KIID_PATH") -> "FOOTPRINT *":
        r"""FindFootprintByPath(BOARD self, KIID_PATH aPath) -> FOOTPRINT"""
        return _pcbnew.BOARD_FindFootprintByPath(self, aPath)

    def GetNetClassAssignmentCandidates(self) -> "std::vector< wxString,std::allocator< wxString > >":
        r"""GetNetClassAssignmentCandidates(BOARD self) -> std::vector< wxString,std::allocator< wxString > >"""
        return _pcbnew.BOARD_GetNetClassAssignmentCandidates(self)

    def SynchronizeNetsAndNetClasses(self) -> "void":
        r"""SynchronizeNetsAndNetClasses(BOARD self)"""
        return _pcbnew.BOARD_SynchronizeNetsAndNetClasses(self)

    def SynchronizeProperties(self) -> "void":
        r"""SynchronizeProperties(BOARD self)"""
        return _pcbnew.BOARD_SynchronizeProperties(self)

    def GetClass(self) -> "wxString":
        r"""GetClass(BOARD self) -> wxString"""
        return _pcbnew.BOARD_GetClass(self)

    def SetAreasNetCodesFromNetNames(self) -> "int":
        r"""SetAreasNetCodesFromNetNames(BOARD self) -> int"""
        return _pcbnew.BOARD_SetAreasNetCodesFromNetNames(self)

    def GetArea(self, index: "int") -> "ZONE *":
        r"""GetArea(BOARD self, int index) -> ZONE"""
        return _pcbnew.BOARD_GetArea(self, index)

    def GetZoneList(self, aIncludeZonesInFootprints: "bool"=False) -> "std::list< ZONE *,std::allocator< ZONE * > >":
        r"""GetZoneList(BOARD self, bool aIncludeZonesInFootprints=False) -> std::list< ZONE *,std::allocator< ZONE * > >"""
        return _pcbnew.BOARD_GetZoneList(self, aIncludeZonesInFootprints)

    def GetAreaCount(self) -> "int":
        r"""GetAreaCount(BOARD self) -> int"""
        return _pcbnew.BOARD_GetAreaCount(self)

    def AddArea(self, aNewZonesList: "PICKED_ITEMS_LIST *", aNetcode: "int", aLayer: "PCB_LAYER_ID", aStartPointPosition: "wxPoint", aHatch: "ZONE_BORDER_DISPLAY_STYLE") -> "ZONE *":
        r"""AddArea(BOARD self, PICKED_ITEMS_LIST * aNewZonesList, int aNetcode, PCB_LAYER_ID aLayer, wxPoint aStartPointPosition, ZONE_BORDER_DISPLAY_STYLE aHatch) -> ZONE"""
        return _pcbnew.BOARD_AddArea(self, aNewZonesList, aNetcode, aLayer, aStartPointPosition, aHatch)

    def TestZoneIntersection(self, aZone1: "ZONE", aZone2: "ZONE") -> "bool":
        r"""TestZoneIntersection(BOARD self, ZONE aZone1, ZONE aZone2) -> bool"""
        return _pcbnew.BOARD_TestZoneIntersection(self, aZone1, aZone2)

    def GetPadFast(self, aPosition: "wxPoint", aLayerMask: "LSET") -> "PAD *":
        r"""GetPadFast(BOARD self, wxPoint aPosition, LSET aLayerMask) -> PAD"""
        return _pcbnew.BOARD_GetPadFast(self, aPosition, aLayerMask)

    def GetPad(self, *args) -> "PAD *":
        r"""
        GetPad(BOARD self, wxPoint aPosition, LSET aLayerMask) -> PAD
        GetPad(BOARD self, wxPoint aPosition) -> PAD
        GetPad(BOARD self, PCB_TRACK aTrace, ENDPOINT_T aEndPoint) -> PAD
        GetPad(BOARD self, PADS_VEC aPadList, wxPoint aPosition, LSET aLayerMask) -> PAD
        """
        return _pcbnew.BOARD_GetPad(self, *args)

    def PadDelete(self, aPad: "PAD") -> "void":
        r"""PadDelete(BOARD self, PAD aPad)"""
        return _pcbnew.BOARD_PadDelete(self, aPad)

    def GetSortedPadListByXthenYCoord(self, aVector: "PADS_VEC", aNetCode: "int"=-1) -> "void":
        r"""GetSortedPadListByXthenYCoord(BOARD self, PADS_VEC aVector, int aNetCode=-1)"""
        return _pcbnew.BOARD_GetSortedPadListByXthenYCoord(self, aVector, aNetCode)

    def GetTrackLength(self, aTrack: "PCB_TRACK") -> "std::tuple< int,double,double >":
        r"""GetTrackLength(BOARD self, PCB_TRACK aTrack) -> std::tuple< int,double,double >"""
        return _pcbnew.BOARD_GetTrackLength(self, aTrack)

    def TracksInNet(self, aNetCode: "int") -> "TRACKS":
        r"""TracksInNet(BOARD self, int aNetCode) -> TRACKS"""
        return _pcbnew.BOARD_TracksInNet(self, aNetCode)

    def GetFootprint(self, aPosition: "wxPoint", aActiveLayer: "PCB_LAYER_ID", aVisibleOnly: "bool", aIgnoreLocked: "bool"=False) -> "FOOTPRINT *":
        r"""GetFootprint(BOARD self, wxPoint aPosition, PCB_LAYER_ID aActiveLayer, bool aVisibleOnly, bool aIgnoreLocked=False) -> FOOTPRINT"""
        return _pcbnew.BOARD_GetFootprint(self, aPosition, aActiveLayer, aVisibleOnly, aIgnoreLocked)

    def ClearAllNetCodes(self) -> "void":
        r"""ClearAllNetCodes(BOARD self)"""
        return _pcbnew.BOARD_ClearAllNetCodes(self)

    def MapNets(self, aDestBoard: "BOARD") -> "void":
        r"""MapNets(BOARD self, BOARD aDestBoard)"""
        return _pcbnew.BOARD_MapNets(self, aDestBoard)

    def SanitizeNetcodes(self) -> "void":
        r"""SanitizeNetcodes(BOARD self)"""
        return _pcbnew.BOARD_SanitizeNetcodes(self)

    def AddListener(self, aListener: "BOARD_LISTENER") -> "void":
        r"""AddListener(BOARD self, BOARD_LISTENER aListener)"""
        return _pcbnew.BOARD_AddListener(self, aListener)

    def RemoveListener(self, aListener: "BOARD_LISTENER") -> "void":
        r"""RemoveListener(BOARD self, BOARD_LISTENER aListener)"""
        return _pcbnew.BOARD_RemoveListener(self, aListener)

    def OnItemChanged(self, aItem: "BOARD_ITEM") -> "void":
        r"""OnItemChanged(BOARD self, BOARD_ITEM aItem)"""
        return _pcbnew.BOARD_OnItemChanged(self, aItem)

    def OnItemsChanged(self, aItems: "std::vector< BOARD_ITEM *,std::allocator< BOARD_ITEM * > > &") -> "void":
        r"""OnItemsChanged(BOARD self, std::vector< BOARD_ITEM *,std::allocator< BOARD_ITEM * > > & aItems)"""
        return _pcbnew.BOARD_OnItemsChanged(self, aItems)

    def GroupsSanityCheck(self, repair: "bool"=False) -> "wxString":
        r"""GroupsSanityCheck(BOARD self, bool repair=False) -> wxString"""
        return _pcbnew.BOARD_GroupsSanityCheck(self, repair)

    def GroupsSanityCheckInternal(self, repair: "bool") -> "wxString":
        r"""GroupsSanityCheckInternal(BOARD self, bool repair) -> wxString"""
        return _pcbnew.BOARD_GroupsSanityCheckInternal(self, repair)

    def GroupLegalOps(self, selection: "PCB_SELECTION const &") -> "BOARD::GroupLegalOpsField":
        r"""GroupLegalOps(BOARD self, PCB_SELECTION const & selection) -> BOARD::GroupLegalOpsField"""
        return _pcbnew.BOARD_GroupLegalOps(self, selection)
    m_InsideFCourtyardCache = property(_pcbnew.BOARD_m_InsideFCourtyardCache_get, _pcbnew.BOARD_m_InsideFCourtyardCache_set, doc=r"""m_InsideFCourtyardCache : std::map<(std::pair<(p.BOARD_ITEM,p.BOARD_ITEM)>,bool,std::less<(std::pair<(p.BOARD_ITEM,p.BOARD_ITEM)>)>,std::allocator<(std::pair<(q(const).std::pair<(p.BOARD_ITEM,p.BOARD_ITEM)>,bool)>)>)>""")
    m_InsideBCourtyardCache = property(_pcbnew.BOARD_m_InsideBCourtyardCache_get, _pcbnew.BOARD_m_InsideBCourtyardCache_set, doc=r"""m_InsideBCourtyardCache : std::map<(std::pair<(p.BOARD_ITEM,p.BOARD_ITEM)>,bool,std::less<(std::pair<(p.BOARD_ITEM,p.BOARD_ITEM)>)>,std::allocator<(std::pair<(q(const).std::pair<(p.BOARD_ITEM,p.BOARD_ITEM)>,bool)>)>)>""")
    m_LayerExpressionCache = property(_pcbnew.BOARD_m_LayerExpressionCache_get, _pcbnew.BOARD_m_LayerExpressionCache_set, doc=r"""m_LayerExpressionCache : std::map<(wxString,LSET,std::less<(wxString)>,std::allocator<(std::pair<(q(const).wxString,LSET)>)>)>""")

    def __init__(self, *args):
        this = CreateEmptyBoard()

        try:
            self.this.append(this)
        except:
            self.this = this

    # Convert these to lists to keep users from using them to delete
    # items in the iterable while looping over it
    def GetFootprints(self):          return list(self.Footprints())
    def GetDrawings(self):            return list(self.Drawings())
    def GetTracks(self):              return list(self.Tracks())

    def Save(self,filename):
        return SaveBoard(filename,self)

    def GetNetClasses(self):
        return self.GetDesignSettings().m_NetClasses

    def GetCurrentNetClassName(self):
        return self.GetDesignSettings().m_CurrentNetClassName

    def GetViasDimensionsList(self):
        return self.GetDesignSettings().m_ViasDimensionsList

    def GetTrackWidthList(self):
        return self.GetDesignSettings().m_TrackWidthList

    def GetNetsByName(self):
        """
        Return a dictionary like object with key:wxString netname and value:NETINFO_ITEM
        """
        return self.GetNetInfo().NetsByName()

    def GetNetsByNetcode(self):
        """
        Return a dictionary like object with key:int netcode and value:NETINFO_ITEM
        """
        return self.GetNetInfo().NetsByNetcode()

    def GetNetcodeFromNetname(self,netname):
        """
        Given a netname, return its netcode
        """
        net = self.GetNetsByName()[netname]
        return net.GetNetCode()

    def GetAllNetClasses(self):
        """
        Return a dictionary like object with net_class_name as key and NETCLASSPTR as value
        GetNetClasses(BOARD self) -> { wxString net_class_name : NETCLASSPTR }
        Include the "Default" netclass also.
        """

    # Copy the NETCLASS_MAP so the one in the BOARD isn't modified
    # when we add the Default net class.
        netclassmap = {k:v for k,v in self.GetNetClasses().NetClasses().items()}
        netclassmap['Default'] = self.GetNetClasses().GetDefault()
        return netclassmap


# Register BOARD in _pcbnew:
_pcbnew.BOARD_swigregister(BOARD)

def BOARD_ClassOf(aItem: "EDA_ITEM") -> "bool":
    r"""BOARD_ClassOf(EDA_ITEM aItem) -> bool"""
    return _pcbnew.BOARD_ClassOf(aItem)

def BOARD_GetStandardLayerName(aLayerId: "PCB_LAYER_ID") -> "wxString":
    r"""BOARD_GetStandardLayerName(PCB_LAYER_ID aLayerId) -> wxString"""
    return _pcbnew.BOARD_GetStandardLayerName(aLayerId)

class MAP_STRING_STRING(object):
    r"""Proxy of C++ std::map< wxString,wxString > 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) -> "swig::SwigPyIterator *":
        r"""iterator(MAP_STRING_STRING self) -> SwigPyIterator"""
        return _pcbnew.MAP_STRING_STRING_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(MAP_STRING_STRING self) -> bool"""
        return _pcbnew.MAP_STRING_STRING___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(MAP_STRING_STRING self) -> bool"""
        return _pcbnew.MAP_STRING_STRING___bool__(self)

    def __len__(self) -> "std::map< wxString,wxString >::size_type":
        r"""__len__(MAP_STRING_STRING self) -> std::map< wxString,wxString >::size_type"""
        return _pcbnew.MAP_STRING_STRING___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "wxString") -> "std::map< wxString,wxString >::mapped_type const &":
        r"""__getitem__(MAP_STRING_STRING self, wxString key) -> wxString"""
        return _pcbnew.MAP_STRING_STRING___getitem__(self, key)

    def __delitem__(self, key: "wxString") -> "void":
        r"""__delitem__(MAP_STRING_STRING self, wxString key)"""
        return _pcbnew.MAP_STRING_STRING___delitem__(self, key)

    def has_key(self, key: "wxString") -> "bool":
        r"""has_key(MAP_STRING_STRING self, wxString key) -> bool"""
        return _pcbnew.MAP_STRING_STRING_has_key(self, key)

    def keys(self) -> "PyObject *":
        r"""keys(MAP_STRING_STRING self) -> PyObject *"""
        return _pcbnew.MAP_STRING_STRING_keys(self)

    def values(self) -> "PyObject *":
        r"""values(MAP_STRING_STRING self) -> PyObject *"""
        return _pcbnew.MAP_STRING_STRING_values(self)

    def items(self) -> "PyObject *":
        r"""items(MAP_STRING_STRING self) -> PyObject *"""
        return _pcbnew.MAP_STRING_STRING_items(self)

    def __contains__(self, key: "wxString") -> "bool":
        r"""__contains__(MAP_STRING_STRING self, wxString key) -> bool"""
        return _pcbnew.MAP_STRING_STRING___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        r"""key_iterator(MAP_STRING_STRING self) -> SwigPyIterator"""
        return _pcbnew.MAP_STRING_STRING_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        r"""value_iterator(MAP_STRING_STRING self) -> SwigPyIterator"""
        return _pcbnew.MAP_STRING_STRING_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(MAP_STRING_STRING self, wxString key)
        __setitem__(MAP_STRING_STRING self, wxString key, wxString x)
        """
        return _pcbnew.MAP_STRING_STRING___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        r"""asdict(MAP_STRING_STRING self) -> PyObject *"""
        return _pcbnew.MAP_STRING_STRING_asdict(self)

    def __init__(self, *args):
        r"""
        __init__(MAP_STRING_STRING self, std::less< wxString > const & other) -> MAP_STRING_STRING
        __init__(MAP_STRING_STRING self) -> MAP_STRING_STRING
        __init__(MAP_STRING_STRING self, MAP_STRING_STRING other) -> MAP_STRING_STRING
        """
        _pcbnew.MAP_STRING_STRING_swiginit(self, _pcbnew.new_MAP_STRING_STRING(*args))

    def empty(self) -> "bool":
        r"""empty(MAP_STRING_STRING self) -> bool"""
        return _pcbnew.MAP_STRING_STRING_empty(self)

    def size(self) -> "std::map< wxString,wxString >::size_type":
        r"""size(MAP_STRING_STRING self) -> std::map< wxString,wxString >::size_type"""
        return _pcbnew.MAP_STRING_STRING_size(self)

    def swap(self, v: "MAP_STRING_STRING") -> "void":
        r"""swap(MAP_STRING_STRING self, MAP_STRING_STRING v)"""
        return _pcbnew.MAP_STRING_STRING_swap(self, v)

    def begin(self) -> "std::map< wxString,wxString >::iterator":
        r"""begin(MAP_STRING_STRING self) -> std::map< wxString,wxString >::iterator"""
        return _pcbnew.MAP_STRING_STRING_begin(self)

    def end(self) -> "std::map< wxString,wxString >::iterator":
        r"""end(MAP_STRING_STRING self) -> std::map< wxString,wxString >::iterator"""
        return _pcbnew.MAP_STRING_STRING_end(self)

    def rbegin(self) -> "std::map< wxString,wxString >::reverse_iterator":
        r"""rbegin(MAP_STRING_STRING self) -> std::map< wxString,wxString >::reverse_iterator"""
        return _pcbnew.MAP_STRING_STRING_rbegin(self)

    def rend(self) -> "std::map< wxString,wxString >::reverse_iterator":
        r"""rend(MAP_STRING_STRING self) -> std::map< wxString,wxString >::reverse_iterator"""
        return _pcbnew.MAP_STRING_STRING_rend(self)

    def clear(self) -> "void":
        r"""clear(MAP_STRING_STRING self)"""
        return _pcbnew.MAP_STRING_STRING_clear(self)

    def get_allocator(self) -> "std::map< wxString,wxString >::allocator_type":
        r"""get_allocator(MAP_STRING_STRING self) -> std::map< wxString,wxString >::allocator_type"""
        return _pcbnew.MAP_STRING_STRING_get_allocator(self)

    def count(self, x: "wxString") -> "std::map< wxString,wxString >::size_type":
        r"""count(MAP_STRING_STRING self, wxString x) -> std::map< wxString,wxString >::size_type"""
        return _pcbnew.MAP_STRING_STRING_count(self, x)

    def erase(self, *args) -> "void":
        r"""
        erase(MAP_STRING_STRING self, wxString x) -> std::map< wxString,wxString >::size_type
        erase(MAP_STRING_STRING self, std::map< wxString,wxString >::iterator position)
        erase(MAP_STRING_STRING self, std::map< wxString,wxString >::iterator first, std::map< wxString,wxString >::iterator last)
        """
        return _pcbnew.MAP_STRING_STRING_erase(self, *args)

    def find(self, x: "wxString") -> "std::map< wxString,wxString >::iterator":
        r"""find(MAP_STRING_STRING self, wxString x) -> std::map< wxString,wxString >::iterator"""
        return _pcbnew.MAP_STRING_STRING_find(self, x)

    def lower_bound(self, x: "wxString") -> "std::map< wxString,wxString >::iterator":
        r"""lower_bound(MAP_STRING_STRING self, wxString x) -> std::map< wxString,wxString >::iterator"""
        return _pcbnew.MAP_STRING_STRING_lower_bound(self, x)

    def upper_bound(self, x: "wxString") -> "std::map< wxString,wxString >::iterator":
        r"""upper_bound(MAP_STRING_STRING self, wxString x) -> std::map< wxString,wxString >::iterator"""
        return _pcbnew.MAP_STRING_STRING_upper_bound(self, x)
    __swig_destroy__ = _pcbnew.delete_MAP_STRING_STRING

# Register MAP_STRING_STRING in _pcbnew:
_pcbnew.MAP_STRING_STRING_swigregister(MAP_STRING_STRING)

DO_NOT_INCLUDE_NPTH = _pcbnew.DO_NOT_INCLUDE_NPTH

INCLUDE_NPTH = _pcbnew.INCLUDE_NPTH

FP_THROUGH_HOLE = _pcbnew.FP_THROUGH_HOLE

FP_SMD = _pcbnew.FP_SMD

FP_EXCLUDE_FROM_POS_FILES = _pcbnew.FP_EXCLUDE_FROM_POS_FILES

FP_EXCLUDE_FROM_BOM = _pcbnew.FP_EXCLUDE_FROM_BOM

FP_BOARD_ONLY = _pcbnew.FP_BOARD_ONLY

FP_JUST_ADDED = _pcbnew.FP_JUST_ADDED

class FP_3DMODEL(object):
    r"""Proxy of C++ FP_3DMODEL 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__(FP_3DMODEL self) -> FP_3DMODEL"""
        _pcbnew.FP_3DMODEL_swiginit(self, _pcbnew.new_FP_3DMODEL())
    m_Scale = property(_pcbnew.FP_3DMODEL_m_Scale_get, _pcbnew.FP_3DMODEL_m_Scale_set, doc=r"""m_Scale : FP_3DMODEL::VECTOR3D""")
    m_Rotation = property(_pcbnew.FP_3DMODEL_m_Rotation_get, _pcbnew.FP_3DMODEL_m_Rotation_set, doc=r"""m_Rotation : FP_3DMODEL::VECTOR3D""")
    m_Offset = property(_pcbnew.FP_3DMODEL_m_Offset_get, _pcbnew.FP_3DMODEL_m_Offset_set, doc=r"""m_Offset : FP_3DMODEL::VECTOR3D""")
    m_Opacity = property(_pcbnew.FP_3DMODEL_m_Opacity_get, _pcbnew.FP_3DMODEL_m_Opacity_set, doc=r"""m_Opacity : double""")
    m_Filename = property(_pcbnew.FP_3DMODEL_m_Filename_get, _pcbnew.FP_3DMODEL_m_Filename_set, doc=r"""m_Filename : wxString""")
    m_Show = property(_pcbnew.FP_3DMODEL_m_Show_get, _pcbnew.FP_3DMODEL_m_Show_set, doc=r"""m_Show : bool""")
    __swig_destroy__ = _pcbnew.delete_FP_3DMODEL

# Register FP_3DMODEL in _pcbnew:
_pcbnew.FP_3DMODEL_swigregister(FP_3DMODEL)

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    x = property(_pcbnew.VECTOR3D_x_get, _pcbnew.VECTOR3D_x_set, doc=r"""x : double""")
    y = property(_pcbnew.VECTOR3D_y_get, _pcbnew.VECTOR3D_y_set, doc=r"""y : double""")
    z = property(_pcbnew.VECTOR3D_z_get, _pcbnew.VECTOR3D_z_set, doc=r"""z : double""")

    def __init__(self):
        r"""__init__(VECTOR3D self) -> VECTOR3D"""
        _pcbnew.VECTOR3D_swiginit(self, _pcbnew.new_VECTOR3D())
    __swig_destroy__ = _pcbnew.delete_VECTOR3D

# Register VECTOR3D in _pcbnew:
_pcbnew.VECTOR3D_swigregister(VECTOR3D)

class FOOTPRINT(BOARD_ITEM_CONTAINER):
    r"""Proxy of C++ FOOTPRINT 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__(FOOTPRINT self, BOARD parent) -> FOOTPRINT
        __init__(FOOTPRINT self, FOOTPRINT aFootprint) -> FOOTPRINT
        __init__(FOOTPRINT self, FOOTPRINT aFootprint) -> FOOTPRINT
        """
        _pcbnew.FOOTPRINT_swiginit(self, _pcbnew.new_FOOTPRINT(*args))
    __swig_destroy__ = _pcbnew.delete_FOOTPRINT

    @staticmethod
    def ClassOf(aItem: "EDA_ITEM") -> "bool":
        r"""ClassOf(EDA_ITEM aItem) -> bool"""
        return _pcbnew.FOOTPRINT_ClassOf(aItem)

    def AddNative(self, *args) -> "void":
        r"""AddNative(FOOTPRINT self, BOARD_ITEM aItem, ADD_MODE aMode=INSERT)"""
        return _pcbnew.FOOTPRINT_AddNative(self, *args)

    def RemoveNative(self, *args) -> "void":
        r"""RemoveNative(FOOTPRINT self, BOARD_ITEM aItem, REMOVE_MODE aMode=NORMAL)"""
        return _pcbnew.FOOTPRINT_RemoveNative(self, *args)

    def ClearAllNets(self) -> "void":
        r"""ClearAllNets(FOOTPRINT self)"""
        return _pcbnew.FOOTPRINT_ClearAllNets(self)

    def FixUuids(self) -> "bool":
        r"""FixUuids(FOOTPRINT self) -> bool"""
        return _pcbnew.FOOTPRINT_FixUuids(self)

    def GetFpPadsLocalBbox(self) -> "EDA_RECT":
        r"""GetFpPadsLocalBbox(FOOTPRINT self) -> EDA_RECT"""
        return _pcbnew.FOOTPRINT_GetFpPadsLocalBbox(self)

    def GetBoundingHull(self) -> "SHAPE_POLY_SET":
        r"""GetBoundingHull(FOOTPRINT self) -> SHAPE_POLY_SET"""
        return _pcbnew.FOOTPRINT_GetBoundingHull(self)

    def GetBoundingBox(self, *args) -> "EDA_RECT const":
        r"""
        GetBoundingBox(FOOTPRINT self) -> EDA_RECT
        GetBoundingBox(FOOTPRINT self, bool aIncludeText, bool aIncludeInvisibleText) -> EDA_RECT
        """
        return _pcbnew.FOOTPRINT_GetBoundingBox(self, *args)

    def Pads(self, *args) -> "PADS const &":
        r"""
        Pads(FOOTPRINT self) -> PADS
        Pads(FOOTPRINT self) -> PADS
        """
        return _pcbnew.FOOTPRINT_Pads(self, *args)

    def GraphicalItems(self, *args) -> "DRAWINGS const &":
        r"""
        GraphicalItems(FOOTPRINT self) -> DRAWINGS
        GraphicalItems(FOOTPRINT self) -> DRAWINGS
        """
        return _pcbnew.FOOTPRINT_GraphicalItems(self, *args)

    def Zones(self, *args) -> "FP_ZONES const &":
        r"""
        Zones(FOOTPRINT self) -> FP_ZONES
        Zones(FOOTPRINT self) -> FP_ZONES
        """
        return _pcbnew.FOOTPRINT_Zones(self, *args)

    def Groups(self, *args) -> "FP_GROUPS const &":
        r"""
        Groups(FOOTPRINT self) -> FP_GROUPS
        Groups(FOOTPRINT self) -> FP_GROUPS
        """
        return _pcbnew.FOOTPRINT_Groups(self, *args)

    def HasThroughHolePads(self) -> "bool":
        r"""HasThroughHolePads(FOOTPRINT self) -> bool"""
        return _pcbnew.FOOTPRINT_HasThroughHolePads(self)

    def Models(self, *args) -> "std::list< FP_3DMODEL,std::allocator< FP_3DMODEL > > const &":
        r"""
        Models(FOOTPRINT self) -> FP_3DMODEL_List
        Models(FOOTPRINT self) -> FP_3DMODEL_List
        """
        return _pcbnew.FOOTPRINT_Models(self, *args)

    def SetPosition(self, aPos: "wxPoint") -> "void":
        r"""SetPosition(FOOTPRINT self, wxPoint aPos)"""
        return _pcbnew.FOOTPRINT_SetPosition(self, aPos)

    def GetPosition(self) -> "wxPoint":
        r"""GetPosition(FOOTPRINT self) -> wxPoint"""
        return _pcbnew.FOOTPRINT_GetPosition(self)

    def SetOrientation(self, aNewAngle: "double") -> "void":
        r"""SetOrientation(FOOTPRINT self, double aNewAngle)"""
        return _pcbnew.FOOTPRINT_SetOrientation(self, aNewAngle)

    def SetOrientationDegrees(self, aOrientation: "double") -> "void":
        r"""SetOrientationDegrees(FOOTPRINT self, double aOrientation)"""
        return _pcbnew.FOOTPRINT_SetOrientationDegrees(self, aOrientation)

    def GetOrientation(self) -> "double":
        r"""GetOrientation(FOOTPRINT self) -> double"""
        return _pcbnew.FOOTPRINT_GetOrientation(self)

    def GetOrientationDegrees(self) -> "double":
        r"""GetOrientationDegrees(FOOTPRINT self) -> double"""
        return _pcbnew.FOOTPRINT_GetOrientationDegrees(self)

    def GetOrientationRadians(self) -> "double":
        r"""GetOrientationRadians(FOOTPRINT self) -> double"""
        return _pcbnew.FOOTPRINT_GetOrientationRadians(self)

    def GetFPID(self) -> "LIB_ID const &":
        r"""GetFPID(FOOTPRINT self) -> LIB_ID"""
        return _pcbnew.FOOTPRINT_GetFPID(self)

    def SetFPID(self, aFPID: "LIB_ID") -> "void":
        r"""SetFPID(FOOTPRINT self, LIB_ID aFPID)"""
        return _pcbnew.FOOTPRINT_SetFPID(self, aFPID)

    def GetDescription(self) -> "wxString const &":
        r"""GetDescription(FOOTPRINT self) -> wxString"""
        return _pcbnew.FOOTPRINT_GetDescription(self)

    def SetDescription(self, aDoc: "wxString") -> "void":
        r"""SetDescription(FOOTPRINT self, wxString aDoc)"""
        return _pcbnew.FOOTPRINT_SetDescription(self, aDoc)

    def GetKeywords(self) -> "wxString const &":
        r"""GetKeywords(FOOTPRINT self) -> wxString"""
        return _pcbnew.FOOTPRINT_GetKeywords(self)

    def SetKeywords(self, aKeywords: "wxString") -> "void":
        r"""SetKeywords(FOOTPRINT self, wxString aKeywords)"""
        return _pcbnew.FOOTPRINT_SetKeywords(self, aKeywords)

    def GetPath(self) -> "KIID_PATH const &":
        r"""GetPath(FOOTPRINT self) -> KIID_PATH"""
        return _pcbnew.FOOTPRINT_GetPath(self)

    def SetPath(self, aPath: "KIID_PATH") -> "void":
        r"""SetPath(FOOTPRINT self, KIID_PATH aPath)"""
        return _pcbnew.FOOTPRINT_SetPath(self, aPath)

    def GetLocalSolderMaskMargin(self) -> "int":
        r"""GetLocalSolderMaskMargin(FOOTPRINT self) -> int"""
        return _pcbnew.FOOTPRINT_GetLocalSolderMaskMargin(self)

    def SetLocalSolderMaskMargin(self, aMargin: "int") -> "void":
        r"""SetLocalSolderMaskMargin(FOOTPRINT self, int aMargin)"""
        return _pcbnew.FOOTPRINT_SetLocalSolderMaskMargin(self, aMargin)

    def SetLocalClearance(self, aClearance: "int") -> "void":
        r"""SetLocalClearance(FOOTPRINT self, int aClearance)"""
        return _pcbnew.FOOTPRINT_SetLocalClearance(self, aClearance)

    def GetLocalClearance(self, *args) -> "int":
        r"""
        GetLocalClearance(FOOTPRINT self) -> int
        GetLocalClearance(FOOTPRINT self, wxString aSource) -> int
        """
        return _pcbnew.FOOTPRINT_GetLocalClearance(self, *args)

    def GetLocalSolderPasteMargin(self) -> "int":
        r"""GetLocalSolderPasteMargin(FOOTPRINT self) -> int"""
        return _pcbnew.FOOTPRINT_GetLocalSolderPasteMargin(self)

    def SetLocalSolderPasteMargin(self, aMargin: "int") -> "void":
        r"""SetLocalSolderPasteMargin(FOOTPRINT self, int aMargin)"""
        return _pcbnew.FOOTPRINT_SetLocalSolderPasteMargin(self, aMargin)

    def GetLocalSolderPasteMarginRatio(self) -> "double":
        r"""GetLocalSolderPasteMarginRatio(FOOTPRINT self) -> double"""
        return _pcbnew.FOOTPRINT_GetLocalSolderPasteMarginRatio(self)

    def SetLocalSolderPasteMarginRatio(self, aRatio: "double") -> "void":
        r"""SetLocalSolderPasteMarginRatio(FOOTPRINT self, double aRatio)"""
        return _pcbnew.FOOTPRINT_SetLocalSolderPasteMarginRatio(self, aRatio)

    def SetZoneConnection(self, aType: "ZONE_CONNECTION") -> "void":
        r"""SetZoneConnection(FOOTPRINT self, ZONE_CONNECTION aType)"""
        return _pcbnew.FOOTPRINT_SetZoneConnection(self, aType)

    def GetZoneConnection(self) -> "ZONE_CONNECTION":
        r"""GetZoneConnection(FOOTPRINT self) -> ZONE_CONNECTION"""
        return _pcbnew.FOOTPRINT_GetZoneConnection(self)

    def SetThermalWidth(self, aWidth: "int") -> "void":
        r"""SetThermalWidth(FOOTPRINT self, int aWidth)"""
        return _pcbnew.FOOTPRINT_SetThermalWidth(self, aWidth)

    def GetThermalWidth(self) -> "int":
        r"""GetThermalWidth(FOOTPRINT self) -> int"""
        return _pcbnew.FOOTPRINT_GetThermalWidth(self)

    def SetThermalGap(self, aGap: "int") -> "void":
        r"""SetThermalGap(FOOTPRINT self, int aGap)"""
        return _pcbnew.FOOTPRINT_SetThermalGap(self, aGap)

    def GetThermalGap(self) -> "int":
        r"""GetThermalGap(FOOTPRINT self) -> int"""
        return _pcbnew.FOOTPRINT_GetThermalGap(self)

    def GetAttributes(self) -> "int":
        r"""GetAttributes(FOOTPRINT self) -> int"""
        return _pcbnew.FOOTPRINT_GetAttributes(self)

    def SetAttributes(self, aAttributes: "int") -> "void":
        r"""SetAttributes(FOOTPRINT self, int aAttributes)"""
        return _pcbnew.FOOTPRINT_SetAttributes(self, aAttributes)

    def SetFlag(self, aFlag: "int") -> "void":
        r"""SetFlag(FOOTPRINT self, int aFlag)"""
        return _pcbnew.FOOTPRINT_SetFlag(self, aFlag)

    def IncrementFlag(self) -> "void":
        r"""IncrementFlag(FOOTPRINT self)"""
        return _pcbnew.FOOTPRINT_IncrementFlag(self)

    def GetFlag(self) -> "int":
        r"""GetFlag(FOOTPRINT self) -> int"""
        return _pcbnew.FOOTPRINT_GetFlag(self)

    def IsNetTie(self) -> "bool":
        r"""IsNetTie(FOOTPRINT self) -> bool"""
        return _pcbnew.FOOTPRINT_IsNetTie(self)

    def GetLikelyAttribute(self) -> "int":
        r"""GetLikelyAttribute(FOOTPRINT self) -> int"""
        return _pcbnew.FOOTPRINT_GetLikelyAttribute(self)

    def Move(self, aMoveVector: "wxPoint") -> "void":
        r"""Move(FOOTPRINT self, wxPoint aMoveVector)"""
        return _pcbnew.FOOTPRINT_Move(self, aMoveVector)

    def Rotate(self, aRotCentre: "wxPoint", aAngle: "double") -> "void":
        r"""Rotate(FOOTPRINT self, wxPoint aRotCentre, double aAngle)"""
        return _pcbnew.FOOTPRINT_Rotate(self, aRotCentre, aAngle)

    def Flip(self, aCentre: "wxPoint", aFlipLeftRight: "bool") -> "void":
        r"""Flip(FOOTPRINT self, wxPoint aCentre, bool aFlipLeftRight)"""
        return _pcbnew.FOOTPRINT_Flip(self, aCentre, aFlipLeftRight)

    def MoveAnchorPosition(self, aMoveVector: "wxPoint") -> "void":
        r"""MoveAnchorPosition(FOOTPRINT self, wxPoint aMoveVector)"""
        return _pcbnew.FOOTPRINT_MoveAnchorPosition(self, aMoveVector)

    def IsFlipped(self) -> "bool":
        r"""IsFlipped(FOOTPRINT self) -> bool"""
        return _pcbnew.FOOTPRINT_IsFlipped(self)

    def IsOnLayer(self, aLayer: "PCB_LAYER_ID") -> "bool":
        r"""IsOnLayer(FOOTPRINT self, PCB_LAYER_ID aLayer) -> bool"""
        return _pcbnew.FOOTPRINT_IsOnLayer(self, aLayer)

    def IsLocked(self) -> "bool":
        r"""IsLocked(FOOTPRINT self) -> bool"""
        return _pcbnew.FOOTPRINT_IsLocked(self)

    def SetLocked(self, isLocked: "bool") -> "void":
        r"""SetLocked(FOOTPRINT self, bool isLocked)"""
        return _pcbnew.FOOTPRINT_SetLocked(self, isLocked)

    def IsPlaced(self) -> "bool":
        r"""IsPlaced(FOOTPRINT self) -> bool"""
        return _pcbnew.FOOTPRINT_IsPlaced(self)

    def SetIsPlaced(self, isPlaced: "bool") -> "void":
        r"""SetIsPlaced(FOOTPRINT self, bool isPlaced)"""
        return _pcbnew.FOOTPRINT_SetIsPlaced(self, isPlaced)

    def NeedsPlaced(self) -> "bool":
        r"""NeedsPlaced(FOOTPRINT self) -> bool"""
        return _pcbnew.FOOTPRINT_NeedsPlaced(self)

    def SetNeedsPlaced(self, needsPlaced: "bool") -> "void":
        r"""SetNeedsPlaced(FOOTPRINT self, bool needsPlaced)"""
        return _pcbnew.FOOTPRINT_SetNeedsPlaced(self, needsPlaced)

    def LegacyPadsLocked(self) -> "bool":
        r"""LegacyPadsLocked(FOOTPRINT self) -> bool"""
        return _pcbnew.FOOTPRINT_LegacyPadsLocked(self)

    def SetLastEditTime(self, aTime: "timestamp_t") -> "void":
        r"""SetLastEditTime(FOOTPRINT self, timestamp_t aTime)"""
        return _pcbnew.FOOTPRINT_SetLastEditTime(self, aTime)

    def GetLastEditTime(self) -> "timestamp_t":
        r"""GetLastEditTime(FOOTPRINT self) -> timestamp_t"""
        return _pcbnew.FOOTPRINT_GetLastEditTime(self)

    def CheckFootprintAttributes(self, aErrorHandler: "std::function< void (wxString const &) > const *") -> "void":
        r"""CheckFootprintAttributes(FOOTPRINT self, std::function< void (wxString const &) > const * aErrorHandler)"""
        return _pcbnew.FOOTPRINT_CheckFootprintAttributes(self, aErrorHandler)

    def CheckFootprintTHPadNoHoles(self, aErrorHandler: "std::function< void (wxString const &,wxPoint const &) > const *") -> "void":
        r"""CheckFootprintTHPadNoHoles(FOOTPRINT self, std::function< void (wxString const &,wxPoint const &) > const * aErrorHandler)"""
        return _pcbnew.FOOTPRINT_CheckFootprintTHPadNoHoles(self, aErrorHandler)

    def TransformPadsWithClearanceToPolygon(self, aCornerBuffer: "SHAPE_POLY_SET", aLayer: "PCB_LAYER_ID", aClearance: "int", aMaxError: "int", aErrorLoc: "ERROR_LOC", aSkipNPTHPadsWihNoCopper: "bool"=False, aSkipPlatedPads: "bool"=False, aSkipNonPlatedPads: "bool"=False) -> "void":
        r"""TransformPadsWithClearanceToPolygon(FOOTPRINT self, SHAPE_POLY_SET aCornerBuffer, PCB_LAYER_ID aLayer, int aClearance, int aMaxError, ERROR_LOC aErrorLoc, bool aSkipNPTHPadsWihNoCopper=False, bool aSkipPlatedPads=False, bool aSkipNonPlatedPads=False)"""
        return _pcbnew.FOOTPRINT_TransformPadsWithClearanceToPolygon(self, aCornerBuffer, aLayer, aClearance, aMaxError, aErrorLoc, aSkipNPTHPadsWihNoCopper, aSkipPlatedPads, aSkipNonPlatedPads)

    def TransformFPShapesWithClearanceToPolygon(self, aCornerBuffer: "SHAPE_POLY_SET", aLayer: "PCB_LAYER_ID", aClearance: "int", aError: "int", aErrorLoc: "ERROR_LOC", aIncludeText: "bool"=True, aIncludeShapes: "bool"=True) -> "void":
        r"""TransformFPShapesWithClearanceToPolygon(FOOTPRINT self, SHAPE_POLY_SET aCornerBuffer, PCB_LAYER_ID aLayer, int aClearance, int aError, ERROR_LOC aErrorLoc, bool aIncludeText=True, bool aIncludeShapes=True)"""
        return _pcbnew.FOOTPRINT_TransformFPShapesWithClearanceToPolygon(self, aCornerBuffer, aLayer, aClearance, aError, aErrorLoc, aIncludeText, aIncludeShapes)

    def TransformFPTextWithClearanceToPolygonSet(self, aCornerBuffer: "SHAPE_POLY_SET", aLayer: "PCB_LAYER_ID", aClearance: "int", aError: "int", aErrorLoc: "ERROR_LOC") -> "void":
        r"""TransformFPTextWithClearanceToPolygonSet(FOOTPRINT self, SHAPE_POLY_SET aCornerBuffer, PCB_LAYER_ID aLayer, int aClearance, int aError, ERROR_LOC aErrorLoc)"""
        return _pcbnew.FOOTPRINT_TransformFPTextWithClearanceToPolygonSet(self, aCornerBuffer, aLayer, aClearance, aError, aErrorLoc)

    def GetContextualTextVars(self, aVars: "wxArrayString *") -> "void":
        r"""GetContextualTextVars(FOOTPRINT self, wxArrayString * aVars)"""
        return _pcbnew.FOOTPRINT_GetContextualTextVars(self, aVars)

    def ResolveTextVar(self, token: "wxString", aDepth: "int"=0) -> "bool":
        r"""ResolveTextVar(FOOTPRINT self, wxString token, int aDepth=0) -> bool"""
        return _pcbnew.FOOTPRINT_ResolveTextVar(self, token, aDepth)

    def GetMsgPanelInfo(self, aFrame: "EDA_DRAW_FRAME *", aList: "std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > &") -> "void":
        r"""GetMsgPanelInfo(FOOTPRINT self, EDA_DRAW_FRAME * aFrame, std::vector< MSG_PANEL_ITEM,std::allocator< MSG_PANEL_ITEM > > & aList)"""
        return _pcbnew.FOOTPRINT_GetMsgPanelInfo(self, aFrame, aList)

    def HitTestAccurate(self, aPosition: "wxPoint", aAccuracy: "int"=0) -> "bool":
        r"""HitTestAccurate(FOOTPRINT self, wxPoint aPosition, int aAccuracy=0) -> bool"""
        return _pcbnew.FOOTPRINT_HitTestAccurate(self, aPosition, aAccuracy)

    def HitTest(self, *args) -> "bool":
        r"""
        HitTest(FOOTPRINT self, wxPoint aPosition, int aAccuracy=0) -> bool
        HitTest(FOOTPRINT self, EDA_RECT aRect, bool aContained, int aAccuracy=0) -> bool
        """
        return _pcbnew.FOOTPRINT_HitTest(self, *args)

    def GetReference(self) -> "wxString const &":
        r"""GetReference(FOOTPRINT self) -> wxString"""
        return _pcbnew.FOOTPRINT_GetReference(self)

    def SetReference(self, aReference: "wxString") -> "void":
        r"""SetReference(FOOTPRINT self, wxString aReference)"""
        return _pcbnew.FOOTPRINT_SetReference(self, aReference)

    def IncrementReference(self, aDelta: "int") -> "void":
        r"""IncrementReference(FOOTPRINT self, int aDelta)"""
        return _pcbnew.FOOTPRINT_IncrementReference(self, aDelta)

    def GetValue(self) -> "wxString const &":
        r"""GetValue(FOOTPRINT self) -> wxString"""
        return _pcbnew.FOOTPRINT_GetValue(self)

    def SetValue(self, aValue: "wxString") -> "void":
        r"""SetValue(FOOTPRINT self, wxString aValue)"""
        return _pcbnew.FOOTPRINT_SetValue(self, aValue)

    def Value(self, *args) -> "FP_TEXT &":
        r"""
        Value(FOOTPRINT self) -> FP_TEXT
        Value(FOOTPRINT self) -> FP_TEXT
        """
        return _pcbnew.FOOTPRINT_Value(self, *args)

    def Reference(self, *args) -> "FP_TEXT &":
        r"""
        Reference(FOOTPRINT self) -> FP_TEXT
        Reference(FOOTPRINT self) -> FP_TEXT
        """
        return _pcbnew.FOOTPRINT_Reference(self, *args)

    def GetPropertiesNative(self) -> "std::map< wxString,wxString,std::less< wxString >,std::allocator< std::pair< wxString const,wxString > > > const &":
        r"""GetPropertiesNative(FOOTPRINT self) -> MAP_STRING_STRING"""
        return _pcbnew.FOOTPRINT_GetPropertiesNative(self)

    def SetPropertiesNative(self, aProps: "MAP_STRING_STRING") -> "void":
        r"""SetPropertiesNative(FOOTPRINT self, MAP_STRING_STRING aProps)"""
        return _pcbnew.FOOTPRINT_SetPropertiesNative(self, aProps)

    def GetPropertyNative(self, aKey: "wxString") -> "wxString const &":
        r"""GetPropertyNative(FOOTPRINT self, wxString aKey) -> wxString"""
        return _pcbnew.FOOTPRINT_GetPropertyNative(self, aKey)

    def HasProperty(self, aKey: "wxString") -> "bool":
        r"""HasProperty(FOOTPRINT self, wxString aKey) -> bool"""
        return _pcbnew.FOOTPRINT_HasProperty(self, aKey)

    def SetProperty(self, aKey: "wxString", aVal: "wxString") -> "void":
        r"""SetProperty(FOOTPRINT self, wxString aKey, wxString aVal)"""
        return _pcbnew.FOOTPRINT_SetProperty(self, aKey, aVal)

    def FindPadByNumber(self, aPadNumber: "wxString", aSearchAfterMe: "PAD"=None) -> "PAD *":
        r"""FindPadByNumber(FOOTPRINT self, wxString aPadNumber, PAD aSearchAfterMe=None) -> PAD"""
        return _pcbnew.FOOTPRINT_FindPadByNumber(self, aPadNumber, aSearchAfterMe)

    def GetPad(self, *args) -> "PAD *":
        r"""GetPad(FOOTPRINT self, wxPoint aPosition, LSET aLayerMask=LSET::AllLayersMask()) -> PAD"""
        return _pcbnew.FOOTPRINT_GetPad(self, *args)

    def GetTopLeftPad(self) -> "PAD *":
        r"""GetTopLeftPad(FOOTPRINT self) -> PAD"""
        return _pcbnew.FOOTPRINT_GetTopLeftPad(self)

    def GetPadCount(self, *args) -> "unsigned int":
        r"""GetPadCount(FOOTPRINT self, INCLUDE_NPTH_T aIncludeNPTH=INCLUDE_NPTH_T(INCLUDE_NPTH)) -> unsigned int"""
        return _pcbnew.FOOTPRINT_GetPadCount(self, *args)

    def GetUniquePadCount(self, *args) -> "unsigned int":
        r"""GetUniquePadCount(FOOTPRINT self, INCLUDE_NPTH_T aIncludeNPTH=INCLUDE_NPTH_T(INCLUDE_NPTH)) -> unsigned int"""
        return _pcbnew.FOOTPRINT_GetUniquePadCount(self, *args)

    def GetNextPadNumber(self, aLastPadName: "wxString") -> "wxString":
        r"""GetNextPadNumber(FOOTPRINT self, wxString aLastPadName) -> wxString"""
        return _pcbnew.FOOTPRINT_GetNextPadNumber(self, aLastPadName)

    def GetTypeName(self) -> "wxString":
        r"""GetTypeName(FOOTPRINT self) -> wxString"""
        return _pcbnew.FOOTPRINT_GetTypeName(self)

    def GetArea(self, aPadding: "int"=0) -> "double":
        r"""GetArea(FOOTPRINT self, int aPadding=0) -> double"""
        return _pcbnew.FOOTPRINT_GetArea(self, aPadding)

    def GetLink(self) -> "KIID":
        r"""GetLink(FOOTPRINT self) -> KIID"""
        return _pcbnew.FOOTPRINT_GetLink(self)

    def SetLink(self, aLink: "KIID") -> "void":
        r"""SetLink(FOOTPRINT self, KIID aLink)"""
        return _pcbnew.FOOTPRINT_SetLink(self, aLink)

    def GetPlacementCost180(self) -> "int":
        r"""GetPlacementCost180(FOOTPRINT self) -> int"""
        return _pcbnew.FOOTPRINT_GetPlacementCost180(self)

    def SetPlacementCost180(self, aCost: "int") -> "void":
        r"""SetPlacementCost180(FOOTPRINT self, int aCost)"""
        return _pcbnew.FOOTPRINT_SetPlacementCost180(self, aCost)

    def GetPlacementCost90(self) -> "int":
        r"""GetPlacementCost90(FOOTPRINT self) -> int"""
        return _pcbnew.FOOTPRINT_GetPlacementCost90(self)

    def SetPlacementCost90(self, aCost: "int") -> "void":
        r"""SetPlacementCost90(FOOTPRINT self, int aCost)"""
        return _pcbnew.FOOTPRINT_SetPlacementCost90(self, aCost)

    def Duplicate(self) -> "BOARD_ITEM *":
        r"""Duplicate(FOOTPRINT self) -> BOARD_ITEM"""
        return _pcbnew.FOOTPRINT_Duplicate(self)

    def DuplicateItem(self, aItem: "BOARD_ITEM", aAddToFootprint: "bool"=False) -> "BOARD_ITEM *":
        r"""DuplicateItem(FOOTPRINT self, BOARD_ITEM aItem, bool aAddToFootprint=False) -> BOARD_ITEM"""
        return _pcbnew.FOOTPRINT_DuplicateItem(self, aItem, aAddToFootprint)

    def Add3DModel(self, a3DModel: "FP_3DMODEL") -> "void":
        r"""Add3DModel(FOOTPRINT self, FP_3DMODEL a3DModel)"""
        return _pcbnew.FOOTPRINT_Add3DModel(self, a3DModel)

    def Visit(self, inspector: "INSPECTOR", testData: "void *", scanTypes: "KICAD_T const []") -> "SEARCH_RESULT":
        r"""Visit(FOOTPRINT self, INSPECTOR inspector, void * testData, KICAD_T const [] scanTypes) -> SEARCH_RESULT"""
        return _pcbnew.FOOTPRINT_Visit(self, inspector, testData, scanTypes)

    def GetClass(self) -> "wxString":
        r"""GetClass(FOOTPRINT self) -> wxString"""
        return _pcbnew.FOOTPRINT_GetClass(self)

    def GetSelectMenuText(self, aUnits: "EDA_UNITS") -> "wxString":
        r"""GetSelectMenuText(FOOTPRINT self, EDA_UNITS aUnits) -> wxString"""
        return _pcbnew.FOOTPRINT_GetSelectMenuText(self, aUnits)

    def GetMenuImage(self) -> "BITMAPS":
        r"""GetMenuImage(FOOTPRINT self) -> BITMAPS"""
        return _pcbnew.FOOTPRINT_GetMenuImage(self)

    def Clone(self) -> "EDA_ITEM *":
        r"""Clone(FOOTPRINT self) -> EDA_ITEM"""
        return _pcbnew.FOOTPRINT_Clone(self)

    def RunOnChildren(self, aFunction: "std::function< void (BOARD_ITEM *) > const &") -> "void":
        r"""RunOnChildren(FOOTPRINT self, std::function< void (BOARD_ITEM *) > const & aFunction)"""
        return _pcbnew.FOOTPRINT_RunOnChildren(self, aFunction)

    def GetAllDrawingLayers(self, aLayers: "int []", aCount: "int &", aIncludePads: "bool"=True) -> "void":
        r"""GetAllDrawingLayers(FOOTPRINT self, int [] aLayers, int & aCount, bool aIncludePads=True)"""
        return _pcbnew.FOOTPRINT_GetAllDrawingLayers(self, aLayers, aCount, aIncludePads)

    def ViewGetLayers(self, aLayers: "int []", aCount: "int &") -> "void":
        r"""ViewGetLayers(FOOTPRINT self, int [] aLayers, int & aCount)"""
        return _pcbnew.FOOTPRINT_ViewGetLayers(self, aLayers, aCount)

    def ViewGetLOD(self, aLayer: "int", aView: "KIGFX::VIEW *") -> "double":
        r"""ViewGetLOD(FOOTPRINT self, int aLayer, KIGFX::VIEW * aView) -> double"""
        return _pcbnew.FOOTPRINT_ViewGetLOD(self, aLayer, aView)

    def ViewBBox(self) -> "BOX2I const":
        r"""ViewBBox(FOOTPRINT self) -> BOX2I const"""
        return _pcbnew.FOOTPRINT_ViewBBox(self)

    @staticmethod
    def IsLibNameValid(aName: "wxString") -> "bool":
        r"""IsLibNameValid(wxString aName) -> bool"""
        return _pcbnew.FOOTPRINT_IsLibNameValid(aName)

    @staticmethod
    def StringLibNameInvalidChars(aUserReadable: "bool") -> "wxChar const *":
        r"""StringLibNameInvalidChars(bool aUserReadable) -> wxChar const *"""
        return _pcbnew.FOOTPRINT_StringLibNameInvalidChars(aUserReadable)

    def SetInitialComments(self, aInitialComments: "wxArrayString *") -> "void":
        r"""SetInitialComments(FOOTPRINT self, wxArrayString * aInitialComments)"""
        return _pcbnew.FOOTPRINT_SetInitialComments(self, aInitialComments)

    def CoverageRatio(self, aCollector: "GENERAL_COLLECTOR const &") -> "double":
        r"""CoverageRatio(FOOTPRINT self, GENERAL_COLLECTOR const & aCollector) -> double"""
        return _pcbnew.FOOTPRINT_CoverageRatio(self, aCollector)

    @staticmethod
    def GetCoverageArea(aItem: "BOARD_ITEM", aCollector: "GENERAL_COLLECTOR const &") -> "double":
        r"""GetCoverageArea(BOARD_ITEM aItem, GENERAL_COLLECTOR const & aCollector) -> double"""
        return _pcbnew.FOOTPRINT_GetCoverageArea(aItem, aCollector)

    def GetInitialComments(self) -> "wxArrayString const *":
        r"""GetInitialComments(FOOTPRINT self) -> wxArrayString const *"""
        return _pcbnew.FOOTPRINT_GetInitialComments(self)

    def GetPolyCourtyard(self, aLayer: "PCB_LAYER_ID") -> "SHAPE_POLY_SET const &":
        r"""GetPolyCourtyard(FOOTPRINT self, PCB_LAYER_ID aLayer) -> SHAPE_POLY_SET"""
        return _pcbnew.FOOTPRINT_GetPolyCourtyard(self, aLayer)

    def BuildPolyCourtyards(self, aErrorHandler: "OUTLINE_ERROR_HANDLER *"=None) -> "void":
        r"""BuildPolyCourtyards(FOOTPRINT self, OUTLINE_ERROR_HANDLER * aErrorHandler=None)"""
        return _pcbnew.FOOTPRINT_BuildPolyCourtyards(self, aErrorHandler)

    def GetEffectiveShape(self, *args) -> "std::shared_ptr< SHAPE >":
        r"""GetEffectiveShape(FOOTPRINT self, PCB_LAYER_ID aLayer=UNDEFINED_LAYER, FLASHING aFlash=DEFAULT) -> std::shared_ptr< SHAPE >"""
        return _pcbnew.FOOTPRINT_GetEffectiveShape(self, *args)

    def SwapData(self, aImage: "BOARD_ITEM") -> "void":
        r"""SwapData(FOOTPRINT self, BOARD_ITEM aImage)"""
        return _pcbnew.FOOTPRINT_SwapData(self, aImage)


        #def SaveToLibrary(self,filename):
        #  return SaveFootprintToLibrary(filename,self)

        #
        # add function, clears the thisown to avoid python from deleting
        # the object in the garbage collector
        #

    def GetProperties(self):
      """ Returns footprint properties map. """
      properties = self.GetPropertiesNative()
      return {str(k): str(v) for k, v in properties.items()}

    def GetProperty(self, key):
      """ Returns property with a given key if it exists, throws KeyError otherwise. """
      if self.HasProperty(key):
        return self.GetPropertyNative(key)
      else:
        raise KeyError("Property not found: " + key)

    def SetProperties(self, properties):
      """ Sets footprint properties map. """
      wxproperties = MAP_STRING_STRING()
      for k, v in properties.items():
        wxproperties[k] = v
      self.SetPropertiesNative(wxproperties)



# Register FOOTPRINT in _pcbnew:
_pcbnew.FOOTPRINT_swigregister(FOOTPRINT)

def FOOTPRINT_ClassOf(aItem: "EDA_ITEM") -> "bool":
    r"""FOOTPRINT_ClassOf(EDA_ITEM aItem) -> bool"""
    return _pcbnew.FOOTPRINT_ClassOf(aItem)
FP_is_LOCKED = _pcbnew.FP_is_LOCKED

FP_is_PLACED = _pcbnew.FP_is_PLACED

FP_to_PLACE = _pcbnew.FP_to_PLACE

FP_PADS_are_LOCKED = _pcbnew.FP_PADS_are_LOCKED


def FOOTPRINT_IsLibNameValid(aName: "wxString") -> "bool":
    r"""FOOTPRINT_IsLibNameValid(wxString aName) -> bool"""
    return _pcbnew.FOOTPRINT_IsLibNameValid(aName)

def FOOTPRINT_StringLibNameInvalidChars(aUserReadable: "bool") -> "wxChar const *":
    r"""FOOTPRINT_StringLibNameInvalidChars(bool aUserReadable) -> wxChar const *"""
    return _pcbnew.FOOTPRINT_StringLibNameInvalidChars(aUserReadable)

def FOOTPRINT_GetCoverageArea(aItem: "BOARD_ITEM", aCollector: "GENERAL_COLLECTOR const &") -> "double":
    r"""FOOTPRINT_GetCoverageArea(BOARD_ITEM aItem, GENERAL_COLLECTOR const & aCollector) -> double"""
    return _pcbnew.FOOTPRINT_GetCoverageArea(aItem, aCollector)

class cmp_drawings(object):
    r"""Proxy of C++ FOOTPRINT::cmp_drawings 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, aFirst: "BOARD_ITEM", aSecond: "BOARD_ITEM") -> "bool":
        r"""__call__(cmp_drawings self, BOARD_ITEM aFirst, BOARD_ITEM aSecond) -> bool"""
        return _pcbnew.cmp_drawings___call__(self, aFirst, aSecond)

    def __init__(self):
        r"""__init__(cmp_drawings self) -> cmp_drawings"""
        _pcbnew.cmp_drawings_swiginit(self, _pcbnew.new_cmp_drawings())
    __swig_destroy__ = _pcbnew.delete_cmp_drawings

# Register cmp_drawings in _pcbnew:
_pcbnew.cmp_drawings_swigregister(cmp_drawings)

class cmp_pads(object):
    r"""Proxy of C++ FOOTPRINT::cmp_pads 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, aFirst: "PAD", aSecond: "PAD") -> "bool":
        r"""__call__(cmp_pads self, PAD aFirst, PAD aSecond) -> bool"""
        return _pcbnew.cmp_pads___call__(self, aFirst, aSecond)

    def __init__(self):
        r"""__init__(cmp_pads self) -> cmp_pads"""
        _pcbnew.cmp_pads_swiginit(self, _pcbnew.new_cmp_pads())
    __swig_destroy__ = _pcbnew.delete_cmp_pads

# Register cmp_pads in _pcbnew:
_pcbnew.cmp_pads_swigregister(cmp_pads)

class FP_3DMODEL_List(object):
    r"""Proxy of C++ std::list< FP_3DMODEL > 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) -> "swig::SwigPyIterator *":
        r"""iterator(FP_3DMODEL_List self) -> SwigPyIterator"""
        return _pcbnew.FP_3DMODEL_List_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        r"""__nonzero__(FP_3DMODEL_List self) -> bool"""
        return _pcbnew.FP_3DMODEL_List___nonzero__(self)

    def __bool__(self) -> "bool":
        r"""__bool__(FP_3DMODEL_List self) -> bool"""
        return _pcbnew.FP_3DMODEL_List___bool__(self)

    def __len__(self) -> "std::list< FP_3DMODEL >::size_type":
        r"""__len__(FP_3DMODEL_List self) -> std::list< FP_3DMODEL >::size_type"""
        return _pcbnew.FP_3DMODEL_List___len__(self)

    def __getslice__(self, i: "std::list< FP_3DMODEL >::difference_type", j: "std::list< FP_3DMODEL >::difference_type") -> "std::list< FP_3DMODEL,std::allocator< FP_3DMODEL > > *":
        r"""__getslice__(FP_3DMODEL_List self, std::list< FP_3DMODEL >::difference_type i, std::list< FP_3DMODEL >::difference_type j) -> FP_3DMODEL_List"""
        return _pcbnew.FP_3DMODEL_List___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        r"""
        __setslice__(FP_3DMODEL_List self, std::list< FP_3DMODEL >::difference_type i, std::list< FP_3DMODEL >::difference_type j)
        __setslice__(FP_3DMODEL_List self, std::list< FP_3DMODEL >::difference_type i, std::list< FP_3DMODEL >::difference_type j, FP_3DMODEL_List v)
        """
        return _pcbnew.FP_3DMODEL_List___setslice__(self, *args)

    def __delslice__(self, i: "std::list< FP_3DMODEL >::difference_type", j: "std::list< FP_3DMODEL >::difference_type") -> "void":
        r"""__delslice__(FP_3DMODEL_List self, std::list< FP_3DMODEL >::difference_type i, std::list< FP_3DMODEL >::difference_type j)"""
        return _pcbnew.FP_3DMODEL_List___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        r"""
        __delitem__(FP_3DMODEL_List self, std::list< FP_3DMODEL >::difference_type i)
        __delitem__(FP_3DMODEL_List self, PySliceObject * slice)
        """
        return _pcbnew.FP_3DMODEL_List___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::list< FP_3DMODEL >::value_type const &":
        r"""
        __getitem__(FP_3DMODEL_List self, PySliceObject * slice) -> FP_3DMODEL_List
        __getitem__(FP_3DMODEL_List self, std::list< FP_3DMODEL >::difference_type i) -> FP_3DMODEL
        """
        return _pcbnew.FP_3DMODEL_List___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        r"""
        __setitem__(FP_3DMODEL_List self, PySliceObject * slice, FP_3DMODEL_List v)
        __setitem__(FP_3DMODEL_List self, PySliceObject * slice)
        __setitem__(FP_3DMODEL_List self, std::list< FP_3DMODEL >::difference_type i, FP_3DMODEL x)
        """
        return _pcbnew.FP_3DMODEL_List___setitem__(self, *args)

    def pop(self) -> "std::list< FP_3DMODEL >::value_type":
        r"""pop(FP_3DMODEL_List self) -> FP_3DMODEL"""
        return _pcbnew.FP_3DMODEL_List_pop(self)

    def append(self, x: "FP_3DMODEL") -> "void":
        r"""append(FP_3DMODEL_List self, FP_3DMODEL x)"""
        return _pcbnew.FP_3DMODEL_List_append(self, x)

    def empty(self) -> "bool":
        r"""empty(FP_3DMODEL_List self) -> bool"""
        return _pcbnew.FP_3DMODEL_List_empty(self)

    def size(self) -> "std::list< FP_3DMODEL >::size_type":
        r"""size(FP_3DMODEL_List self) -> std::list< FP_3DMODEL >::size_type"""
        return _pcbnew.FP_3DMODEL_List_size(self)

    def swap(self, v: "FP_3DMODEL_List") -> "void":
        r"""swap(FP_3DMODEL_List self, FP_3DMODEL_List v)"""
        return _pcbnew.FP_3DMODEL_List_swap(self, v)

    def begin(self) -> "std::list< FP_3DMODEL >::iterator":
        r"""begin(FP_3DMODEL_List self) -> std::list< FP_3DMODEL >::iterator"""
        return _pcbnew.FP_3DMODEL_List_begin(self)

    def end(self) -> "std::list< FP_3DMODEL >::iterator":
        r"""end(FP_3DMODEL_List self) -> std::list< FP_3DMODEL >::iterator"""
        return _pcbnew.FP_3DMODEL_List_end(self)

    def rbegin(self) -> "std::list< FP_3DMODEL >::reverse_iterator":
        r"""rbegin(FP_3DMODEL_List self) -> std::list< FP_3DMODEL >::reverse_iterator"""
        return _pcbnew.FP_3DMODEL_List_rbegin(self)

    def rend(self) -> "std::list< FP_3DMODEL >::reverse_iterator":
        r"""rend(FP_3DMODEL_List self) -> std::list< FP_3DMODEL >::reverse_iterator"""
        return _pcbnew.FP_3DMODEL_List_rend(self)

    def clear(self) -> "void":
        r"""clear(FP_3DMODEL_List self)"""
        return _pcbnew.FP_3DMODEL_List_clear(self)

    def get_allocator(self) -> "std::list< FP_3DMODEL >::allocator_type":
        r"""get_allocator(FP_3DMODEL_List self) -> std::list< FP_3DMODEL >::allocator_type"""
        return _pcbnew.FP_3DMODEL_List_get_allocator(self)

    def pop_back(self) -> "void":
        r"""pop_back(FP_3DMODEL_List self)"""
        return _pcbnew.FP_3DMODEL_List_pop_back(self)

    def erase(self, *args) -> "std::list< FP_3DMODEL >::iterator":
        r"""
        erase(FP_3DMODEL_List self, std::list< FP_3DMODEL >::iterator pos) -> std::list< FP_3DMODEL >::iterator
        erase(FP_3DMODEL_List self, std::list< FP_3DMODEL >::iterator first, std::list< FP_3DMODEL >::iterator last) -> std::list< FP_3DMODEL >::iterator
        """
        return _pcbnew.FP_3DMODEL_List_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(FP_3DMODEL_List self) -> FP_3DMODEL_List
        __init__(FP_3DMODEL_List self, FP_3DMODEL_List other) -> FP_3DMODEL_List
        __init__(FP_3DMODEL_List self, std::list< FP_3DMODEL >::size_type size) -> FP_3DMODEL_List
        __init__(FP_3DMODEL_List self, std::list< FP_3DMODEL >::size_type size, FP_3DMODEL value) -> FP_3DMODEL_List
        """
        _pcbnew.FP_3DMODEL_List_swiginit(self, _pcbnew.new_FP_3DMODEL_List(*args))

    def push_back(self, x: "FP_3DMODEL") -> "void":
        r"""push_back(FP_3DMODEL_List self, FP_3DMODEL x)"""
        return _pcbnew.FP_3DMODEL_List_push_back(self, x)

    def front(self) -> "std::list< FP_3DMODEL >::value_type const &":
        r"""front(FP_3DMODEL_List self) -> FP_3DMODEL"""
        return _pcbnew.FP_3DMODEL_List_front(self)

    def back(self) -> "std::list< FP_3DMODEL >::value_type const &":
        r"""back(FP_3DMODEL_List self) -> FP_3DMODEL"""
        return _pcbnew.FP_3DMODEL_List_back(self)

    def assign(self, n: "std::list< FP_3DMODEL >::size_type", x: "FP_3DMODEL") -> "void":
        r"""assign(FP_3DMODEL_List self, std::list< FP_3DMODEL >::size_type n, FP_3DMODEL x)"""
        return _pcbnew.FP_3DMODEL_List_assign(self, n, x)

    def resize(self, *args) -> "void":
        r"""
        resize(FP_3DMODEL_List self, std::list< FP_3DMODEL >::size_type new_size)
        resize(FP_3DMODEL_List self, std::list< FP_3DMODEL >::size_type new_size, FP_3DMODEL x)
        """
        return _pcbnew.FP_3DMODEL_List_resize(self, *args)

    def insert(self, *args) -> "void":
        r"""
        insert(FP_3DMODEL_List self, std::list< FP_3DMODEL >::iterator pos, FP_3DMODEL x) -> std::list< FP_3DMODEL >::iterator
        insert(FP_3DMODEL_List self, std::list< FP_3DMODEL >::iterator pos, std::list< FP_3DMODEL >::size_type n, FP_3DMODEL x)
        """
        return _pcbnew.FP_3DMODEL_List_insert(self, *args)

    def pop_front(self) -> "void":
        r"""pop_front(FP_3DMODEL_List self)"""
        return _pcbnew.FP_3DMODEL_List_pop_front(self)

    def push_front(self, x: "FP_3DMODEL") -> "void":
        r"""push_front(FP_3DMODEL_List self, FP_3DMODEL x)"""
        return _pcbnew.FP_3DMODEL_List_push_front(self, x)

    def reverse(self) -> "void":
        r"""reverse(FP_3DMODEL_List self)"""
        return _pcbnew.FP_3DMODEL_List_reverse(self)
    __swig_destroy__ = _pcbnew.delete_FP_3DMODEL_List

# Register FP_3DMODEL_List in _pcbnew:
_pcbnew.FP_3DMODEL_List_swigregister(FP_3DMODEL_List)


def GetPluginForPath(libname):
    plugin_type = IO_MGR.GuessPluginTypeFromLibPath( libname );
    return IO_MGR.PluginFind(plugin_type)

def FootprintEnumerate(libname):
    plug = GetPluginForPath(libname)
    return plug.FootprintEnumerate(libname)

def FootprintLoad(libname,name):
    plug = GetPluginForPath(libname)
    return plug.FootprintLoad(libname,name)

def FootprintSave(libname,module):
    plug = GetPluginForPath(libname)
    return plug.FootprintSave(libname,module)

def FootprintDelete(libname,name):
    plug = GetPluginForPath(libname)
    plug.FootprintDelete(libname,name)

def FootprintLibCreate(libname):
    plug = GetPluginForPath(libname)
    plug.FootprintLibCreate(libname)

def FootprintLibDelete(libname):
    plug = GetPluginForPath(libname)
    plug.FootprintLibDelete(libname)

def FootprintIsWritable(libname):
    plug = GetPluginForPath(libname)
    plug.FootprintLibIsWritable(libname)

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

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

    @staticmethod
    def register_wizard(wizard: "PyObject *") -> "void":
        r"""register_wizard(PyObject * wizard)"""
        return _pcbnew.PYTHON_FOOTPRINT_WIZARD_LIST_register_wizard(wizard)

    @staticmethod
    def deregister_wizard(wizard: "PyObject *") -> "void":
        r"""deregister_wizard(PyObject * wizard)"""
        return _pcbnew.PYTHON_FOOTPRINT_WIZARD_LIST_deregister_wizard(wizard)

    def __init__(self):
        r"""__init__(PYTHON_FOOTPRINT_WIZARD_LIST self) -> PYTHON_FOOTPRINT_WIZARD_LIST"""
        _pcbnew.PYTHON_FOOTPRINT_WIZARD_LIST_swiginit(self, _pcbnew.new_PYTHON_FOOTPRINT_WIZARD_LIST())
    __swig_destroy__ = _pcbnew.delete_PYTHON_FOOTPRINT_WIZARD_LIST

# Register PYTHON_FOOTPRINT_WIZARD_LIST in _pcbnew:
_pcbnew.PYTHON_FOOTPRINT_WIZARD_LIST_swigregister(PYTHON_FOOTPRINT_WIZARD_LIST)

def PYTHON_FOOTPRINT_WIZARD_LIST_register_wizard(wizard: "PyObject *") -> "void":
    r"""PYTHON_FOOTPRINT_WIZARD_LIST_register_wizard(PyObject * wizard)"""
    return _pcbnew.PYTHON_FOOTPRINT_WIZARD_LIST_register_wizard(wizard)

def PYTHON_FOOTPRINT_WIZARD_LIST_deregister_wizard(wizard: "PyObject *") -> "void":
    r"""PYTHON_FOOTPRINT_WIZARD_LIST_deregister_wizard(PyObject * wizard)"""
    return _pcbnew.PYTHON_FOOTPRINT_WIZARD_LIST_deregister_wizard(wizard)

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

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

    @staticmethod
    def register_action(wizard: "PyObject *") -> "void":
        r"""register_action(PyObject * wizard)"""
        return _pcbnew.PYTHON_ACTION_PLUGINS_register_action(wizard)

    @staticmethod
    def deregister_action(wizard: "PyObject *") -> "void":
        r"""deregister_action(PyObject * wizard)"""
        return _pcbnew.PYTHON_ACTION_PLUGINS_deregister_action(wizard)

    def __init__(self):
        r"""__init__(PYTHON_ACTION_PLUGINS self) -> PYTHON_ACTION_PLUGINS"""
        _pcbnew.PYTHON_ACTION_PLUGINS_swiginit(self, _pcbnew.new_PYTHON_ACTION_PLUGINS())
    __swig_destroy__ = _pcbnew.delete_PYTHON_ACTION_PLUGINS

# Register PYTHON_ACTION_PLUGINS in _pcbnew:
_pcbnew.PYTHON_ACTION_PLUGINS_swigregister(PYTHON_ACTION_PLUGINS)

def PYTHON_ACTION_PLUGINS_register_action(wizard: "PyObject *") -> "void":
    r"""PYTHON_ACTION_PLUGINS_register_action(PyObject * wizard)"""
    return _pcbnew.PYTHON_ACTION_PLUGINS_register_action(wizard)

def PYTHON_ACTION_PLUGINS_deregister_action(wizard: "PyObject *") -> "void":
    r"""PYTHON_ACTION_PLUGINS_deregister_action(PyObject * wizard)"""
    return _pcbnew.PYTHON_ACTION_PLUGINS_deregister_action(wizard)


def ToMM(iu):
    if type(iu) in [int,float]:
        return float(iu) / float(IU_PER_MM)
    elif type(iu) in [wxPoint,wxSize,VECTOR2I]:
        return tuple(map(ToMM,iu))
    else:
        raise TypeError("ToMM() excpects int, float, wxPoint, wxSize or VECTOR2I, instead got type " + str(type(iu)))

def FromMM(mm):
    if type(mm) in [int,float]:
        return int(float(mm) * float(IU_PER_MM))
    elif type(mm) in [wxPoint,wxSize,VECTOR2I]:
        return tuple(map(FromMM,mm))
    else:
        raise TypeError("FromMM() expects int, float, wxPoint, wxSize or VECTOR2I, instead got type " + str(type(mm)))

def ToMils(iu):
    if type(iu) in [int,float]:
        return float(iu) / float(IU_PER_MILS)
    elif type(iu) in [wxPoint,wxSize,VECTOR2I]:
        return tuple(map(ToMils,iu))
    else:
        raise TypeError("ToMils() excpects int, float, wxPoint, wxSize or VECTOR2I, instead got type " + str(type(iu)))

def FromMils(mils):
    if type(mils) in [int,float]:
        return int(float(mils)*float(IU_PER_MILS))
    elif type(mils) in [wxPoint,wxSize,VECTOR2I]:
        return tuple(map(FromMils,mils))
    else:
        raise TypeError("FromMils() excpects int, float, wxPoint, wxSize or VECTOR2I, instead got type " + str(type(mils)))

def PutOnGridMM(value, gridSizeMM):
    thresh = FromMM(gridSizeMM)
    return round(value/thresh)*thresh

def PutOnGridMils(value, gridSizeMils):
    thresh = FromMils(gridSizeMils)
    return round(value/thresh)*thresh

def wxSizeMM(mmx,mmy):
    return wxSize(FromMM(mmx),FromMM(mmy))

def wxSizeMils(mmx,mmy):
    return wxSize(FromMils(mmx),FromMils(mmy))

def wxPointMM(mmx,mmy):
    return wxPoint(FromMM(mmx),FromMM(mmy))

def wxPointMils(mmx,mmy):
    return wxPoint(FromMils(mmx),FromMils(mmy))

def VECTOR2I_MM(mmx,mmy):
    return VECTOR2I(FromMM(mmx),FromMM(mmy))

def VECTOR2I_Mils(mmx,mmy):
    return VECTOR2I(FromMils(mmx),FromMils(mmy))

def wxRectMM(x,y,wx,wy):
    x = int(FromMM(x))
    y = int(FromMM(y))
    wx = int(FromMM(wx))
    wy = int (FromMM(wy))
    return wxRect(x,y,wx,wy)

def wxRectMils(x,y,wx,wy):
    x = int(FromMils(x))
    y = int(FromMils(y))
    wx = int(FromMils(wx))
    wy = int(FromMils(wy))
    return wxRect(x,y,wx,wy)

KICAD_VERSION_FULL = _pcbnew.KICAD_VERSION_FULL

KICAD_SEMANTIC_VERSION = _pcbnew.KICAD_SEMANTIC_VERSION

KICAD_MAJOR_VERSION = _pcbnew.KICAD_MAJOR_VERSION

KICAD_MINOR_VERSION = _pcbnew.KICAD_MINOR_VERSION

KICAD_PATCH_VERSION = _pcbnew.KICAD_PATCH_VERSION

KICAD_MAJOR_MINOR_VERSION = _pcbnew.KICAD_MAJOR_MINOR_VERSION

KICAD_WIN32_RC_PRODVER_STR = _pcbnew.KICAD_WIN32_RC_PRODVER_STR

KICAD_WIN32_RC_FILEVER_STR = _pcbnew.KICAD_WIN32_RC_FILEVER_STR


def Version():
    """Return the semantic version of KiCad"""
    return KICAD_SEMANTIC_VERSION

def FullVersion():
    """Return the full, git-based version of KiCad"""
    return KICAD_VERSION_FULL



