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

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

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

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__)


import weakref

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


obj__, object = object, Exception


object = obj__

MVIMPACT_ACQUIRE_MAJOR_VERSION = lib_mvIMPACT_acquire.MVIMPACT_ACQUIRE_MAJOR_VERSION
r"""
     Returns the major version number of the current mvIMPACT Acquire release.
    :rtype: int
    :return: The major version number of mvIMPACT Acquire
    """
MVIMPACT_ACQUIRE_MINOR_VERSION = lib_mvIMPACT_acquire.MVIMPACT_ACQUIRE_MINOR_VERSION
r"""
     Returns the minor version number of the current mvIMPACT Acquire release.
    :rtype: int
    :return: The minor version number of mvIMPACT Acquire
    """
MVIMPACT_ACQUIRE_RELEASE_VERSION = lib_mvIMPACT_acquire.MVIMPACT_ACQUIRE_RELEASE_VERSION
r"""
     Returns the release version number of the current mvIMPACT Acquire release.
    :rtype: int
    :return: The release version number of mvIMPACT Acquire
    """
MVIMPACT_ACQUIRE_BUILD_VERSION = lib_mvIMPACT_acquire.MVIMPACT_ACQUIRE_BUILD_VERSION
r"""
     Returns the build version number of the current mvIMPACT Acquire release.
    :rtype: int
    :return: The build version number of mvIMPACT Acquire
    """
MVIMPACT_ACQUIRE_VERSION_STRING = lib_mvIMPACT_acquire.MVIMPACT_ACQUIRE_VERSION_STRING
r"""
     Returns the full version number of the current mvIMPACT Acquire release as a string ("2.39.0.2982").
    :rtype: string
    :return: The full version string of mvIMPACT Acquire
    """
afAuto = lib_mvIMPACT_acquire.afAuto
r""" Controlled by the camera parameter."""
afOdd = lib_mvIMPACT_acquire.afOdd
r""" Only odd fields will be digitised."""
afEven = lib_mvIMPACT_acquire.afEven
r""" Only even fields will be digitised."""
afAny = lib_mvIMPACT_acquire.afAny
r""" Odd and even fields will be digitised."""
amContinuous = lib_mvIMPACT_acquire.amContinuous
r""" Continuous mode. This is the recommended mode when image data shall either be transferred constantly or when working with an externally triggered setup."""
amMultiFrame = lib_mvIMPACT_acquire.amMultiFrame
r"""
    In this mode *AcquisitionFrameCount* images will transferred by the device.
    When *AcquisitionFrameCount* have been send by the device, it will automatically stop
    to send more data
    """
amSingleFrame = lib_mvIMPACT_acquire.amSingleFrame
r"""
    In this mode the device always will always just send a single image when a data stream is started.
    This mode can be interesting, when the devices acquisition parameters change from image to
    image or when a lot of devices will be operated in the same system an bandwidth resources are
    limited.
    """
assbDefault = lib_mvIMPACT_acquire.assbDefault
r"""
    The default behaviour for acquisition start and stop.
    Most devices will only support this mode. When this mode is selected,
    the device driver will try to start and stop the transfer of data from
    the device automatically. Internally this will happen while image requests
    are being processed
    """
assbUser = lib_mvIMPACT_acquire.assbUser
r"""
    The user can control the start and stop of the data transfer from the device.
    In this mode, queuing of image request buffers and the actual streaming of
    data from the device is de-coupled. This can sometimes be favourable
    compared to the default behaviour e.g. when dealing with device drivers
    that do not accept new buffers while the acquisition engine is running.
    Also when working at very high frame rates, pre-queuing some buffer before
    starting the actual data transfer can help to avoid capture queue underruns
    and thus data loss.
    """
amCentered = lib_mvIMPACT_acquire.amCentered
r"""
     Use a small centered window for image processing.
     In this mode, a device and processing function dependent window in the middle of
     the AOI captured from the device will be used for the processing function.

     Since: 2.37.0

    Example:
     - Assume a device that can deliver 1280*960 pixels.

     Now in the centered AOI mode a processing function will use a window smaller than the AOI in the middle
     of the image.

     The starting point can be calculated by the formula:

     .. code-block:: c++

          offsetX = ( width - ( width / 2 ) ) / 2
          offsetY = ( height - ( height / 2 ) ) / 2

     The used AOI is just width / 2 * height / 2 thus takes up the center quarter of the selected AOI.

    Image: TAoiMode_amCentered.png

     In case of an AOI defined by the user, the central AOI of the delivered image is used.

     Deprecated: Up to version 2.36.0 the AOI had just a size of 50*50 pixels.
     The behavior was the following:
     - Assume a device that can deliver 640*480 pixels.
     - The user selects to capture an rectangular AOI starting at 100/100 with a width of 200*200
     Now in the centered AOI mode a processing function will use a window smaller than the AOI in the middle of the user defined AOI. This e.g. could be a rectangle starting at 150/150 with a
     width of 100*100.
     Image: TAoiMode_amCentered_upTo_2-36-0.png
    """
amFull = lib_mvIMPACT_acquire.amFull
r""" Use the complete image for image processing."""
amUseAoi = lib_mvIMPACT_acquire.amUseAoi
r""" Use a user defined AOI window for image processing."""
acsSlow = lib_mvIMPACT_acquire.acsSlow
r""" The controller will converge slowly to the desired value."""
acsMedium = lib_mvIMPACT_acquire.acsMedium
r""" The controller will converge to the desired value at medium speed."""
acsFast = lib_mvIMPACT_acquire.acsFast
r""" The controller will converge fast to the desired value."""
acsUserDefined = lib_mvIMPACT_acquire.acsUserDefined
r""" In this mode the user can control the behaviour of the closed loop(control circuit)."""
acmStandard = lib_mvIMPACT_acquire.acmStandard
r""" The standard auto control mode."""
acmDeviceSpecific = lib_mvIMPACT_acquire.acmDeviceSpecific
r"""
    A device specific auto control mode.
    **mvBlueFOX** **specific**:
    For mvBlueFOX devices of type 202b and 202d the operation in device specific AEC/AGC
    mode is limited in (non continuous)triggered-modes. AEC/AGC only works while the trigger
    signal is active. As these sensor types only support the trigger modes
    **mvIMPACT::acquire::ctmOnHighLevel** and **mvIMPACT::acquire::ctmOnLowLevel**
    'active' means that the required signal level for that mode(either *high* or *low)*
    is present.

    When this signal level is no longer present AEC/AGC will stop working and gain and exposure
    will be set to a static value. This is due to a limitation of the sensor chip. Effectively this
    means that for single frame triggering requiring short active pulses AEC/AGC is not possible.
    """
aecOff = lib_mvIMPACT_acquire.aecOff
r""" AEC is switched off."""
aecOn = lib_mvIMPACT_acquire.aecOn
r""" AEC is switched on."""
agcOff = lib_mvIMPACT_acquire.agcOff
r""" AGC is switched off."""
agcOn = lib_mvIMPACT_acquire.agcOn
r""" AGC is switched on."""
aocOff = lib_mvIMPACT_acquire.aocOff
r"""
    The automatic offset calibration is switched off.
    In this mode the offset can be adjusted manually.
    """
aocOn = lib_mvIMPACT_acquire.aocOn
r""" The automatic offset calibration is switched on."""
bcmLinearInterpolation = lib_mvIMPACT_acquire.bcmLinearInterpolation
r"""
    Linear interpolation.
    This mode is fast but especially sharp edges will appear slightly blurred in the
    resulting image.
    """
bcmAdaptiveEdgeSensing = lib_mvIMPACT_acquire.bcmAdaptiveEdgeSensing
r"""
    Adaptive edge sensing.
    This mode requires more CPU time than linear interpolation, but the resulting image more closely
    matches the original scene. Edges will be reconstructed with higher accuracy except for noisy images.
    For better results in noisy images **mvIMPACT::acquire::bcmLinearInterpolation** is the recommended mode.
    """
bcmAuto = lib_mvIMPACT_acquire.bcmAuto
r"""
    Auto.
    This mode automatically sets the Bayer conversion algorithm according to the format property of the camera description.
    """
bcmPacked = lib_mvIMPACT_acquire.bcmPacked
r"""
     Packed.
     In this mode the resulting image will have half the height of the source image. The following algorithm will be used for
     generating the resulting image:

    .. code-block:: c++

          1 2 3 4 ...   n
        1 R G R G ... R G
        2 G B G B ... G B

          | 1 | 2 | 3 | 4 | 5 |...| n |
        1 |RGB|RGB|RGB|RGB|RGB|...|RGB|

        R1(dest) = R11
        G1(dest) = (G12 + G21) / 2
        B1(dest) = B22
        R2(dest) = (R11 + R13) / 2
        G2(dest) = ((G12 + G21) / 2) + (G12 + G23)) / 2
        B2(dest) = (B22 + B24) / 2
        ...
        Rn(dest) = R1(n-1)
        Gn(dest) = (G1(n) + G2(n-1)) / 2
        Bn(dest) = B2(n)

     This mode is mainly useful for line scan cameras as for area cameras this would modify the aspect ratio.
     Since: 2.5.9
    """
bcmLinearPacked = lib_mvIMPACT_acquire.bcmLinearPacked
r"""
     Linear Packed.
     In this mode the resulting image will have half the height of the source image. The following algorithm will be used for
     generating the resulting image:

    .. code-block:: c++

          1 2 3 4 ...   n
        1 R G R G ... R G
        2 G B G B ... G B

          | 1 | 2 | 3 | 4 | 5 |...| n |
        1 |RGB|RGB|RGB|RGB|RGB|...|RGB|
        2 |RGB|RGB|RGB|RGB|RGB|...|RGB|

        R1(dest) = R11
        G1(dest) = G21
        B1(dest) = B22
        R2(dest) = (R11 + R13) / 2
        G2(dest) = G12
        B2(dest) = B22
        R3(dest) = R13
        G3(dest) = G23
        B3(dest) = (B22 + B24) / 2
        ...
        Rn(dest) = R1(n-1)
        Gn(dest) = G1(n)
        Bn(dest) = B2(n)

     This mode is mainly useful for line scan cameras as for area cameras this would modify the aspect ratio.
     Since: 2.5.9
    """
bcmAdaptiveEdgeSensingPlus = lib_mvIMPACT_acquire.bcmAdaptiveEdgeSensingPlus
r"""
    Adaptive edge sensing plus.
    This mode is even more demanding CPU-wise than adaptive edge sensing, but the resulting image is sharper
    and has fewer artifacts. The parameters of the sharpening filter can be set by the user, to fit specific needs.
    Since: 2.26.0
    """
bcmAdaptiveHomogeneityDirected = lib_mvIMPACT_acquire.bcmAdaptiveHomogeneityDirected
r"""
    Adaptive edge sensing plus.
    This mode is most demanding CPU-wise, but the resulting image will have the best possible quality.
    It is based on the following algorithm: K. Hirakawa, T.W. Parks, Adaptive Homogeneity-Directed Demosaicing Algorithm, IEEE Trans. Image Processing, March, 2005.
    Since: 2.27.0
    """
bmpUndefined = lib_mvIMPACT_acquire.bmpUndefined
r""" It is not known whether the buffer or image contains raw Bayer data or the buffer or image does NOT contain raw Bayer data."""
bmpGR = lib_mvIMPACT_acquire.bmpGR
r""" The buffer or image starts with a green-red line starting with a green pixel."""
bmpRG = lib_mvIMPACT_acquire.bmpRG
r""" The buffer or image starts with a green-red line starting with a red pixel."""
bmpBG = lib_mvIMPACT_acquire.bmpBG
r""" The buffer or image starts with a green-blue line starting with a blue pixel."""
bmpGB = lib_mvIMPACT_acquire.bmpGB
r""" The buffer or image starts with a green-blue line starting with a green pixel."""
bwbrUnknown = lib_mvIMPACT_acquire.bwbrUnknown
r""" No white balance calibration has been performed since start up."""
bwbrOK = lib_mvIMPACT_acquire.bwbrOK
r""" The white balance calibration has been performed successfully for the selected setting."""
bwbrErrorUnknown = lib_mvIMPACT_acquire.bwbrErrorUnknown
r""" An unknown error occurred during the white balance calibration for the selected setting."""
bwbrErrorTooDark = lib_mvIMPACT_acquire.bwbrErrorTooDark
r""" The previous white balance calibration failed because the reference image used for the calibration was too dark."""
bwbrErrorTooBright = lib_mvIMPACT_acquire.bwbrErrorTooBright
r""" The previous white balance calibration failed because the reference image used for the calibration was too bright."""
bfdit2V = lib_mvIMPACT_acquire.bfdit2V
r""" This input is assumed as logic '1' when the voltage applied to the input lies above about 2 Volts."""
bfdit10V = lib_mvIMPACT_acquire.bfdit10V
r""" This input is assumed as logic '1' when the voltage applied to the input lies above about 10 Volts."""
bffmOff = lib_mvIMPACT_acquire.bffmOff
r""" No footer."""
bffm64B = lib_mvIMPACT_acquire.bffm64B
r""" A 64 Byte footer (standard)."""
bffm512B = lib_mvIMPACT_acquire.bffm512B
r""" A long 512 Byte footer."""
bfiscNone = lib_mvIMPACT_acquire.bfiscNone
r""" A dummy constant to indicate, that this device does not have any capabilities defined by other constants belonging to this enumeration."""
bfiscExposure = lib_mvIMPACT_acquire.bfiscExposure
r""" The exposure time can be controlled by an application."""
bfiscExposureAuto = lib_mvIMPACT_acquire.bfiscExposureAuto
r""" This sensor can automatically control the exposure time."""
bfiscGain = lib_mvIMPACT_acquire.bfiscGain
r""" The gain can be controlled by an application."""
bfiscGainAuto = lib_mvIMPACT_acquire.bfiscGainAuto
r""" This sensor can automatically control the gain."""
bfiscOffset = lib_mvIMPACT_acquire.bfiscOffset
r""" The offset can be controlled by an application."""
bfiscOffsetAuto = lib_mvIMPACT_acquire.bfiscOffsetAuto
r""" This sensor can automatically control the offset."""
bfiscBinning = lib_mvIMPACT_acquire.bfiscBinning
r""" This sensor supports binning."""
bfiscTrigger = lib_mvIMPACT_acquire.bfiscTrigger
r""" This sensor supports triggered acquisition."""
bfiscFlash = lib_mvIMPACT_acquire.bfiscFlash
r""" This sensor can output the 'exposure active' signal(e.g. to control a flash)."""
bfiscLineTrigger = lib_mvIMPACT_acquire.bfiscLineTrigger
r""" This sensor supports line triggered acquisition."""
bfiscShadingCorrection = lib_mvIMPACT_acquire.bfiscShadingCorrection
r""" This sensor can perform shading correction."""
bfiscOverlappedExposure = lib_mvIMPACT_acquire.bfiscOverlappedExposure
r""" This sensor supports overlapped exposure."""
bfiscFrameDelay = lib_mvIMPACT_acquire.bfiscFrameDelay
r""" This sensor supports frame delay."""
bfiscLineDelay = lib_mvIMPACT_acquire.bfiscLineDelay
r""" This sensor supports line delay."""
bfiscAutoControlAOI = lib_mvIMPACT_acquire.bfiscAutoControlAOI
r""" This sensor supports to define an AOI for the AGC/AEC/AOC(Auto Offset Control) features."""
bfiscAutoControlSpeed = lib_mvIMPACT_acquire.bfiscAutoControlSpeed
r""" This sensor supports to define the control speed for the AGC/AEC/AOC(Auto Offset Control) features."""
bfiscAutoControlDelay = lib_mvIMPACT_acquire.bfiscAutoControlDelay
r""" This sensor supports to define a delay for the AGC/AEC/AOC(Auto Offset Control) features."""
bfiscTemperatureSensor = lib_mvIMPACT_acquire.bfiscTemperatureSensor
r""" This sensor supports a temperature sensor within the imager"""
bfoablFastest = lib_mvIMPACT_acquire.bfoablFastest
r""" Fastest Setting"""
bfoablVeryFast = lib_mvIMPACT_acquire.bfoablVeryFast
r""" Very fast Setting"""
bfoablFast = lib_mvIMPACT_acquire.bfoablFast
r""" Fast Setting"""
bfoablMedium = lib_mvIMPACT_acquire.bfoablMedium
r""" Medium Setting"""
bfoablSlow = lib_mvIMPACT_acquire.bfoablSlow
r""" Slow Setting"""
bfoablVerySlow = lib_mvIMPACT_acquire.bfoablVerySlow
r""" Very slow Setting"""
bfoablSlowest = lib_mvIMPACT_acquire.bfoablSlowest
r""" Slowest Setting"""
bfstStandard = lib_mvIMPACT_acquire.bfstStandard
r""" Standard Timing"""
bfstFastLineSkip = lib_mvIMPACT_acquire.bfstFastLineSkip
r"""
    Fast line skip timing
    In this mode a faster line skip timing will be used. This will result in a higher
    frame rate in partial scan mode, but might affect the image quality.

    Notes: 
    This mode is not available for every **mvBlueFOX** camera.
    """
bfstLowSmearLineSkip = lib_mvIMPACT_acquire.bfstLowSmearLineSkip
r""" This mode is not available for every **mvBlueFOX** camera."""
bfts16KB = lib_mvIMPACT_acquire.bfts16KB
r""" 16KB blocks."""
bfts32KB = lib_mvIMPACT_acquire.bfts32KB
r""" 32KB blocks."""
bfts64KB = lib_mvIMPACT_acquire.bfts64KB
r""" 64KB blocks."""
bfts128KB = lib_mvIMPACT_acquire.bfts128KB
r""" 128KB blocks."""
bfts256KB = lib_mvIMPACT_acquire.bfts256KB
r""" 256KB blocks."""
bfts512KB = lib_mvIMPACT_acquire.bfts512KB
r""" 512KB blocks."""
bfts1024KB = lib_mvIMPACT_acquire.bfts1024KB
r""" 1024KB blocks."""
bfts2048KB = lib_mvIMPACT_acquire.bfts2048KB
r""" 2048KB blocks."""
bFalse = lib_mvIMPACT_acquire.bFalse
r""" Off, false or logical low."""
bTrue = lib_mvIMPACT_acquire.bTrue
r""" On, true or logical high."""
bpdtUnknown = lib_mvIMPACT_acquire.bpdtUnknown
r"""
     The framework is not aware of the data type of the data in the provided buffer part
    From the application perspective this can be handled as raw data.
    """
bpdt2DImage = lib_mvIMPACT_acquire.bpdt2DImage
r"""
     Color or monochrome (2D) image.
    This part carries all the pixel data of given image (even if the image is represented by a single-plane pixel format).
    """
bpdt2DPlaneBiplanar = lib_mvIMPACT_acquire.bpdt2DPlaneBiplanar
r"""
     Single color plane of a planar (2D) image.
    The data should be linked with the other color planes to get the complete image. The complete image consists of 2 planes.
    The planes of a given planar image must be placed as consecutive parts within the buffer.
    """
bpdt2DPlaneTriplanar = lib_mvIMPACT_acquire.bpdt2DPlaneTriplanar
r"""
     Single color plane of a planar (2D) image.
    The data should be linked with the other color planes to get the complete image. The complete image consists of 3 planes.
    The planes of a given planar image must be placed as consecutive parts within the buffer.
    """
bpdt2DPlaneQuadplanar = lib_mvIMPACT_acquire.bpdt2DPlaneQuadplanar
r"""
     Single color plane of a planar (2D) image.
    The data should be linked with the other color planes to get the complete image. The complete image consists of 4 planes.
    The planes of a given planar image must be placed as consecutive parts within the buffer.
    """
bpdt3DImage = lib_mvIMPACT_acquire.bpdt3DImage
r"""
     3D image (pixel coordinates).
    This part carries all the pixel data of given image (even if the image is represented by a single-plane pixel format, for example when transferring the depth map only).
    """
bpdt3DPlaneBiplanar = lib_mvIMPACT_acquire.bpdt3DPlaneBiplanar
r"""
     Single color plane of a planar (3D) image.
    The data should be linked with the other color planes to get the complete image. The complete image consists of 2 planes.
    The planes of a given planar image must be placed as consecutive parts within the buffer.
    """
bpdt3DPlaneTriplanar = lib_mvIMPACT_acquire.bpdt3DPlaneTriplanar
r"""
     Single color plane of a planar (3D) image.
    The data should be linked with the other color planes to get the complete image. The complete image consists of 3 planes.
    The planes of a given planar image must be placed as consecutive parts within the buffer.
    """
bpdt3DPlaneQuadplanar = lib_mvIMPACT_acquire.bpdt3DPlaneQuadplanar
r"""
     Single color plane of a planar (3D) image.
    The data should be linked with the other color planes to get the complete image. The complete image consists of 4 planes.
    The planes of a given planar image must be placed as consecutive parts within the buffer.
    """
bpdtConfidenceMap = lib_mvIMPACT_acquire.bpdtConfidenceMap
r"""
     Confidence of the individual pixel values.
    Expresses the level of validity of given pixel values. Confidence map is always used together with one or more additional
    image-based parts matching 1:1 dimension-wise. Each value in the confidence map expresses level of validity of the image pixel at
    matching position.
    """
bpdtJPEG = lib_mvIMPACT_acquire.bpdtJPEG
r""" JPEG image data."""
bpdtJPEG2000 = lib_mvIMPACT_acquire.bpdtJPEG2000
r""" JPEG 2000 image data."""
camFull = lib_mvIMPACT_acquire.camFull
r""" Use the complete AOI window defined by the hardware or input data (sensor, camera)."""
camUser = lib_mvIMPACT_acquire.camUser
r""" Use a user defined AOI window."""
cbmOff = lib_mvIMPACT_acquire.cbmOff
r""" No Binning."""
cbmBinningH = lib_mvIMPACT_acquire.cbmBinningH
r""" Horizontal Binning (combines 2 adjacent columns)."""
cbmBinningV = lib_mvIMPACT_acquire.cbmBinningV
r""" Vertical Binning (combines 2 adjacent rows)."""
cbmBinningHV = lib_mvIMPACT_acquire.cbmBinningHV
r""" Combines **mvIMPACT::acquire::cbmBinningH** and **mvIMPACT::acquire::cbmBinningV**."""
cbmBinning3H = lib_mvIMPACT_acquire.cbmBinning3H
r""" Horizontal Binning (combines 4 adjacent columns)."""
cbmBinning3V = lib_mvIMPACT_acquire.cbmBinning3V
r""" Vertical Binning (combines 4 adjacent rows)."""
cbmBinning3H3V = lib_mvIMPACT_acquire.cbmBinning3H3V
r""" Combines **mvIMPACT::acquire::cbmBinning3H** and **mvIMPACT::acquire::cbmBinning3V**."""
cbmBinningHAvg = lib_mvIMPACT_acquire.cbmBinningHAvg
r""" Horizontal Binning with average (combines 2 adjacent columns and averages the result)."""
cbmBinningVAvg = lib_mvIMPACT_acquire.cbmBinningVAvg
r""" Vertical Binning with average (combines 2 adjacent rows and averages the result)."""
cbmBinningHVAvg = lib_mvIMPACT_acquire.cbmBinningHVAvg
r""" Combines **mvIMPACT::acquire::cbmBinningH** and **mvIMPACT::acquire::cbmBinningV**."""
cbmBinning3HAvg = lib_mvIMPACT_acquire.cbmBinning3HAvg
r""" Horizontal Binning with average (combines 4 adjacent columns and averages the result)."""
cbmBinning3VAvg = lib_mvIMPACT_acquire.cbmBinning3VAvg
r""" Vertical Binning with average (combines 4 adjacent rows and averages the result)."""
cbmBinning3H3VAvg = lib_mvIMPACT_acquire.cbmBinning3H3VAvg
r""" Combines **mvIMPACT::acquire::cbmBinning3H** and **mvIMPACT::acquire::cbmBinning3V**."""
cbmDroppingH = lib_mvIMPACT_acquire.cbmDroppingH
r""" Horizontal Dropping (drops every second column)."""
cbmDroppingV = lib_mvIMPACT_acquire.cbmDroppingV
r""" Vertical Dropping (drops every second row)."""
cbmDroppingHV = lib_mvIMPACT_acquire.cbmDroppingHV
r""" Combines **mvIMPACT::acquire::cbmDroppingH** and **mvIMPACT::acquire::cbmDroppingV**."""
cbmDropping3H = lib_mvIMPACT_acquire.cbmDropping3H
r""" Horizontal Dropping (drops 3 adjacent columns out of 4)."""
cbmDropping3V = lib_mvIMPACT_acquire.cbmDropping3V
r""" Vertical Binning (drops 3 adjacent rows out of 4)."""
cbmDropping3H3V = lib_mvIMPACT_acquire.cbmDropping3H3V
r""" Combines **mvIMPACT::acquire::cbmDropping3H** and **mvIMPACT::acquire::cbmDropping3V**."""
cdfUnknown = lib_mvIMPACT_acquire.cdfUnknown
r""" This is an unknown type."""
cdfMono = lib_mvIMPACT_acquire.cdfMono
r""" This is a mono data format."""
cdfBayer = lib_mvIMPACT_acquire.cdfBayer
r""" This is a Bayer format."""
cdfBayerPacked = lib_mvIMPACT_acquire.cdfBayerPacked
r""" This is a Bayer Packed format. For each object line there is a red and a blue raw line to calculate the resulting color line."""
cdfRGB = lib_mvIMPACT_acquire.cdfRGB
r""" This is a RGB format."""
cdfYUV = lib_mvIMPACT_acquire.cdfYUV
r""" This is a YUV format."""
cemStandard = lib_mvIMPACT_acquire.cemStandard
r"""
    Standard sequential mode.
    In this mode the sensor first is exposed and then afterwards the image readout
    is performed.
    """
cemOverlapped = lib_mvIMPACT_acquire.cemOverlapped
r"""
    Overlapped mode, expose during image readout.
    This only affects the behaviour of the acquisition in **mvIMPACT::acquire::TCameraTriggerMode**
    is set to **mvIMPACT::acquire::ctmContinuous**.

    In this mode the flash output should **NOT** be used. In any case the flash output will **NOT**
    work like in **mvIMPACT::acquire::cemStandard** but only a short pulse will be sent to
    the output.
    """
cemNoShutter = lib_mvIMPACT_acquire.cemNoShutter
r"""
    'No shutter' mode, switch off exposure control.
    This only affects the behaviour of the acquisition in **mvIMPACT::acquire::TCameraTriggerMode**
    is set to **mvIMPACT::acquire::ctmContinuous**. In this case the shutter of the camera is
    never closed. Thus the exposure time in this mode is equal to the reciprocal value of the
    current frame rate.
    """
ceseNo = lib_mvIMPACT_acquire.ceseNo
ceseFallingEdge = lib_mvIMPACT_acquire.ceseFallingEdge
ceseRisingEdge = lib_mvIMPACT_acquire.ceseRisingEdge
cesoAuto = lib_mvIMPACT_acquire.cesoAuto
cesoRed = lib_mvIMPACT_acquire.cesoRed
cesoGreen = lib_mvIMPACT_acquire.cesoGreen
cesoBlue = lib_mvIMPACT_acquire.cesoBlue
cesoExtern = lib_mvIMPACT_acquire.cesoExtern
cfmOff = lib_mvIMPACT_acquire.cfmOff
r""" Do not use the cameras flash output."""
cfmDigout0 = lib_mvIMPACT_acquire.cfmDigout0
r""" Output 0 will be active during the exposure period."""
cfmDigout1 = lib_mvIMPACT_acquire.cfmDigout1
r""" Output 1 will be active during the exposure period."""
cftStandard = lib_mvIMPACT_acquire.cftStandard
r""" Flash signal is on while the shutter is open on a frame shutter sensor or during the complete exposure period of a rolling shutter sensor."""
cftRollingShutterFlash = lib_mvIMPACT_acquire.cftRollingShutterFlash
r"""
    Flash signal is only on during the time all lines of a rolling shutter sensor are exposed.
    This time is always smaller or equal to the time defined by **mvIMPACT::acquire::cftStandard**.
    """
cftVSync = lib_mvIMPACT_acquire.cftVSync
r"""
    Flash signal is derived from the sensors internal VSync (Frame-sync. signal).
    The specific timing of this signal is hardware dependent. The signal can be used to synchronise
    a master camera with a flash or another camera with a rolling shutter sensor.
    """
cHDRmFixed0 = lib_mvIMPACT_acquire.cHDRmFixed0
r""" Fixed HDR parameter set 0."""
cHDRmFixed1 = lib_mvIMPACT_acquire.cHDRmFixed1
r""" Fixed HDR parameter set 1."""
cHDRmFixed2 = lib_mvIMPACT_acquire.cHDRmFixed2
r""" Fixed HDR parameter set 2."""
cHDRmFixed3 = lib_mvIMPACT_acquire.cHDRmFixed3
r""" Fixed HDR parameter set 3."""
cHDRmFixed4 = lib_mvIMPACT_acquire.cHDRmFixed4
r""" Fixed HDR parameter set 4."""
cHDRmFixed5 = lib_mvIMPACT_acquire.cHDRmFixed5
r""" Fixed HDR parameter set 5."""
cHDRmFixed6 = lib_mvIMPACT_acquire.cHDRmFixed6
r""" Fixed HDR parameter set 6."""
cHDRmUser = lib_mvIMPACT_acquire.cHDRmUser
r""" User specific HDR mode, controlled by additional parameters."""
citNone = lib_mvIMPACT_acquire.citNone
r""" The video signal is transmitted non interlaced, meaning that a complete image is transferred without interruption."""
citInterlaced = lib_mvIMPACT_acquire.citInterlaced
r"""
    The video signal is transferred interlaced.
    Here the camera transmits the video signal in two consecutive frames that form a complete
    image. The first frame contains all the even lines (0, 2, 4, ... ) of the image, while
    the second frame contains all odd lines of the image.
    """
citInvertedInterlaced = lib_mvIMPACT_acquire.citInvertedInterlaced
r"""
    The video signal is transferred interlaced with the two frames in reversed order.
    Here the camera transmits the video signal in two consecutive frames that form a complete
    image. The first frame contains all the odd lines (0, 2, 4, ... ) of the image, while
    the second frame contains all even lines of the image.
    """
cldvmActive = lib_mvIMPACT_acquire.cldvmActive
r""" The camera transmits a data valid (**DVAL**) signal, that should be evaluated by the frame grabber."""
cldvmInactive = lib_mvIMPACT_acquire.cldvmInactive
r""" The camera does not transmit a data valid (**DVAL**) signal, that should be evaluated by the frame grabber."""
coUndefined = lib_mvIMPACT_acquire.coUndefined
r""" Specifies an undefined output."""
coAuto = lib_mvIMPACT_acquire.coAuto
r""" Auto mode. Here the capture device tries to guess how the data is transmitted."""
coComposite = lib_mvIMPACT_acquire.coComposite
r""" The camera will offer an analogue composite video signal."""
coBase = lib_mvIMPACT_acquire.coBase
r""" The camera will offer **CameraLink(R) Base** compliant image data."""
coDigital = lib_mvIMPACT_acquire.coDigital
r""" The camera will offer digital image data."""
coSVideo = lib_mvIMPACT_acquire.coSVideo
r""" The camera will offer an analogue SVideo signal."""
coMedium = lib_mvIMPACT_acquire.coMedium
r""" The camera will offer **CameraLink(R) Medium** compliant image data."""
coRGB = lib_mvIMPACT_acquire.coRGB
r""" The camera will offer an analogue RGB signal."""
co2xComposite = lib_mvIMPACT_acquire.co2xComposite
r""" Two cameras will offer two synchronous analogue signals."""
co3xComposite = lib_mvIMPACT_acquire.co3xComposite
r""" Three cameras will offer three synchronous analogue signals."""
co4xComposite = lib_mvIMPACT_acquire.co4xComposite
r""" Four cameras will offer four synchronous analogue signals."""
coFull = lib_mvIMPACT_acquire.coFull
r""" The camera will offer **CameraLink(R) Full** compliant image data."""
coSDSDI = lib_mvIMPACT_acquire.coSDSDI
r""" The camera will offer serial digital interface(SDI) SD signal."""
coHDSDI = lib_mvIMPACT_acquire.coHDSDI
r""" The camera will offer serial digital interface(SDI) HD signal."""
co3GSDI = lib_mvIMPACT_acquire.co3GSDI
r""" The camera will offer serial digital interface(SDI) 3G signal."""
cpcStandard = lib_mvIMPACT_acquire.cpcStandard
r"""
    Standard sensor clocking.
    This is a legacy mode used by some devices only.
    """
cpcHighSpeed = lib_mvIMPACT_acquire.cpcHighSpeed
r"""
    High speed sensor clocking.
    This is a legacy mode used by some devices only.
    """
cpc6000KHz = lib_mvIMPACT_acquire.cpc6000KHz
r""" 6 MHz pixel clock."""
cpc8000KHz = lib_mvIMPACT_acquire.cpc8000KHz
r""" 8 MHz pixel clock."""
cpc10000KHz = lib_mvIMPACT_acquire.cpc10000KHz
r""" 10 MHz pixel clock."""
cpc12000KHz = lib_mvIMPACT_acquire.cpc12000KHz
r""" 12 MHz pixel clock."""
cpc13500KHz = lib_mvIMPACT_acquire.cpc13500KHz
r""" 13.5 MHz pixel clock."""
cpc20000KHz = lib_mvIMPACT_acquire.cpc20000KHz
r""" 20 MHz pixel clock."""
cpc24000KHz = lib_mvIMPACT_acquire.cpc24000KHz
r""" 24 MHz pixel clock."""
cpc24540KHz = lib_mvIMPACT_acquire.cpc24540KHz
r""" 24.54 MHz pixel clock."""
cpc27000KHz = lib_mvIMPACT_acquire.cpc27000KHz
r""" 27 MHz pixel clock."""
cpc32000KHz = lib_mvIMPACT_acquire.cpc32000KHz
r""" 32 MHz pixel clock."""
cpc37600KHz = lib_mvIMPACT_acquire.cpc37600KHz
r""" 37.6 MHz pixel clock."""
cpc40000KHz = lib_mvIMPACT_acquire.cpc40000KHz
r""" 40 MHz pixel clock."""
cpc50000KHz = lib_mvIMPACT_acquire.cpc50000KHz
r""" 50 MHz pixel clock."""
cpc57600KHz = lib_mvIMPACT_acquire.cpc57600KHz
r""" 57.6 MHz pixel clock."""
csmArea = lib_mvIMPACT_acquire.csmArea
r""" The connected camera is an area scan camera."""
csmLine = lib_mvIMPACT_acquire.csmLine
r""" The connected camera is an line scan camera."""
cspbr9600 = lib_mvIMPACT_acquire.cspbr9600
r""" 9600 baud"""
cspbr19200 = lib_mvIMPACT_acquire.cspbr19200
r""" 19200 baud"""
cspbr38400 = lib_mvIMPACT_acquire.cspbr38400
r""" 38400 baud"""
cspbr57600 = lib_mvIMPACT_acquire.cspbr57600
r""" 57600 baud"""
cspbr115200 = lib_mvIMPACT_acquire.cspbr115200
r""" 115200 baud"""
cspbr230400 = lib_mvIMPACT_acquire.cspbr230400
r""" 230400 baud"""
cspbr460800 = lib_mvIMPACT_acquire.cspbr460800
r""" 460800 baud"""
cspbr921600 = lib_mvIMPACT_acquire.cspbr921600
r""" 921600 baud"""
csmFrameShutter = lib_mvIMPACT_acquire.csmFrameShutter
r"""
    Standard Frame-Shutter mode.
    Start and stop of integration occurs at the same time for all pixels
    """
csmElectronicRollingShutter = lib_mvIMPACT_acquire.csmElectronicRollingShutter
r"""
    Electronic rolling shutter mode (ERS)
    Start and stop of integration occurs on a line by line base. Integration time is the same for all lines bit timing is slightly different
    """
csmGlobalResetRelease = lib_mvIMPACT_acquire.csmGlobalResetRelease
r"""
    Global reset release shutter (GRR)
    Start of integration occurs at the same time for all pixels. End of integration happens on a line per line base like with ERS.
    This is only useful with special lighting or an mechanical extra shutter
    """
csmFrameShutterWithFastCenterReadout = lib_mvIMPACT_acquire.csmFrameShutterWithFastCenterReadout
r""" Start and stop of integration will happen at the same time for all pixels. Uses optimization for fast centered Readout."""
cltxg1X = lib_mvIMPACT_acquire.cltxg1X
r""" One tap. Pixels are transmitted from left to right."""
cltxg1X2 = lib_mvIMPACT_acquire.cltxg1X2
r"""
    Two taps. Pixels are transmitted from left to right.
    Adjacent pixels are transmitted with one pixel clock.


    |clock cycle|Pixel from Tap 1|Pixel from Tap 2|
    |1|1|2|
    |2|3|4|
    |...|...|...|
    |W/2|W-1|W|
    """
cltxg2X = lib_mvIMPACT_acquire.cltxg2X
r"""
    Two taps. Sorting of data needed.
    The first tap will transmit the first half of each line, the second tap will transmit the second half
    of each line. Both taps will transmit pixels from left to right.


    |clock cycle|Pixel from Tap 1|Pixel from Tap 2|
    |1|1|W/2+1|
    |2|2|W/2+2|
    |...|...|...|
    |W/2|W/2|W|
    """
cltxg2XE = lib_mvIMPACT_acquire.cltxg2XE
r"""
    Two taps. Sorting of data needed.
    The first tap will transmit the first half of each line from left to right, the second tap will transmit the
    second half of the line from right to left.


    |clock cycle|Pixel from Tap 1|Pixel from Tap 2|
    |1|1|W|
    |2|2|W-1|
    |...|...|...|
    |W/2|W/2|W/2+1|
    """
cltxg2XM = lib_mvIMPACT_acquire.cltxg2XM
r"""
    Two taps. Sorting of data needed.
    The first tap will transmit the first half of each line from right to left, the second tap will transmit the
    second half of the line from left to right.


    |clock cycle|Pixel from Tap 1|Pixel from Tap 2|
    |1|W/2|W/2+1|
    |2|W/2-1|W/2+2|
    |...|...|...|
    |W/2|1|W|
    """
cltxg1X3 = lib_mvIMPACT_acquire.cltxg1X3
r"""
    Three taps. Pixels are transmitted from left to right.
    Adjacent pixels are transmitted with one pixel clock.


    |clock cycle|Pixel from Tap 1|Pixel from Tap 2|Pixel from Tap 3|
    |1|1|2|3|
    |2|4|5|6|
    |...|...|...|...|
    |W/3|W-2|W-1|W|
    """
cltxg3X = lib_mvIMPACT_acquire.cltxg3X
r"""
    Three taps. Each tap will transmit one third of each line, pixel are transmitted from left to right. Sorting of data needed.
    The first tap will transmit the first third of each line, the second tap will transmit the second third and the third tap will transmit the
    last third of each line from left to right.


    |clock cycle|Pixel from Tap 1|Pixel from Tap 2|Pixel from Tap 3|
    |1|1|W/3+1|2W/3+1|
    |2|2|W/3+2|2W/3+2|
    |...|...|...|...|
    |W/3|W/3|2W/3|W|
    """
cltxg1X4 = lib_mvIMPACT_acquire.cltxg1X4
r"""
    Four taps. Pixels are transmitted from left to right.
    Adjacent pixels are transmitted with one pixel clock.


    |clock cycle|Pixel from Tap 1|Pixel from Tap 2|Pixel from Tap 3|Pixel from Tap 4|
    |1|1|2|3|4|
    |2|5|6|7|8|
    |...|...|...|...|...|
    |W/4|W-3|W-2|W-1|W|
    """
cltxg4X = lib_mvIMPACT_acquire.cltxg4X
r"""
    Four taps. Each tap will transmit one fourth of each line, pixel are transmitted from left to right. Sorting of data needed.
    The first tap will transmit the first quarter of each line, the second tap will transmit the second quarter etc.


    |clock cycle|Pixel from Tap 1|Pixel from Tap 2|Pixel from Tap 3|Pixel from Tap 4|
    |1|1|W/4+1|2W/4+1|3W/4+1|
    |2|2|W/4+2|2W/4+2|3W/4+2|
    |...|...|...|...|...|
    |W/4|W/4|2W/4|3W/4|W|
    """
cltxg2X2 = lib_mvIMPACT_acquire.cltxg2X2
r"""
    Four taps. The first two taps will transmit the first half of the line, while the second two taps will transmit the second half of the line. Sorting of data needed.
    Both tap pairs will transmit their data from left to right.


    |clock cycle|Pixel from Tap 1|Pixel from Tap 2|Pixel from Tap 3|Pixel from Tap 4|
    |1|1|2|W/2+1|W/2+2|
    |2|3|4|W/2+3|W/2+4|
    |...|...|...|...|...|
    |W/4|W/2-1|W/2|W-1|W|
    """
cltxg2X2E = lib_mvIMPACT_acquire.cltxg2X2E
r"""
    Four taps. The first two taps will transmit the first half of the line, while the second two taps will transmit the second half of the line. Sorting of data needed.
    The first tap pair will transmit the data from left to right, while the second pair of taps will transfer the data from right to left.


    |clock cycle|Pixel from Tap 1|Pixel from Tap 2|Pixel from Tap 3|Pixel from Tap 4|
    |1|1|2|W-1|W|
    |2|3|4|W-3|W-2|
    |...|...|...|...|...|
    |W/4|W/2-1|W/2|W/2+1|W/2+2|
    """
cltxg2X2M = lib_mvIMPACT_acquire.cltxg2X2M
r"""
    Four taps. The first two taps will transmit the first half of the line, while the second two taps will transmit the second half of the line. Sorting of data needed.
    The first tap pair will transmit the data from right to left, while the second pair of taps will transfer the data from left to right.


    |clock cycle|Pixel from Tap 1|Pixel from Tap 2|Pixel from Tap 3|Pixel from Tap 4|
    |1|W/2-1|W/2|W/2+1|W/2+2|
    |2|W/2-3|W/2-2|W/2+3|W/2+4|
    |...|...|...|...|...|
    |W/4|1|2|W-1|W|
    """
cltxg4XE = lib_mvIMPACT_acquire.cltxg4XE
r"""
    Four taps. Each tap will transmit one quarter of the image. Sorting of data needed.
    The first two taps will transmit the data from left to right, while the second two taps will transfer the data from right to left.


    |clock cycle|Pixel from Tap 1|Pixel from Tap 2|Pixel from Tap 3|Pixel from Tap 4|
    |1|1|W/4+1|3W/4|W|
    |2|2|W/4+2|3W/4-1|W-1|
    |...|...|...|...|...|
    |W/4|W/4|W/2|W/2+1|3W/4+1|
    """
cltxg1X8 = lib_mvIMPACT_acquire.cltxg1X8
r"""
    Eight taps. Pixels are transmitted from left to right.
    Adjacent pixels are transmitted with one pixel clock.

    |clock cycle|Pixel from Tap 1|Pixel from Tap 2|Pixel from Tap 3|Pixel from Tap 4|Pixel from Tap 5|Pixel from Tap 6|Pixel from Tap 7|Pixel from Tap 8|
    |1|1|2|3|4|5|6|7|8|
    |2|9|10|11|12|13|14|15|16|
    |...|...|...|...|...|...|...|...|...|
    |W/8|W-7|W-6|W-5|W-4|W-3|W-2|W-1|W|
    """
cltxg8X = lib_mvIMPACT_acquire.cltxg8X
r"""
    Eight taps. Each tap will transmit one eighth of each line, pixel are transmitted from left to right. Sorting of data needed.
    The first tap will transmit the first eighth of each line, the second tap will transmit the second eighth etc.


    |clock cycle|Pixel from Tap 1|Pixel from Tap 2|Pixel from Tap 3|Pixel from Tap 4|Pixel from Tap 5|Pixel from Tap 6|Pixel from Tap 7|Pixel from Tap 8|
    |1|1|W/8+1|2W/8+1|3W/8+1|4W/8+1|5W/8+1|6W/8+1|7W/8+1|
    |2|2|W/8+2|2W/8+2|3W/8+2|4W/8+2|5W/8+2|6W/8+2|7W/8+2|
    |...|...|...|...|...|...|...|...|...|
    |W/8|W/8|2W/8|3W/8|4W/8|5W/8|6W/8|7W/8|W|
    """
cltxg4X2 = lib_mvIMPACT_acquire.cltxg4X2
r"""
    Eight taps. Every two taps will transmit one quarter of the line. Sorting of data needed.
    All tap pairs will transmit their data from left to right.


    |clock cycle|Pixel from Tap 1|Pixel from Tap 2|Pixel from Tap 3|Pixel from Tap 4|Pixel from Tap 5|Pixel from Tap 6|Pixel from Tap 7|Pixel from Tap 8|
    |1|1|2|W/4+1|W/4+2|W/2+1|W/2+2|3W/4+1|3W/4+2|
    |2|3|4|W/4+3|W/4+4|W/2+3|W/2+4|3W/4+3|3W/4+4|
    |...|...|...|...|...|...|...|...|...|
    |W/8|W/4-1|W/4|W/2-1|W/2|3W/4-1|3W/4|W-1|W|
    """
cltxg4X2E = lib_mvIMPACT_acquire.cltxg4X2E
r"""
    Eight taps. Every two taps will transmit one quarter of the line. Sorting of data needed.
    Taps 1 to 4 will transmit the data from left to right, while taps 5 to 8 will transmit the data from right to left.


    |clock cycle|Pixel from Tap 1|Pixel from Tap 2|Pixel from Tap 3|Pixel from Tap 4|Pixel from Tap 5|Pixel from Tap 6|Pixel from Tap 7|Pixel from Tap 8|
    |1|1|2|W/4+1|W/4+2|3W/4-1|3W/4|W-1|W|
    |2|3|4|W/4+3|W/4+4|3W/4-3|3W/4-2|W-3|W-2|
    |...|...|...|...|...|...|...|...|...|
    |W/8|W/4-1|W/4|W/2-1|W/2|W/2+1|W/2+2|3W/4+1|3W/4+2|


    Since: 2.4.0
    """
cltyg1Y = lib_mvIMPACT_acquire.cltyg1Y
r""" Lines from top to bottom."""
cltyg1Y2 = lib_mvIMPACT_acquire.cltyg1Y2
r""" Two neighbouring lines are transmitted during one FVAL"""
cltyg2YE = lib_mvIMPACT_acquire.cltyg2YE
r""" One line from top and one line from bottom are transmitted during one FVAL"""
ctmOff = lib_mvIMPACT_acquire.ctmOff
r""" The 'normal' camera image will be transmitted."""
ctmGreyRamp = lib_mvIMPACT_acquire.ctmGreyRamp
r""" A grey gradient will be transmitted by the camera."""
ctmMovingColor = lib_mvIMPACT_acquire.ctmMovingColor
r""" A color test image with some moving components in it will be displayed."""
ctmWBTest = lib_mvIMPACT_acquire.ctmWBTest
r""" A raw white Bayer image will be transmitted."""
ctmContinuous = lib_mvIMPACT_acquire.ctmContinuous
r"""
    Don't wait for trigger. In this mode the camera continuously exposes images with the current settings.
    However images are not transferred to the host system automatically in this mode,
    so **NO** CPU load or whatsoever is produced in this mode when the driver isn't asked
    for images by the user.

    This mode is recommended for most applications and will be available for every image sensor.

    When the user requests an image the image **AFTER** the next frame start will be returned.
    In applications that need fast but **NOT** continuous image transfer the **mvIMPACT::acquire::ctmOnDemand**
    therefore might be more interesting.
    """
ctmOnDemand = lib_mvIMPACT_acquire.ctmOnDemand
r"""
    Start frame expose when the software asks for an image.
    Here without image requests by the user the image sensor will not expose images. An exposure
    and image transmission will start immediately after at least one images has been requested
    by the user.

    When e.g. a camera in free running mode captures 30 images per sec. and the user needs
    an image every 40 ms (25 fps) this mode might be more suitable then **mvIMPACT::acquire::ctmContinuous**
    as in the continuous mode when asking for an image every 40 ms the user might need to wait
    for the next frame start which at 30 Hz in the worst case would result in a capture time
    of (1/30Hz)*2 = 66.6 ms when an image start has just been missed. In
    **mvIMPACT::acquire::ctmOnDemand** however the image exposure will be started immediately
    after the request reaches the camera thus no delay will be introduced.

    Notes: 
    In applications where the capture time can be disregarded because either the transfer time is
    much higher or the capture frequency is very low the difference between the
    **mvIMPACT::acquire::ctmOnDemand** and the **mvIMPACT::acquire::ctmContinuous** can
    be disregarded as well. However in this case **mvIMPACT::acquire::ctmContinuous** is recommended
    as this mode will be available for every sensor type and is more universal.
    """
ctmOnLowLevel = lib_mvIMPACT_acquire.ctmOnLowLevel
r"""
    Start the exposure of a frame when the trigger input is below the trigger threshold.
    Each time an image is requested and the trigger signal is below the trigger threshold a image will be captured.
    """
ctmOnHighLevel = lib_mvIMPACT_acquire.ctmOnHighLevel
r"""
    Start the exposure of a frame when the trigger input is above the trigger threshold.
    Each time an image is requested and the trigger signal is above the trigger threshold a image will be captured.
    """
ctmOnFallingEdge = lib_mvIMPACT_acquire.ctmOnFallingEdge
r""" Start the exposure of a frame when the trigger input level changes from high to low."""
ctmOnRisingEdge = lib_mvIMPACT_acquire.ctmOnRisingEdge
r""" Start the exposure of a frame when the trigger input level changes from low to high."""
ctmOnHighExpose = lib_mvIMPACT_acquire.ctmOnHighExpose
r""" Start frame expose when the trigger input level rises above the trigger threshold and expose while the trigger input level remains above this threshold."""
ctmOnLowExpose = lib_mvIMPACT_acquire.ctmOnLowExpose
r""" Start frame expose when the trigger input level falls below the trigger threshold and expose while the trigger input level remains below this threshold."""
ctmOnAnyEdge = lib_mvIMPACT_acquire.ctmOnAnyEdge
r""" Start the exposure of a frame when the trigger input level changes from high to low or from low to high."""
ctmFramerateControlled = lib_mvIMPACT_acquire.ctmFramerateControlled
r"""
    Start the exposure of a frame when the trigger input level changes from high to low or from low to high.
    This mode is behaves like ctmContinuous but allows the FPS-Rate to be controlled directly.
    """
ctsDigIn0 = lib_mvIMPACT_acquire.ctsDigIn0
r""" Uses digital input 0 as the source for the trigger signal."""
ctsDigIn1 = lib_mvIMPACT_acquire.ctsDigIn1
r""" Use digital input 1 as the source for the trigger signal."""
ctsRTCtrl = lib_mvIMPACT_acquire.ctsRTCtrl
r""" Use real time controller (RTCtrl) as the source for the trigger signal."""
ctsDigOut0 = lib_mvIMPACT_acquire.ctsDigOut0
r""" Uses digital output 0 as the source for the trigger signal (this allows a SW controlled trigger (or exposure))."""
ctsDigOut1 = lib_mvIMPACT_acquire.ctsDigOut1
r""" Uses digital output 1 as the source for the trigger signal (this allows a SW controlled trigger (or exposure))."""
ctsDigOut2 = lib_mvIMPACT_acquire.ctsDigOut2
r""" Uses digital output 2 as the source for the trigger signal (this allows a SW controlled trigger (or exposure))."""
ctsDigOut3 = lib_mvIMPACT_acquire.ctsDigOut3
r""" Uses digital output 3 as the source for the trigger signal (this allows a SW controlled trigger (or exposure))."""
csmVertical = lib_mvIMPACT_acquire.csmVertical
r""" The channels will be re-arranged one after the other thus the resulting image will have the same width but 'channel count' times more lines then the input image."""
csmHorizontal = lib_mvIMPACT_acquire.csmHorizontal
r""" The channels will be re-arranged next to each other thus the resulting image will have the same height but 'channel count' times more pixels per line."""
csmExtractSingle = lib_mvIMPACT_acquire.csmExtractSingle
r""" Only one selectable channel will be extracted and forwarded."""
ecmAuto = lib_mvIMPACT_acquire.ecmAuto
r""" Clamp pulse starts at 80 % of **ActiveVideoAoi/X** ."""
ecmUser = lib_mvIMPACT_acquire.ecmUser
r""" The user can set the clamp start time in micro sec. after the falling edge of the video signals' VSync."""
cticmmUser = lib_mvIMPACT_acquire.cticmmUser
r""" A user defined correction matrix."""
cticmmDeviceSpecific = lib_mvIMPACT_acquire.cticmmDeviceSpecific
r"""
    A device specific internally defined correction matrix.
    This will almost always be the best selection as then the driver
    internally uses the best matrix for known products.
    """
ctocmmUser = lib_mvIMPACT_acquire.ctocmmUser
r""" A user defined correction matrix."""
ctocmmXYZToAdobeRGB_D50 = lib_mvIMPACT_acquire.ctocmmXYZToAdobeRGB_D50
r"""
    Will apply the XYZ to Adobe RGB matrix with a D50 white reference.
    The following matrix will be applied:


    |Row 0|Row 1|Row 2|
    |1.9624274|-0.6105343|-0.3413404|
    |-0.9787684|1.9161415|0.0334540|
    |0.0286869|-0.1406752|1.3487655|
    """
ctocmmXYZTosRGB_D50 = lib_mvIMPACT_acquire.ctocmmXYZTosRGB_D50
r"""
    Will apply the XYZ to sRGB matrix with a D50 white reference.
    The following matrix will be applied:


    |Row 0|Row 1|Row 2|
    |3.1338561|-1.6168667|-0.4906146|
    |-0.9787684|1.9161415|0.0334540|
    |0.0719453|-0.2289914|1.4052427|
    """
ctocmmXYZToWideGamutRGB_D50 = lib_mvIMPACT_acquire.ctocmmXYZToWideGamutRGB_D50
r"""
    Will apply the XYZ to White Gamut RGB matrix with a D50 white reference.
    The following matrix will be applied:


    |Row 0|Row 1|Row 2|
    |1.4628067|-0.1840623|-0.2743606|
    |-0.5217933,|1.4472381|0.0677227|
    |0.0349342|-0.0968930|1.2884099|
    """
ctocmmXYZToAdobeRGB_D65 = lib_mvIMPACT_acquire.ctocmmXYZToAdobeRGB_D65
r"""
    Will apply the XYZ to Adobe RGB matrix with a D65 white reference.
    The following matrix will be applied:


    |Row 0|Row 1|Row 2|
    |2.0413690|-0.5649464|-0.3446944|
    |-0.9692660|1.8760108|0.0415560|
    |0.0134474|-0.1183897|1.0154096|
    """
ctocmmXYZTosRGB_D65 = lib_mvIMPACT_acquire.ctocmmXYZTosRGB_D65
r"""
    Will apply the XYZ to sRGB matrix with a D65 white reference.
    The following matrix will be applied:


    |Row 0|Row 1|Row 2|
    |3.2404542|-1.5371385|-0.4985314|
    |-0.9692660|1.8760108|0.0415560|
    |0.0556434|-0.2040259|1.0572252|
    """
cpmAuto = lib_mvIMPACT_acquire.cpmAuto
r""" The driver decides (depending on the connected camera) what kind of color processing has to be applied."""
cpmRaw = lib_mvIMPACT_acquire.cpmRaw
r""" No color processing will be performed."""
cpmBayer = lib_mvIMPACT_acquire.cpmBayer
r""" A Bayer color conversion will be applied before the image is transferred to the user."""
cpmBayerToMono = lib_mvIMPACT_acquire.cpmBayerToMono
r""" A Bayer to mono conversion will be applied before the image is transferred to the user."""
cpmRawToPlanes = lib_mvIMPACT_acquire.cpmRawToPlanes
r"""
    No color processing will be performed but the packed raw Bayer data will be re-arranged within the buffer.
    In the resulting image the top left quarter of the image will contain the red pixels,
    the top right quarter the blue pixels, the lower left quarter the green pixels from the
    red line and the lower right quarter the green pixels from the blue line:

           w: width, h: height
           R(0, 0)          R(0, 1), ...          R(0, (w-1)/2)          B(0, 0)          B(0, 1), ...          B(0, (w-1)/2)
           R(1, 0)          R(1, 1), ...          R(1, (w-1)/2)          B(1, 0)          B(1, 1), ...          B(1, (w-1)/2)
                     .
                     .
                     .
           R((h-1/2), 0)    R((h-1/2), 1), ...    R((h-1/2), (w-1)/2)    B((h-1/2), 0)    B((h-1/2), 1), ...    B((h-1/2), (w-1)/2)
           G(R)(0, 0)       G(R)(0, 1), ...       G(R)(0, (w-1)/2)       G(B)(0, 0)       G(B)(0, 1), ...       G(B)(0, (w-1)/2)
           G(R)(1, 0)       G(R)(1, 1), ...       G(R)(1, (w-1)/2)       G(B)(1, 0)       G(B)(1, 1), ...       G(B)(1, (w-1)/2)
                     .
                     .
                     .
           G(R)((h-1/2), 0) G(R)((h-1/2), 1), ... G(R)((h-1/2), (w-1)/2) G(B)((h-1/2), 0) G(B)((h-1/2), 1), ... G(B)((h-1/2), (w-1)/2)
    """
dcfmOff = lib_mvIMPACT_acquire.dcfmOff
r""" The filter is switched off."""
dcfmOn = lib_mvIMPACT_acquire.dcfmOn
r""" The filter is switched on."""
dcfmCalibrateDarkCurrent = lib_mvIMPACT_acquire.dcfmCalibrateDarkCurrent
r"""
    The next selected number of images will be taken for calculating the dark current correction image.
    In this mode after the correction image has been calculated the mode will automatically switch back to
    **mvIMPACT::acquire::dcfmOff**
    """
dcfmTransmitCorrectionImage = lib_mvIMPACT_acquire.dcfmTransmitCorrectionImage
r"""
    In this mode whenever reaching this filter, the captured image will be replaced by the last correction image, that has been created as a result of the filter being calibrated.
    Since: 2.5.9
    """
dpfmOff = lib_mvIMPACT_acquire.dpfmOff
r""" This filter is switched off."""
dpfm3x1Average = lib_mvIMPACT_acquire.dpfm3x1Average
r""" The filter is active, detected defective pixels will be replaced with the average value from the left and right neighbor pixel."""
dpfm3x3Median = lib_mvIMPACT_acquire.dpfm3x3Median
r""" The filter is active, detected defective pixels will be replaced with the median value calculated from the nearest neighbors (3x3)."""
dpfmResetCalibration = lib_mvIMPACT_acquire.dpfmResetCalibration
r""" reset the calibration, delete all internal lists."""
dpfmCalibrateLeakyPixel = lib_mvIMPACT_acquire.dpfmCalibrateLeakyPixel
r"""
    Detect defective leaky pixels within the next frame captured.
    These are pixels that produce a higher read out value than the average when the sensor is not exposed.
    """
dpfmCalibrateColdPixel = lib_mvIMPACT_acquire.dpfmCalibrateColdPixel
r"""
    Detect defective cold pixels within the next frame captured.
    These are pixels that produce a lower read out code than the average when the sensor is exposed to light.
    """
dpfmCalibrateHotPixel = lib_mvIMPACT_acquire.dpfmCalibrateHotPixel
r"""
    Detect defective hot pixels within the next frame captured.
    These are pixels that produce a higher read out code than the average when the sensor is exposed to light.

    Since: 2.31.0
    """
dpfmCalibrateHotAndColdPixel = lib_mvIMPACT_acquire.dpfmCalibrateHotAndColdPixel
r"""
    Detect defective hot and cold pixels within the next frame captured.
    These are pixels that produce either a higher or a lower read out code than the average when the sensor is exposed to light. This
    effectively combines **mvIMPACT::acquire::dpfmCalibrateColdPixel** and **mvIMPACT::acquire::dpfmCalibrateHotPixel**

    Since: 2.31.0
    """
dpfmReplaceDefectivePixelAfter3x3Filter = lib_mvIMPACT_acquire.dpfmReplaceDefectivePixelAfter3x3Filter
r"""
     The filter is active, detected defective pixel will be replaced and treated as being fed into a 3x3 de-Bayer algorithm before reaching the filter.
     This is a rather special mode that only makes sense for very specific use cases:
     - Defective pixel data has been obtained by the filter from a device that did carry this data within it's non-volatile memory,
       the device itself does NOT provide a defective pixel replacement functionality and the device is
       operated in RGB or YUV mode using a 3 by 3 filter kernel. This will introduce artifacts in the pixels surrounding the defective pixel then and
       to compensate that a special handling is needed.
     - To reduce CPU load another use case might be to detect defective pixels on a device in Bayer mode using the defective pixel filter of this
       SDK and then switch the device into RGB mode if supported. Again this is only needed if the device itself does not offer a defective
       pixel compensation.

     A far better way to tackle this of course would be (in that order):
     - Compensate the defective pixels on the device BEFORE feeding the data into the Bayer filter
     - Switch the device to a Bayer format, compensate the defective pixels on the host and THEN feed the data into a host-based Bayer filter
     - Select a device with less defective pixels if these are causing harm to the application

    This mode will only operate on packed RGB or packed YUV444 data! It will assume that when given a pixel *p* all the surrounding pixels marked with a *d* in the following
    section need to be replaced as well(*-* stands for other pixels **NOT** affected by the replacement operation):

    .. code-block:: c++

         ---------------
         ---------------
         ----ddd--------
         ----dpd--------
         ----ddd--------
         ---------------

    Since: 2.33.0
    """
damUnknown = lib_mvIMPACT_acquire.damUnknown
r""" Unknown device access mode."""
damNone = lib_mvIMPACT_acquire.damNone
r""" No access to the device."""
damRead = lib_mvIMPACT_acquire.damRead
r"""
    Requested or obtained read access to the device.
    Properties can be read but can't be changed.
    """
damControl = lib_mvIMPACT_acquire.damControl
r"""
    Requested or obtained control access to the device.
    Properties can be read and changed, other applications might establish read
    access.
    """
damExclusive = lib_mvIMPACT_acquire.damExclusive
r"""
    Requested or obtained exclusive access to the device.
    Properties can be read and changed, other applications can't establish access to the device.
    """
daoOff = lib_mvIMPACT_acquire.daoOff
r""" No advanced option selected."""
daoLowLight = lib_mvIMPACT_acquire.daoLowLight
r"""
    Put camera in low light mode.
    This is a special feature offered by some sensors. Typically this will enable an additional analogue
    gain that will increase both the luminance and the noise of the resulting image. This feature can not
    be configured any further and there also is no additional information available on this topic.
    """
daoEmbeddedImageInfo = lib_mvIMPACT_acquire.daoEmbeddedImageInfo
r""" Embed sensor specific info into the image readout buffer."""
daoImageAverage = lib_mvIMPACT_acquire.daoImageAverage
r""" Calculate the average intensity value of the image and return as part of the request."""
daoPipelinedGainExposeControl = lib_mvIMPACT_acquire.daoPipelinedGainExposeControl
r"""
    Enable pipelined Gain/Exposure control.
    This will result in a changed exposure or gain value becoming active not with the next frame but the one after that.
    Changing Gain/Exposure will be faster in pipelined Gain/Exposure control mode.
    Since: 2.1.3
    """
daoOnDemandTriggerPreShot = lib_mvIMPACT_acquire.daoOnDemandTriggerPreShot
r"""
    Enable on demand trigger pre-shot option.
    This will trigger an internal image capture cycle on the sensor prior to the user requested frame.
    Can be used to remove variations in image quality when working with unstable frame rates.
    Since: 2.5.0
    """
daoLowFrameRateOptimization = lib_mvIMPACT_acquire.daoLowFrameRateOptimization
r"""
    Enable low frame rate optimization.
    This will result in a much reduced variation in the offset signal when changing the sensor frame rate or running
    the sensor at low frame rates. The offset will change slightly if switched on and the signal response is slightly reduced.
    """
daoEnablePerChannelOffsetCorrection = lib_mvIMPACT_acquire.daoEnablePerChannelOffsetCorrection
r"""
    Enable per channel offset correction.
    Allow per channel offset correction in non auto offset mode for sensors with a Bayer (RGGB) based analog path.
    The per channel offset value will be added to the master offset (Offset_pc).
    """
daoUseRawSensorGain = lib_mvIMPACT_acquire.daoUseRawSensorGain
r"""
    Enable raw sensor gain.
    Use mathematical correct gain for sensor setting. Thus increasing the gain by 6 dB will actually result in a factor of 2.
    However with this option enabled the gain range will include values so low that the pixel saturation charge will
    be with in ADC digitizer range thus an over-saturated image will contain pixels that do **NOT** contain the maximum
    value for the given pixel format.
    Since: 2.5.6
    """
daoTriggerSensorColumnCalibration = lib_mvIMPACT_acquire.daoTriggerSensorColumnCalibration
r"""
     Trigger sensor column correction.
    When switched on this triggers a single column correction calibration process when requesting an image.
    To do it again switch it off and on again. This should be done while no acquisition is running.
    Changing gain or AOI could make such a recalibration necessary.
    """
danpsmHighToLow = lib_mvIMPACT_acquire.danpsmHighToLow
r"""
     Start with the maximum possible packet size.
    If set to **mvIMPACT::acquire::danpsmHighToLow** the packet size auto negotiation starts with the NICs current MTU value. If this value is too
    large (in terms of not all network components support it) decreasing sizes will be tried until the optimal (thus highest value supported by all
    network components) has been found.

    Notes: This mode is optimal when working with network interfaces where Jumbo frames are enabled.
    """
danpsmLowToHigh = lib_mvIMPACT_acquire.danpsmLowToHigh
r"""
     Start with the minimal possible packet size.
    If set to **mvIMPACT::acquire::danpsmLowToHigh** the packet size auto negotiation starts with the smallest possible MTU. Afterwards increasing sizes
    will be tried until the optimal (thus highest value supported by all network components) has been found.

    Notes: This mode is optimal when nothing is known about the network configuration.
    """
dcNone = lib_mvIMPACT_acquire.dcNone
r""" A dummy constant to indicate, that this device does not have any capabilities defined by other constants belonging to this enumeration."""
dcHotplugable = lib_mvIMPACT_acquire.dcHotplugable
r""" This is a device that supports hot plugging."""
dcSelectableVideoInputs = lib_mvIMPACT_acquire.dcSelectableVideoInputs
r""" This is a device, that has more than one video input channel."""
dcNonVolatileUserMemory = lib_mvIMPACT_acquire.dcNonVolatileUserMemory
r""" This device has non volatile memory, the user can write to and read from."""
dcCameraDescriptionSupport = lib_mvIMPACT_acquire.dcCameraDescriptionSupport
r"""
    This device supports camera descriptions.
    This is a feature mainly interesting for frame grabbers.
    """
dcEventSupport = lib_mvIMPACT_acquire.dcEventSupport
r""" This device supports events."""
dcGeneric = lib_mvIMPACT_acquire.dcGeneric
r""" A generic device"""
dcCamera = lib_mvIMPACT_acquire.dcCamera
r""" A plain camera device"""
dcIntelligentCamera = lib_mvIMPACT_acquire.dcIntelligentCamera
r""" An intelligent camera device"""
dcFrameGrabber = lib_mvIMPACT_acquire.dcFrameGrabber
r""" A frame grabber device"""
dc3DCamera = lib_mvIMPACT_acquire.dc3DCamera
r""" A 3D camera"""
ddomManual = lib_mvIMPACT_acquire.ddomManual
r""" The digital output can be switched manually."""
ddomPulse = lib_mvIMPACT_acquire.ddomPulse
r""" A single pulse will be generated on the digital output."""
ddomUser = lib_mvIMPACT_acquire.ddomUser
r""" A user defined signal will be generated on the digital output."""
ddomExposureActive = lib_mvIMPACT_acquire.ddomExposureActive
r""" The digital output will change its state during the active exposure period of the image sensor and will switch back to its initial state again once the exposure period is over."""
ddomDigitalSignalPassThrough = lib_mvIMPACT_acquire.ddomDigitalSignalPassThrough
r""" A signal connected to a digital input is passed through to this digital output."""
ddomDigitalSignalPassThroughInv = lib_mvIMPACT_acquire.ddomDigitalSignalPassThroughInv
r""" A signal connected to a digital input is inverted and passed to this digital output."""
ddomInternalVD = lib_mvIMPACT_acquire.ddomInternalVD
r"""
    An internal VD sync. signal will be passed to this digital output.
    In case of a camera this e.g. might be the cameras internal VD signal. This then can be used to
    synchronize two or more cameras.
    """
ddomRealTimeController = lib_mvIMPACT_acquire.ddomRealTimeController
r""" The digital output is controlled by a **R**eal **T**ime **C**ontroller."""
ddomExposureAndAcquisitionActive = lib_mvIMPACT_acquire.ddomExposureAndAcquisitionActive
r""" When there is at least one outstanding request the digital output will change its state during the active exposure period of the image sensor and will switch back to its initial state again once the exposure period is over."""
ddomTemperatureOutOfRange = lib_mvIMPACT_acquire.ddomTemperatureOutOfRange
r""" Will change the state whenever the device temperature moves in or out of defined limits(**subject to change**!)."""
ditImmediately = lib_mvIMPACT_acquire.ditImmediately
r""" Acquisition starts with trigger event as fast as possible."""
ditAfterDigOutSignals = lib_mvIMPACT_acquire.ditAfterDigOutSignals
r""" Acquisition starts after all defined signals have been generated on the digital outputs."""
dilDeviceSpecific = lib_mvIMPACT_acquire.dilDeviceSpecific
r"""
    A device specific interface shall be used(**deprecated** for all GenICam compliant devices).
    For most devices supported by this SDK this will be the only interface layout
    available. In this interface layout also most of the features will have
    the same name and location for every device even if a device is operated
    using another device driver. However this interface layout requires the
    driver to have detailed information about the underlying hardware, thus
    it will not be available for any third party hardware which might be usable with
    a certain device driver.

    In contrast to the other interface layouts, this layout will use a *buffered* *property*
    *approach*. This means that consecutive buffers can be requested each using defined but
    different settings. At the time of requesting a buffer, the driver will internally store the
    current property settings and will re-program the hardware later at the time of processing
    this request if the current settings differ from the settings that shall be used for this request.

    Deprecated: 
    This interface layout has been declared **deprecated** for GenICam compliant devices(mvBlueCOUGAR-S,
    mvBlueCOUGAR-X and mvBlueCOUGAR-XD). For these products please use **mvIMPACT::acquire::dilGenICam**
    instead. Newer devices like the mvBlueFOX3 will not support this interface layout at all.

    See also: 'InterfaceLayouts_Differences'.
    """
dilGenICam = lib_mvIMPACT_acquire.dilGenICam
r"""
    A GenICam TM like interface layout shall be used.
    This interface layout will be available when a device is
    (or claims to be) compliant with a the GenICam TM standard, thus provides a GenICam TM
    compliant XML interface description. This also applies for third party devices, which can
    be used with the GenICam GenTL Producer of mvIMPACT Acquire.

    In this interface layout property value changes will always have immediate effect, thus when
    changing the exposure time directly **after** requesting a buffer this buffer might be captured
    with the new exposure time already depending on the time the buffer request is actually be processed.

    Notes: This interface layout will allow to access third party devices as well.

    See also: 'InterfaceLayouts'

    'InterfaceLayouts_Differences'.
    """
dlsAuto = lib_mvIMPACT_acquire.dlsAuto
r"""
     Tries to load settings automatically following an internal procedure.
     The load cycle at initialization time is like this:

    .. code-block:: c++

         look for a setting for this particular device (via serial number)
         if not found
           look for a setting for this device type (via string in property 'Product' )
           if not found
             look for a setting for this device family (via string in property 'Family' )
             if not found
               use the default settings

     Under Linux(R) the current directory will be searched for files named <serialNumber>.xml,
     <productString>.xml and <familyString.xml> while under Windows(R) the registry will
     be searched for keys with these names. This only happens once (when the device is opened)
    """
dlsNoLoad = lib_mvIMPACT_acquire.dlsNoLoad
r""" No stored settings will be loaded at start-up. The device will be initialized with the drivers default values."""
dpmOn = lib_mvIMPACT_acquire.dpmOn
r""" This device is switched on"""
dpmOff = lib_mvIMPACT_acquire.dpmOff
r"""
    This device is switched off.
    This might save a considerable amount of energy if the device isn't
    needed for a certain amount of time.
    """
dsrmAuto = lib_mvIMPACT_acquire.dsrmAuto
r""" Auto, scan rate of camera used."""
dsrmUser = lib_mvIMPACT_acquire.dsrmUser
r""" User, scan rate must be set manually."""
dsoseFrame = lib_mvIMPACT_acquire.dsoseFrame
r""" The signal generation on the digital outputs starts with the next frame start signal ( e.g.: VSync )."""
dsoseTrigger = lib_mvIMPACT_acquire.dsoseTrigger
r""" The signal generation on the digital outputs starts with the event defined in setting->camera->trigger."""
dsoseFrameAfterTrigger = lib_mvIMPACT_acquire.dsoseFrameAfterTrigger
r""" The signal generation on the digital outputs starts with next frame signal after the event defined in setting->camera->trigger."""
dsoseSyncInRisingEdge = lib_mvIMPACT_acquire.dsoseSyncInRisingEdge
r""" The signal generation on the digital outputs starts with the rising edge of SyncIn - signal. **CameraLink(R)** only!!!"""
dsoseSyncInFallingEdge = lib_mvIMPACT_acquire.dsoseSyncInFallingEdge
r""" The signal generation on the digital outputs starts with the falling edge of SyncIn - signal. **CameraLink(R)** only!!!"""
dsoseSyncInPassThrough = lib_mvIMPACT_acquire.dsoseSyncInPassThrough
r""" The SyncIn - signal is passed to the selected digital output. **CameraLink(R)** only!!!"""
dsoseSyncInPassThroughInv = lib_mvIMPACT_acquire.dsoseSyncInPassThroughInv
r""" The SyncIn - signal is inverted and passed to the selected digital output. **CameraLink(R)** only!!!"""
dsosePeriodically = lib_mvIMPACT_acquire.dsosePeriodically
r""" The signal generation on the digital outputs starts periodically. **CameraLink(R)** only!!!"""
dsoseTriggerInPassThrough = lib_mvIMPACT_acquire.dsoseTriggerInPassThrough
r""" The TriggerIn - signal is passed to the selected digital output. **CameraLink(R)** only!!!"""
dsoseTriggerInPassThroughInv = lib_mvIMPACT_acquire.dsoseTriggerInPassThroughInv
r""" The TriggerIn - signal is inverted and passed to the selected digital output. **CameraLink(R)** only!!!"""
dsoseFVALPassThrough = lib_mvIMPACT_acquire.dsoseFVALPassThrough
r""" The FVAL - signal is passed to the selected digital output. **CameraLink(R)** only!!!"""
dsoseFVALPassThroughInv = lib_mvIMPACT_acquire.dsoseFVALPassThroughInv
r""" The FVAL - signal is inverted and passed to the selected digital output. **CameraLink(R)** only!!!"""
dsoseFVALRisingEdge = lib_mvIMPACT_acquire.dsoseFVALRisingEdge
r""" The signal generation on the digital outputs starts with the rising edge of FVAL - signal. **CameraLink(R)** only!!!"""
dsAbsent = lib_mvIMPACT_acquire.dsAbsent
r"""
    The **mvIMPACT::acquire::Device** has been unplugged.
    The **mvIMPACT::acquire::Device** has present been since the **mvIMPACT::acquire::DeviceManager** has been initialized,
    but has been unplugged now and the driver has detected the unplugging of the device. Automatic detection of unplugging events
    is only possible for devices that support plug and play, other device drivers will only check if a device is still present
    if an application triggered this check.
    """
dsPresent = lib_mvIMPACT_acquire.dsPresent
r""" The **mvIMPACT::acquire::Device** is currently connected and initialized."""
dsInitializing = lib_mvIMPACT_acquire.dsInitializing
r""" The **mvIMPACT::acquire::Device** is connected and is currently initializing."""
dsUnreachable = lib_mvIMPACT_acquire.dsUnreachable
r"""
    This device is recognized, but can't be accessed currently.
    This e.g. can be the case, if this is a device connected via a network and the device
    does not respond to one of the recognized network protocols or if another client is already
    connected to this device and the device does not support multiple clients.
    """
dsPowerDown = lib_mvIMPACT_acquire.dsPowerDown
r""" This device is present, but currently switched into a low power consumption mode"""
dsomOff = lib_mvIMPACT_acquire.dsomOff
r""" Sync. signals off."""
dsomNonInterlaced = lib_mvIMPACT_acquire.dsomNonInterlaced
r""" A non interlaced HD-out/VD-out signal is generated."""
dsomInterlaced = lib_mvIMPACT_acquire.dsomInterlaced
r""" A interlaced HD-out/VD-out signal is generated."""
dtiStandard = lib_mvIMPACT_acquire.dtiStandard
r"""
    The standard trigger interface.
    When this trigger interface is used, the configuration of an external trigger
    signal can be done very easy. However more complex scenarios might not be
    possible using this view on the trigger configuration.
    """
dtiAdvanced = lib_mvIMPACT_acquire.dtiAdvanced
r"""
    The advanced view on the trigger interface.
    When this view on the interface is selected, all features offered by the device
    regarding the creation of trigger events will be visible. So more complex configurations are possible
    but more knowledge about the hardware is required as well.
    """
dtmOff = lib_mvIMPACT_acquire.dtmOff
r""" Trigger off"""
dtmOn = lib_mvIMPACT_acquire.dtmOn
r""" Trigger on"""
dtmFallingEdge = lib_mvIMPACT_acquire.dtmFallingEdge
r""" Trigger on falling edge of an external signal."""
dtmRisingEdge = lib_mvIMPACT_acquire.dtmRisingEdge
r""" Trigger on rising edge of an external signal."""
dtmPeriodically = lib_mvIMPACT_acquire.dtmPeriodically
r""" Timer is used to simulate trigger."""
dtmOnDemand = lib_mvIMPACT_acquire.dtmOnDemand
r""" Request simulates trigger."""
dtmStartRisingStopFalling = lib_mvIMPACT_acquire.dtmStartRisingStopFalling
r""" Line scan mode: Acquisition starts with rising edge and stops with falling edge of trigger ( mvTITAN/mvGAMMA-CL only )"""
dtmStartFallingStopRising = lib_mvIMPACT_acquire.dtmStartFallingStopRising
r""" Line scan mode: Acquisition starts with falling edge and stops with rising edge of trigger ( mvTITAN/mvGAMMA-CL only )"""
dtmLevelHigh = lib_mvIMPACT_acquire.dtmLevelHigh
r""" Trigger valid as long as the level of the source signal is high."""
dtmLevelLow = lib_mvIMPACT_acquire.dtmLevelLow
r""" Trigger valid as long as the level of the source signal is low."""
dtoOff = lib_mvIMPACT_acquire.dtoOff
r""" No trigger overlap is permitted."""
dtoReadOut = lib_mvIMPACT_acquire.dtoReadOut
r""" Trigger is accepted immediately after the exposure period."""
dtoPreviousFrame = lib_mvIMPACT_acquire.dtoPreviousFrame
r""" Trigger is accepted at any time during the capture of the previous frame."""
digioOff = lib_mvIMPACT_acquire.digioOff
r""" Digital I/O is in 'logic 0' state."""
digioOn = lib_mvIMPACT_acquire.digioOn
r""" Digital I/O is in 'logic 1' state."""
digioIgnore = lib_mvIMPACT_acquire.digioIgnore
r""" Digital Input is in 'ignore' state."""
digioKeep = lib_mvIMPACT_acquire.digioKeep
r""" Digital Output is kept in unchanged state."""
diommFrequency_Hz_10ms = lib_mvIMPACT_acquire.diommFrequency_Hz_10ms
r""" Measure frequency with a 10 ms gate time."""
diommFrequency_Hz_100ms = lib_mvIMPACT_acquire.diommFrequency_Hz_100ms
r""" Measure frequency with a 100 ms gate time."""
diomsInput0 = lib_mvIMPACT_acquire.diomsInput0
r""" Measurement will be done on digital input 0."""
diomsInput1 = lib_mvIMPACT_acquire.diomsInput1
r""" Measurement will be done on digital input 1."""
diomsInput2 = lib_mvIMPACT_acquire.diomsInput2
r""" Measurement will be done on digital input 2."""
diomsInput3 = lib_mvIMPACT_acquire.diomsInput3
r""" Measurement will be done on digital input 3."""
docmSoftware = lib_mvIMPACT_acquire.docmSoftware
r""" The digital output signal is generated by the on-board processor."""
docmRTC = lib_mvIMPACT_acquire.docmRTC
r""" The digital output signal is generated by a **R**eal **T**ime **C**ontroller that is part of the used hardware device."""
dsNone = lib_mvIMPACT_acquire.dsNone
r""" A dummy value to delete a mask or signal configuration."""
dsSignal1 = lib_mvIMPACT_acquire.dsSignal1
r""" A constant for digital signal 1."""
dsSignal2 = lib_mvIMPACT_acquire.dsSignal2
r""" A constant for digital signal 2."""
dsSignal3 = lib_mvIMPACT_acquire.dsSignal3
r""" A constant for digital signal 3."""
dsSignal4 = lib_mvIMPACT_acquire.dsSignal4
r""" A constant for digital signal 4."""
dsSignal5 = lib_mvIMPACT_acquire.dsSignal5
r""" A constant for digital signal 5."""
dsSignal6 = lib_mvIMPACT_acquire.dsSignal6
r""" A constant for digital signal 6."""
dsSignal7 = lib_mvIMPACT_acquire.dsSignal7
r""" A constant for digital signal 7."""
dsSignal8 = lib_mvIMPACT_acquire.dsSignal8
r""" A constant for digital signal 8."""
dsSignal9 = lib_mvIMPACT_acquire.dsSignal9
r""" A constant for digital signal 9."""
dsSignal10 = lib_mvIMPACT_acquire.dsSignal10
r""" A constant for digital signal 10."""
dsSignal11 = lib_mvIMPACT_acquire.dsSignal11
r""" A constant for digital signal 11."""
dsSignal12 = lib_mvIMPACT_acquire.dsSignal12
r""" A constant for digital signal 12."""
dsSignal13 = lib_mvIMPACT_acquire.dsSignal13
r""" A constant for digital signal 13."""
dsSignal14 = lib_mvIMPACT_acquire.dsSignal14
r""" A constant for digital signal 14."""
dsSignal15 = lib_mvIMPACT_acquire.dsSignal15
r""" A constant for digital signal 15."""
dsSignal16 = lib_mvIMPACT_acquire.dsSignal16
r""" A constant for digital signal 16."""
DMR_NO_ERROR = lib_mvIMPACT_acquire.DMR_NO_ERROR
r"""
     The function call was executed successfully.

    **[0]**
    """
DMR_DEV_NOT_FOUND = lib_mvIMPACT_acquire.DMR_DEV_NOT_FOUND
r"""
     The specified device can't be found.
     This error occurs either if an invalid device ID has been passed to the
     device manager or if the caller tried to close a device which currently
     isn't initialized.


    **[-2100]**
    """
DMR_INIT_FAILED = lib_mvIMPACT_acquire.DMR_INIT_FAILED
r"""
     The device manager couldn't be initialized.
     This is an internal error.


    **[-2101]**
    """
DMR_DRV_ALREADY_IN_USE = lib_mvIMPACT_acquire.DMR_DRV_ALREADY_IN_USE
r"""
     The device is already in use.
     This error e.g. will occur if this or another process has initialized this
     device already and an application tries to open the device once more or if a
     certain resource is available only once but shall be used twice.


    **[-2102]**
    """
DMR_DEV_CANNOT_OPEN = lib_mvIMPACT_acquire.DMR_DEV_CANNOT_OPEN
r"""
     The specified device couldn't be initialized.

    **[-2103]**
    """
DMR_NOT_INITIALIZED = lib_mvIMPACT_acquire.DMR_NOT_INITIALIZED
r"""
     The device manager or another module hasn't been initialized properly.
     This error occurs if the user tries e.g. to close the device manager without
     having initialized it before or if a library used internally or a module or device associated with that library has not been initialized properly or if


    **[-2104]**
    """
DMR_DRV_CANNOT_OPEN = lib_mvIMPACT_acquire.DMR_DRV_CANNOT_OPEN
r"""
     A device could not be initialized.
     In this case the log-file will contain detailed information about the source of the
     problem.


    **[-2105]**
    """
DMR_DEV_REQUEST_QUEUE_EMPTY = lib_mvIMPACT_acquire.DMR_DEV_REQUEST_QUEUE_EMPTY
r"""
     The devices request queue is empty.
     This error e.g. occurs if the user waits for an image request to become available at a
     result queue without having send an image request to the device before.

     It might also arise when trying to trigger an image with a software trigger mechanism
     before the acquisition engine has been completely started. In this case a small delay and
     then again calling the software trigger function will succeed.


    **[-2106]**
    """
DMR_DEV_REQUEST_CREATION_FAILED = lib_mvIMPACT_acquire.DMR_DEV_REQUEST_CREATION_FAILED
r"""
     A request object couldn't be created.
     The creation of a request object failed. This might e.g. happen, if the system
     runs extremely low on memory.


    **[-2107]**
    """
DMR_INVALID_PARAMETER = lib_mvIMPACT_acquire.DMR_INVALID_PARAMETER
r"""
     An invalid parameter has been passed to a function.
     This might e.g. happen if a function requiring a pointer to a structure has been passed
     an unassigned pointer or if a value has been passed, that is either too large or too small in
     that context.


    **[-2108]**
    """
DMR_EXPORTED_SYMBOL_NOT_FOUND = lib_mvIMPACT_acquire.DMR_EXPORTED_SYMBOL_NOT_FOUND
r"""
     One or more symbols needed in a detected driver library couldn't be resolved.
     In most cases this is an error handled internally. So the user will not receive this error
     code as a result of a call to an API function. However when the user tries to get access
     to an **IMPACT** buffer type while the needed **IMPACT Base libraries** are not installed
     on the target system this error code also might be returned to the user.


    **[-2109]**
    """
DEV_UNKNOWN_ERROR = lib_mvIMPACT_acquire.DEV_UNKNOWN_ERROR
r"""
     An unknown error occurred while processing a user called driver function.

    **[-2110]**
    """
DEV_HANDLE_INVALID = lib_mvIMPACT_acquire.DEV_HANDLE_INVALID
r"""
     A driver function has been called with an invalid device handle.

    **[-2111]**
    """
DEV_INPUT_PARAM_INVALID = lib_mvIMPACT_acquire.DEV_INPUT_PARAM_INVALID
r"""
     A driver function has been called but one or more of the input parameters are invalid.
     There are several possible reasons for this error:
     - an unassigned pointer has been passed to a function, that requires a valid pointer
     - one or more of the passed parameters are of an incorrect type
     - one or more parameters contain an invalid value (e.g. a filename that points to a file that can't
     be found, a value, that is larger or smaller than the allowed values.


    **[-2112]**
    """
DEV_WRONG_INPUT_PARAM_COUNT = lib_mvIMPACT_acquire.DEV_WRONG_INPUT_PARAM_COUNT
r"""
     A function has been called with an invalid number of input parameters.

    **[-2113]**
    """
DEV_CREATE_SETTING_FAILED = lib_mvIMPACT_acquire.DEV_CREATE_SETTING_FAILED
r"""
     The creation of a setting failed.
     This can either happen, when a setting with the same name as the one the user
     tried to create already exists or if the system can't allocate memory for the
     new setting.


    **[-2114]**
    """
DEV_REQUEST_CANT_BE_UNLOCKED = lib_mvIMPACT_acquire.DEV_REQUEST_CANT_BE_UNLOCKED
r"""
     The unlock for a **mvIMPACT::acquire::Request** object failed.
     This might happen, if the **mvIMPACT::acquire::Request** is
     not locked at the time of calling the unlock function. It either has been unlocked by the
     user already or this request has never been locked as the request so far has not been used to
     capture image data into its buffer. Another reason for this error might be that the user tries to
     unlock a request that is currently processed by the device driver.


    **[-2115]**
    """
DEV_INVALID_REQUEST_NUMBER = lib_mvIMPACT_acquire.DEV_INVALID_REQUEST_NUMBER
r"""
     The number for the **mvIMPACT::acquire::Request** object is invalid.
     The max. number for a **mvIMPACT::acquire::Request** object is
     the value of the property *RequestCount* in the **mvIMPACT::acquire::SystemSettings** list - 1.


    **[-2116]**
    """
DEV_LOCKED_REQUEST_IN_QUEUE = lib_mvIMPACT_acquire.DEV_LOCKED_REQUEST_IN_QUEUE
r"""
     A Request that hasn't been unlocked has been passed back to the driver.
     This error might occur if the user requested an image from the driver but hasn't
     unlocked the **mvIMPACT::acquire::Request** that will be used for this new
     image.


    **[-2117]**
    """
DEV_NO_FREE_REQUEST_AVAILABLE = lib_mvIMPACT_acquire.DEV_NO_FREE_REQUEST_AVAILABLE
r"""
     The user requested a new image, but no free **mvIMPACT::acquire::Request** object is available to process this request.

    **[-2118]**
    """
DEV_WAIT_FOR_REQUEST_FAILED = lib_mvIMPACT_acquire.DEV_WAIT_FOR_REQUEST_FAILED
r"""
     The wait for a request failed.
     This might have several reasons:

      the user waited for an image, but no image has been requested before.

      the user waited for a requested image, but the image is still not ready(e.g. because of
     a short timeout and a long exposure time).

      a triggered image has been requested but no trigger signal has been detected within the
     wait period.

      a plug and play device(e.g. an USB device) has been unplugged and therefore can't deliver
     images anymore. In this case the *'state'* property should be checked to find out if the
     device is still present or not.



    **[-2119]**
    """
DEV_UNSUPPORTED_PARAMETER = lib_mvIMPACT_acquire.DEV_UNSUPPORTED_PARAMETER
r"""
     The user tried to get/set a parameter, which is not supported by this device.

    **[-2120]**
    """
DEV_INVALID_RTC_NUMBER = lib_mvIMPACT_acquire.DEV_INVALID_RTC_NUMBER
r"""
     The requested real time controller is not available for this device.

    **[-2121]**
    """
DMR_INTERNAL_ERROR = lib_mvIMPACT_acquire.DMR_INTERNAL_ERROR
r"""
     Some kind of internal error occurred.
     More information can be found in the *.log-file or the debug output.


    **[-2122]**
    """
DMR_INPUT_BUFFER_TOO_SMALL = lib_mvIMPACT_acquire.DMR_INPUT_BUFFER_TOO_SMALL
r"""
     The user allocated input buffer is too small to accommodate the result.

    **[-2123]**
    """
DEV_INTERNAL_ERROR = lib_mvIMPACT_acquire.DEV_INTERNAL_ERROR
r"""
     Some kind of internal error occurred in the device driver.
     More information can be found in the *.log-file or the debug output.


    **[-2124]**
    """
DMR_LIBRARY_NOT_FOUND = lib_mvIMPACT_acquire.DMR_LIBRARY_NOT_FOUND
r"""
     One or more needed libraries are not installed on the system.

    **[-2125]**
    """
DMR_FUNCTION_NOT_IMPLEMENTED = lib_mvIMPACT_acquire.DMR_FUNCTION_NOT_IMPLEMENTED
r"""
     A called function or accessed feature is not available for this device.

    **[-2126]**
    """
DMR_FEATURE_NOT_AVAILABLE = lib_mvIMPACT_acquire.DMR_FEATURE_NOT_AVAILABLE
r"""
     The feature in question is (currently) not available for this device or driver.
     This might be because another feature currently blocks the one in question from being accessible.
     More information can be found in the *.log-file or the debug output.


    **[-2127]**
    """
DMR_EXECUTION_PROHIBITED = lib_mvIMPACT_acquire.DMR_EXECUTION_PROHIBITED
r"""
     The user is not permitted to perform the requested operation.
     This e.g. might happen if the user tried to delete user data without specifying the
     required password.


    **[-2128]**
    """
DMR_FILE_NOT_FOUND = lib_mvIMPACT_acquire.DMR_FILE_NOT_FOUND
r"""
     The specified file can't be found.
     This might e.g. happen if the current working directory doesn't contain the file specified.


    **[-2129]**
    """
DMR_INVALID_LICENCE = lib_mvIMPACT_acquire.DMR_INVALID_LICENCE
r"""
     The licence doesn't match the device it has been assigned to.
     When e.g. upgrading a device feature each licence file is bound to a certain device. If the
     device this file has been assigned to has a different serial number then the one used
     to create the licence this error will occur.


    **[-2130]**
    """
DEV_SENSOR_TYPE_ERROR = lib_mvIMPACT_acquire.DEV_SENSOR_TYPE_ERROR
r"""
     There is no sensor found or the found sensor type is wrong or not supported.

    **[-2131]**
    """
DMR_CAMERA_DESCRIPTION_INVALID = lib_mvIMPACT_acquire.DMR_CAMERA_DESCRIPTION_INVALID
r"""
     A function call was associated with a camera description, that is invalid.
     One possible reason might be, that the camera description has been deleted(driver closed?).

     Since: 1.5.0


    **[-2132]**
    """
DMR_NEWER_LIBRARY_REQUIRED = lib_mvIMPACT_acquire.DMR_NEWER_LIBRARY_REQUIRED
r"""
     A suitable driver library to work with the device manager has been detected, but it is too old to work with this version of the mvDeviceManager library.
     This might happen if two different drivers have been installed on the target system and
     one introduces a newer version of the device manager that is not compatible with the older
     driver installed on the system. In this case this error message will be written into the
     log-file together with the name of the library that is considered to be too old.

     The latest drivers will always be available online under **www.matrix-vision.de**. There
     will always be an updated version of the library considered to be too old for download from
     here.

     Since: 1.6.6


    **[-2133]**
    """
DMR_TIMEOUT = lib_mvIMPACT_acquire.DMR_TIMEOUT
r"""
     A general timeout occurred.
     This is the typical result of functions that wait for some condition to be met with a timeout
     among their parameters.

     More information can be found in the *.log-file or the debug output.

     Since: 1.7.2


    **[-2134]**
    """
DMR_WAIT_ABANDONED = lib_mvIMPACT_acquire.DMR_WAIT_ABANDONED
r"""
     A wait operation has been aborted.
     This e.g. might occur if the user waited for some message to be returned by the driver and the
     device driver has been closed within another thread. In order to inform the user that this waiting operation
     terminated in an unusual wait, **mvIMPACT::acquire::DMR_WAIT_ABANDONED** will be returned then.

     Since: 1.7.2


    **[-2135]**
    """
DMR_EXECUTION_FAILED = lib_mvIMPACT_acquire.DMR_EXECUTION_FAILED
r"""
     The execution of a method object or reading/writing to a feature failed.
     More information can be found in the log-file.

     Since: 1.9.0


    **[-2136]**
    """
DEV_REQUEST_ALREADY_IN_USE = lib_mvIMPACT_acquire.DEV_REQUEST_ALREADY_IN_USE
r"""
     This request is currently used by the driver
     This error may occur if the user tries to send a certain request object to the driver by a call to the
     corresponding image request function.

     Since: 1.10.31


    **[-2137]**
    """
DEV_REQUEST_BUFFER_INVALID = lib_mvIMPACT_acquire.DEV_REQUEST_BUFFER_INVALID
r"""
     A request has been configured to use a user supplied buffer, but the buffer pointer associated with the request is invalid.

     Since: 1.10.31


    **[-2138]**
    """
DEV_REQUEST_BUFFER_MISALIGNED = lib_mvIMPACT_acquire.DEV_REQUEST_BUFFER_MISALIGNED
r"""
     A request has been configured to use a user supplied buffer, but the buffer pointer associated with the request has an incorrect alignment.
     Certain devices need aligned memory to perform efficiently thus when a user supplied buffer shall be used to
     capture data into this buffer must follow these alignment constraints

     Since: 1.10.31


    **[-2139]**
    """
DEV_ACCESS_DENIED = lib_mvIMPACT_acquire.DEV_ACCESS_DENIED
r"""
     The requested access to a device could not be granted.
     This might e.g. happen if an application tries to access a device exclusively that is already open in another
     process. This could also happen if a network device has already been opened with control access from another system
     and the current system also tries to establish control access to the device.

     Since: 1.10.39


    **[-2140]**
    """
DMR_PRELOAD_CHECK_FAILED = lib_mvIMPACT_acquire.DMR_PRELOAD_CHECK_FAILED
r"""
     A pre-load condition for loading a device driver failed.
     Certain device drivers may depend on certain changes applied to the system in order to operate correctly.
     E.g. a device driver might need a certain environment variable to exist. When the device manager tries
     to load a device driver it performs some basic checks to detect problems like this. When one of these checks
     fails the device manager will not try to load the device driver and an error message will be written
     to the selected log outputs.

     Since: 1.10.52


    **[-2141]**
    """
DMR_CAMERA_DESCRIPTION_INVALID_PARAMETER = lib_mvIMPACT_acquire.DMR_CAMERA_DESCRIPTION_INVALID_PARAMETER
r"""
     One or more of the camera descriptions parameters are invalid for the grabber it is used with.
     There are multiple reasons for this error code. Detailed information can be found in the *.log-file.

     **POSSIBLE CAUSES:**

      The TapsXGeometry or TapsYGeometry parameter of the selected camera description cannot be used with a user defined AOI.

      A scan standard has been selected, that is not supported by this device.

      An invalid scan rate has been selected.

      ...


     This error code will be returned by frame grabbers only.

     Since: 1.10.57


    **[-2142]**
    """
DMR_FILE_ACCESS_ERROR = lib_mvIMPACT_acquire.DMR_FILE_ACCESS_ERROR
r"""
     A general error returned whenever there has been a problem with accessing a file.
     There can be multiple reasons for this error and a detailed error message will be sent to the log-output
     whenever this error code is returned.

     **POSSIBLE CAUSES:**

      The driver tried to modify a file, for which it has no write access

      The driver tried to read from a file, for which it has no read access

      ...


     Since: 1.10.87


    **[-2143]**
    """
DMR_INVALID_QUEUE_SELECTION = lib_mvIMPACT_acquire.DMR_INVALID_QUEUE_SELECTION
r"""
     An error returned when the user application attempts to operate on an invalid queue.
     Since: 1.11.0


    **[-2144]**
    """
DMR_ACQUISITION_ENGINE_BUSY = lib_mvIMPACT_acquire.DMR_ACQUISITION_ENGINE_BUSY
r"""
     An error returned when the user application attempts to start the acquisition engine at a time, where it is already running.
     Since: 2.5.3


    **[-2145]**
    """
DMR_BUSY = lib_mvIMPACT_acquire.DMR_BUSY
r"""
     An error returned when the user application attempts to perform any operation that currently for any reason cannot be started because something else already running.
     The log-output will provide additional information.

     Since: 2.32.0


    **[-2146]**
    """
DMR_OUT_OF_MEMORY = lib_mvIMPACT_acquire.DMR_OUT_OF_MEMORY
r"""
     An error returned when for any reason internal resources (memory, handles, ...) cannot be allocated.
     The log-output will provide additional information.

     Since: 2.32.0


    **[-2147]**
    """
DMR_LAST_VALID_ERROR_CODE = lib_mvIMPACT_acquire.DMR_LAST_VALID_ERROR_CODE
r"""
     Defines the last valid error code value for device and device manager related errors.

    **[-2199]**
    """
efmAuto = lib_mvIMPACT_acquire.efmAuto
r""" Fieldgate starts at 1/3 of a line and ends at 2/3 of a line."""
efmUser = lib_mvIMPACT_acquire.efmUser
r""" FieldGateStart and FieldGateWidth can be set in pixels."""
ffcmDefault = lib_mvIMPACT_acquire.ffcmDefault
r""" The default flat field correction is used."""
ffcmBrightPreserving = lib_mvIMPACT_acquire.ffcmBrightPreserving
r""" The flat field correction with clipping compensation is used. This mode prevents clipping artifacts when overexposing the image, but may cause missing codes in the histogram and a brighter image."""
fffmOff = lib_mvIMPACT_acquire.fffmOff
r""" The filter is switched off."""
fffmOn = lib_mvIMPACT_acquire.fffmOn
r""" The filter is switched on."""
fffmCalibrateFlatField = lib_mvIMPACT_acquire.fffmCalibrateFlatField
r"""
    The next selected number of images will be taken for calculating the flat field correction image.
    In this mode after the correction image has been calculated the mode will automatically switch back to
    **mvIMPACT::acquire::fffmOff**
    """
fffmTransmitCorrectionImage = lib_mvIMPACT_acquire.fffmTransmitCorrectionImage
r"""
    In this mode whenever reaching this filter, the captured image will be replaced by the last correction image, that has been created as a result of the filter being calibrated.
    Since: 2.5.9
    """
urNoUpdatePerformed = lib_mvIMPACT_acquire.urNoUpdatePerformed
r"""
    No update has been performed for this **mvIMPACT::acquire::Device**.
    No update has been performed in the current process since this device driver
    has been loaded in the current process address space.
    """
urUpdateFW = lib_mvIMPACT_acquire.urUpdateFW
r""" The **mvIMPACT::acquire::Device** is currently updating firmware."""
urUpdateFWError = lib_mvIMPACT_acquire.urUpdateFWError
r""" The **mvIMPACT::acquire::Device** indicates an error during updating firmware."""
urDevAlreadyInUse = lib_mvIMPACT_acquire.urDevAlreadyInUse
r"""
    The requested update couldn't be performed as the device is already in use.
    If another (or even the same) process uses the device, this hardware update can't be performed.
    To perform the requested update this device needs to be closed.
    """
urUpdateFWOK = lib_mvIMPACT_acquire.urUpdateFWOK
r""" The **mvIMPACT::acquire::Device** indicates that the firmware has been updated successfully."""
urSetDevID = lib_mvIMPACT_acquire.urSetDevID
r""" The **mvIMPACT::acquire::Device** is currently setting device ID."""
urSetDevIDError = lib_mvIMPACT_acquire.urSetDevIDError
r""" The **mvIMPACT::acquire::Device** signaled an error when setting device ID."""
urSetDevIDInvalidID = lib_mvIMPACT_acquire.urSetDevIDInvalidID
r"""
    An invalid device ID has been specified.
    Valid device ID lie within 0 and 250 including the upper and lower limit.
    """
urSetDevIDOK = lib_mvIMPACT_acquire.urSetDevIDOK
r""" The **mvIMPACT::acquire::Device** has successfully been assigned a new ID."""
urSetUserDataSizeError = lib_mvIMPACT_acquire.urSetUserDataSizeError
r""" Size Error in writing User Data to **mvIMPACT::acquire::Device** ."""
urSetUserDataWriteError = lib_mvIMPACT_acquire.urSetUserDataWriteError
r""" Write Error in writing User Data to **mvIMPACT::acquire::Device** ."""
urSetUserDataWriteOK = lib_mvIMPACT_acquire.urSetUserDataWriteOK
r""" Writing user data to **mvIMPACT::acquire::Device** was successful."""
urGetUserDataReadError = lib_mvIMPACT_acquire.urGetUserDataReadError
r""" Reading user data from an **mvIMPACT::acquire::Device** failed."""
urVerifyFWError = lib_mvIMPACT_acquire.urVerifyFWError
r""" The **mvIMPACT::acquire::Device** indicates an error during verifying firmware."""
urVerifyFWOK = lib_mvIMPACT_acquire.urVerifyFWOK
r""" The **mvIMPACT::acquire::Device** indicates that the firmware has been verified successfully."""
I2ComRead = lib_mvIMPACT_acquire.I2ComRead
r""" Selects I2C read access."""
I2ComWrite = lib_mvIMPACT_acquire.I2ComWrite
r""" Selects I2C write access."""
I2CosSuccess = lib_mvIMPACT_acquire.I2CosSuccess
r""" The last I2C operation was successful."""
I2CosFailure = lib_mvIMPACT_acquire.I2CosFailure
r""" The last I2C operation did fail. The log-file might contain additional information"""
I2CosInvalidDeviceAddress = lib_mvIMPACT_acquire.I2CosInvalidDeviceAddress
r""" During the execution of the last I2C operation an invalid device address was specified."""
I2CosInvalidDeviceSubAddress = lib_mvIMPACT_acquire.I2CosInvalidDeviceSubAddress
r"""
    During the execution of the last I2C operation an invalid device sub-address was specified.
    This can either be caused by an invalid address or by an invalid address width.
    """
I2CosTooMuchData = lib_mvIMPACT_acquire.I2CosTooMuchData
r""" During the execution of the last I2C operation too much data was either requested or sent."""
I2CosNotEnoughData = lib_mvIMPACT_acquire.I2CosNotEnoughData
r""" During the execution of the last I2C operation the amount of data requested or sent was too small."""
ibpfRaw = lib_mvIMPACT_acquire.ibpfRaw
r""" An unprocessed block of data."""
ibpfMono8 = lib_mvIMPACT_acquire.ibpfMono8
r""" A single channel 8 bit per pixel format."""
ibpfMono16 = lib_mvIMPACT_acquire.ibpfMono16
r""" A single channel 16 bit per pixel format."""
ibpfRGBx888Packed = lib_mvIMPACT_acquire.ibpfRGBx888Packed
r"""
     A three channel RGB image with 32 bit per pixel containing one fill byte per pixel.
     This is an interleaved pixel format suitable for most display functions. The data
     is stored pixel-wise. The memory layout of the pixel data is like this:

    .. code-block:: c++

         4 bytes             4 bytes             etc.
         B(1) G(1) R(1) A(1) B(2) G(2) R(2) A(2) etc.
         .......................................
                             B(n) G(n) R(n) A(n)

     So the first byte in memory is the first pixels blue component. **ImageBuffer::vpData** will therefore
     point to B(1) when using a byte pointer.

    See also: 'Channel_Split_PackedToPlanar'
    """
ibpfYUV422Packed = lib_mvIMPACT_acquire.ibpfYUV422Packed
r"""
     This is a YUV422 packed image with 32 bit for a pair of pixels.
     This format uses 2:1 horizontal downsampling, which means that the Y component is
     sampled at each pixel, while U(Cb) and V(Cr) components are sampled every 2 pixels in
     horizontal direction. If each component takes 8 bits, the pair of pixels requires 32 bits.

     Two consecutive pixels (32 bit, 0xaabbccdd ) contain 8 bit luminance of pixel 1(aa),
     8 bit chrominance blue of pixel 1 and 2(bb), 8 bit luminance of pixel 2(cc) and finally 8 bit chrominance red of pixels 1 and 2(dd).

     Thus in memory the data will be stored like this:

    .. code-block:: c++

         4 bytes                   4 bytes                         etc.
         Y(1) Cb(1,2) Y(2) Cr(1,2) Y(3)   Cb(3,4)   Y(4) Cr(3,4)   etc.
         ..........................Y(n-1) Cb(n-1,n) Y(n) Cr(n-1,n)

     So the first byte in memory is the first pixels luminance component. **ImageBuffer::vpData** will therefore
     point to Y(1) when using a byte pointer.

    See also: 'Channel_Split_PackedToPlanar'
    """
ibpfRGBx888Planar = lib_mvIMPACT_acquire.ibpfRGBx888Planar
r"""
     The image will be transferred as an RGB image in planar format.
     This is a format best suitable for most image processing functions.
     The image will be converted into four planes(a plane for each color component and one
     alpha plane).

    .. code-block:: c++

         R(1) R(2) R(3) R(4) etc.
         ...................
         .............. R(n)
         G(1) G(2) G(3) G(4) etc.
         ...................
         .............. G(n)
         B(1) B(2) B(3) B(4) etc.
         ...................
         .............. B(n)
         A(1) A(2) A(3) A(4) etc.
         ...................
         .............. A(n)

     So the first byte in memory is the first pixels red component. **ImageBuffer::vpData** will therefore
     point to R(1) when using a byte pointer.
    """
ibpfMono10 = lib_mvIMPACT_acquire.ibpfMono10
r"""
    A single channel 10 bit per pixel format.
    Each pixel in this format consumes 2 bytes of memory. The lower 10 bit of this 2 bytes will contain valid data.
    """
ibpfMono12 = lib_mvIMPACT_acquire.ibpfMono12
r"""
    A single channel 12 bit per pixel format.
    Each pixel in this format consumes 2 bytes of memory. The lower 12 bit of this 2 bytes will contain valid data.
    """
ibpfMono14 = lib_mvIMPACT_acquire.ibpfMono14
r"""
    A single channel 14 bit per pixel format.
    Each pixel in this format consumes 2 bytes of memory. The lower 14 bit of this 2 bytes will contain valid data.
    """
ibpfRGB888Packed = lib_mvIMPACT_acquire.ibpfRGB888Packed
r"""
     The image will be transferred as an RGB image with 24 bit per pixel.
     This is an interleaved pixel format suitable for most display and processing functions.
     The data is stored pixel-wise:

    .. code-block:: c++

         3 bytes        3 bytes        3 bytes      etc.
         B(1)G(1)R(1)   B(2)G(2)R(2)   B(3)G(3)R(3) etc.
         ..........................................
         ...........................   B(n)G(n)R(n)

     So the first byte in memory is the first pixels blue component. **ImageBuffer::vpData** will therefore
     point to B(1) when using a byte pointer.

    See also: 'Channel_Split_PackedToPlanar'
    """
ibpfYUV444Planar = lib_mvIMPACT_acquire.ibpfYUV444Planar
r"""
     This is a YUV444 planar image with 24 bit per pixels.
     A planar YUV format. In memory the data will be stored plane-wise like this:

    .. code-block:: c++

         Y(1)    Y(2)    Y(3)    Y(4) etc.
         ............................
         ..............  Y(n-1)  Y(n)
         Cr(1)   Cr(2)   Cr(3)   Cr(4) etc.
         ............................
         ..............  Cr(n-1) Cr(n)
         Cb(1)   Cb(2)   Cb(3)   Cb(4) etc.
         ............................
         .............   Cb(n-1) Cb(n)

     So the first byte in memory is the first pixels luminance component. **ImageBuffer::vpData** will therefore
     point to Y(1) when using a byte pointer.
    """
ibpfMono32 = lib_mvIMPACT_acquire.ibpfMono32
r""" A single channel 32 bit per pixel format."""
ibpfYUV422Planar = lib_mvIMPACT_acquire.ibpfYUV422Planar
r"""
     This is a YUV422 planar image with 32 bit for a pair of pixels.
     This format uses 2:1 horizontal downsampling, which means that the Y component is
     sampled at each pixel, while U(Cb) and V(Cr) components are sampled every 2 pixels in
     horizontal direction. If each component takes 8 bits, the pair of pixels requires 32 bits.

     In memory the data will be stored like this:

    .. code-block:: c++

         Y(1)    Y(2)    Y(3)    Y(4) etc.
         ............................
         ..............  Y(n-1)  Y(n)
         Cr(1,2) Cr(3,4) etc.
         ...............
         ....... Cr(n/2)
         Cb(1,2) Cb(3,4) etc.
         ...............
         ....... Cb(n/2)

     Thus the Y planes size in bytes equals the sum of the 2 other planes.

     So the first byte in memory is the first pixels luminance component. **ImageBuffer::vpData** will therefore
     point to Y(1) when using a byte pointer.
    """
ibpfRGB101010Packed = lib_mvIMPACT_acquire.ibpfRGB101010Packed
r"""
     The image will be transferred as an RGB image with 30 bit of usable data per pixel.
     This is an interleaved pixel format with 2 bytes per color component.
     The data is stored pixel-wise:

    .. code-block:: c++

         6 bytes        6 bytes        6 bytes      etc.
         B(1)G(1)R(1)   B(2)G(2)R(2)   B(3)G(3)R(3) etc.
         ..........................................
         ...........................   B(n)G(n)R(n)

     The data of each color component will be LSB aligned, thus the 6 MSB of each 16 bit will
     not contain valid data.

     So the first 2 bytes in memory are the first pixels blue component. **ImageBuffer::vpData** will therefore
     point to B(1) when using a 16 bit pointer.

    See also: 'Channel_Split_PackedToPlanar'
    """
ibpfRGB121212Packed = lib_mvIMPACT_acquire.ibpfRGB121212Packed
r"""
     The image will be transferred as an RGB image with 36 bit of usable data per pixel.
     This is an interleaved pixel format with 2 bytes per color component.
     The data is stored pixel-wise:

    .. code-block:: c++

         6 bytes        6 bytes        6 bytes      etc.
         B(1)G(1)R(1)   B(2)G(2)R(2)   B(3)G(3)R(3) etc.
         ..........................................
         ...........................   B(n)G(n)R(n)

     The data of each color component will be LSB aligned, thus the 4 MSB of each 16 bit will
     not contain valid data.

     So the first 2 bytes in memory are the first pixels blue component. **ImageBuffer::vpData** will therefore
     point to B(1) when using a 16 bit pointer.

    See also: 'Channel_Split_PackedToPlanar'
    """
ibpfRGB141414Packed = lib_mvIMPACT_acquire.ibpfRGB141414Packed
r"""
     The image will be transferred as an RGB image with 42 bit of usable data per pixel.
     This is an interleaved pixel format with 2 bytes per color component.
     The data is stored pixel-wise:

    .. code-block:: c++

         6 bytes        6 bytes        6 bytes      etc.
         B(1)G(1)R(1)   B(2)G(2)R(2)   B(3)G(3)R(3) etc.
         ..........................................
         ...........................   B(n)G(n)R(n)

     The data of each color component will be LSB aligned, thus the 2 MSB of each 16 bit will
     not contain valid data.

     So the first 2 bytes in memory are the first pixels blue component. **ImageBuffer::vpData** will therefore
     point to B(1) when using a 16 bit pointer.

    See also: 'Channel_Split_PackedToPlanar'
    """
ibpfRGB161616Packed = lib_mvIMPACT_acquire.ibpfRGB161616Packed
r"""
     The image will be transferred as an RGB image with 48 bit of usable data per pixel.
     This is an interleaved pixel format with 2 bytes per color component.
     The data is stored pixel-wise:

    .. code-block:: c++

         6 bytes        6 bytes        6 bytes      etc.
         B(1)G(1)R(1)   B(2)G(2)R(2)   B(3)G(3)R(3) etc.
         ..........................................
         ...........................   B(n)G(n)R(n)

     The data of each color component will be LSB aligned.

     So the first 2 bytes in memory are the first pixels blue component. **ImageBuffer::vpData** will therefore
     point to B(1) when using a 16 bit pointer.

    See also: 'Channel_Split_PackedToPlanar'
    """
ibpfYUV422_UYVYPacked = lib_mvIMPACT_acquire.ibpfYUV422_UYVYPacked
r"""
     This is a YUV422 packed image with 32 bit for a pair of pixels.
     This format uses 2:1 horizontal downsampling, which means that the Y component is
     sampled at each pixel, while U(Cb) and V(Cr) components are sampled every 2 pixels in
     horizontal direction. If each component takes 8 bits, the pair of pixels requires 32 bits.

     Two consecutive pixels (32 bit, 0xaabbccdd ) will contain 8 bit chrominance blue of pixel 1 and 2(aa),
     8 bit luminance of pixel 1(bb), 8 bit chrominance red of pixel 1 and 2 (cc) and finally 8 bit luminance of pixel 2(dd).

     Thus in memory the data will be stored like this:

    .. code-block:: c++

         4 bytes                   4 bytes                         etc.
         Cb(1,2) Y(1) Cr(1,2) Y(2) Cb(3,4)   Y(3)   Cr(3,4)   Y(4)    etc.
         ..........................Cb(n-1,n) Y(n-1) Cr(n-1,n) Y(n)

     So the first byte in memory is the first pixels Cb component. **ImageBuffer::vpData** will therefore
     point to Cb(1,2) when using a byte pointer.

    See also: 'Channel_Split_PackedToPlanar'
    """
ibpfMono12Packed_V2 = lib_mvIMPACT_acquire.ibpfMono12Packed_V2
r"""
     A single channel 12 bit per pixel packed format.
     This format will use 3 bytes to store 2 12 bit pixel. Every 3 bytes will use the following layout in
     memory:

    .. code-block:: c++

         3 bytes                                               3 bytes                                               etc.
         bits 11..4(1) bits 3..0(1) bits 3..0(2) bits 11..4(2) bits 11..4(3) bits 3..0(3) bits 3..0(4) bits 11..4(4) etc.

     Notes: 
     When the width is not divisible by 2 the line pitch of a buffer can't be used to calculate line start offsets in a buffer!
     In that case something like this can be used to access a certain pixel (pseudo code assuming 'pointerToStartOfTheBuffer' is a 'byte pointer'):

    .. code-block:: c++

         GetMono12Packed_V1Pixel( pointerToStartOfTheBuffer, pixelIndex )
           const int offsetFromStartOfTheBuffer = (3*pixel)/2
           if pixel divisible by 2
             return (pointerToStartOfTheBuffer[offset+1] < shift) | (pointerToStartOfTheBuffer[offset]  4)
           return pointerToStartOfTheBuffer[offset] < shift) | (pointerToStartOfTheBuffer[offset+1]  0xF)
    """
ibpfYUV422_10Packed = lib_mvIMPACT_acquire.ibpfYUV422_10Packed
r"""
     This is a YUV422 packed image with 64 bit for a pair of pixels.
     This format uses 2:1 horizontal downsampling, which means that the Y component is
     sampled at each pixel, while U(Cb) and V(Cr) components are sampled every 2 pixels in
     horizontal direction. If each component takes 16 bits, the pair of pixels requires 64 bits.

     Two consecutive pixels (64 bit, 0xaaaabbbbccccdddd ) contain 10 bit luminance of pixel 1(aaaa),
     10 bit chrominance blue of pixel 1 and 2(bbbb), 10 bit luminance of pixel 2(cccc) and finally 10 bit chrominance red of pixels 1 and 2(dddd).
     The upper 6 bits of each component will be 0.

     Thus in memory the data will be stored like this:

    .. code-block:: c++

         8 bytes                   8 bytes                         etc.
         Y(1) Cb(1,2) Y(2) Cr(1,2) Y(3)   Cb(3,4)   Y(4) Cr(3,4)   etc.
         ..........................Y(n-1) Cb(n-1,n) Y(n) Cr(n-1,n)

     So the first 2 bytes in memory are the first pixels luminance component. **ImageBuffer::vpData** will therefore
     point to Y(1) when using a 16 bit pointer.

    See also: 'Channel_Split_PackedToPlanar'
    """
ibpfYUV422_UYVY_10Packed = lib_mvIMPACT_acquire.ibpfYUV422_UYVY_10Packed
r"""
     This is a YUV422 packed image with 64 bit for a pair of pixels.
     This format uses 2:1 horizontal downsampling, which means that the Y component is
     sampled at each pixel, while U(Cb) and V(Cr) components are sampled every 2 pixels in
     horizontal direction. If each component takes 16 bits, the pair of pixels requires 64 bits.

     Two consecutive pixels (64 bit, 0xaaaabbbbccccdddd ) will contain 10 bit chrominance blue of pixel 1 and 2(aaaa),
     10 bit luminance of pixel 1(bbbb), 10 bit chrominance red of pixel 1 and 2 (cccc) and finally 10 bit luminance of pixel 2(dddd).
     The upper 6 bits of each component will be 0.

     Thus in memory the data will be stored like this:

    .. code-block:: c++

         8 bytes                   8 bytes                         etc.
         Cb(1,2) Y(1) Cr(1,2) Y(2) Cb(3,4)   Y(3)   Cr(3,4)   Y(4)    etc.
         ..........................Cb(n-1,n) Y(n-1) Cr(n-1,n) Y(n)

     So the first 2 bytes in memory are the first pixels luminance component. **ImageBuffer::vpData** will therefore
     point to Cb(1,2) when using a 16 bit pointer.

    See also: 'Channel_Split_PackedToPlanar'
    """
ibpfBGR888Packed = lib_mvIMPACT_acquire.ibpfBGR888Packed
r"""
     The image will be transferred as an RGB image with 24 bit per pixel.
     This is an interleaved pixel format suitable for most processing functions. Most
     blit/display function however will expect ibpfRGB888Packed.
     The data is stored pixel-wise:

    .. code-block:: c++

         3 bytes        3 bytes        3 bytes      etc.
         R(1)G(1)B(1)   R(2)G(2)B(2)   R(3)G(3)B(3) etc.
         ..........................................
         ...........................   R(n)G(n)B(n)

     So the first byte in memory is the first pixels red component. **ImageBuffer::vpData** will therefore
     point to R(1) when using a byte pointer.

    See also: 'Channel_Split_PackedToPlanar'
    """
ibpfBGR101010Packed_V2 = lib_mvIMPACT_acquire.ibpfBGR101010Packed_V2
r"""
     A 10 bit per color component RGB packed format.
     This format will use 4 bytes to store one 10 bit per color component RGB pixel. The following memory layout is
     used for each pixel:

    .. code-block:: c++

         byte 0   | byte 1   | byte 2   | byte 3   |
         0      7 | 890....5 | 6..90..3 | 4    9xx |
         RRRRRRRR | RRGGGGGG | GGGGBBBB | BBBBBB   |

    If: (DOXYGEN_C_DOCUMENTATION { || DOXYGEN_CPP_DOCUMENTATION)
    Notes: 
    Access to a certain pixel can e.g. be implemented like this:

    .. code-block:: c++

         //-----------------------------------------------------------------------------
         // slow version
         inline void GetBGR101010Packed_V2Pixel( void* p, const int pitch, int x, int y, unsigned short red, unsigned short green, unsigned short blue )
         //-----------------------------------------------------------------------------
         {
           unsigned int* pSrc = reinterpret_castunsigned int*(static_castunsigned char*(p) + y * pitch) + x;
           red   = static_castunsigned short( (*pSrc)          0x3FF);
           green = static_castunsigned short(((*pSrc)  10 )  0x3FF);
           blue  = static_castunsigned short(((*pSrc)  20 )  0x3FF);
         }

         //-----------------------------------------------------------------------------
         // faster version
         inline void GetBGR101010Packed_V2Pixel( unsigned int pixel, unsigned short red, unsigned short green, unsigned short blue )
         //-----------------------------------------------------------------------------
         {
           red   = static_castunsigned short(  pixel          0x3FF);
           green = static_castunsigned short(( pixel  10 )  0x3FF);
           blue  = static_castunsigned short(( pixel  20 )  0x3FF);
         }
    }

    See also: 'Channel_Split_PackedToPlanar'
    """
ibpfYUV444_UYVPacked = lib_mvIMPACT_acquire.ibpfYUV444_UYVPacked
r"""
     The image will be transferred as an YUV image with 24 bit per pixel.
     This is an interleaved pixel format.

     The data is stored pixel-wise:

    .. code-block:: c++

         3 bytes        3 bytes        3 bytes      etc.
         Cb(1)Y(1)Cr(1) Cb(2)Y(2)Cr(2) Cb(3)Y(3)Cr(3) etc.
         ..........................................
         ...........................   Cb(n)Y(n)Cr(n)

     So the first byte in memory is the first pixels Cb component. **ImageBuffer::vpData** will therefore
     point to Cb(1) when using a byte pointer.

    See also: 'Channel_Split_PackedToPlanar'
    """
ibpfYUV444_UYV_10Packed = lib_mvIMPACT_acquire.ibpfYUV444_UYV_10Packed
r"""
     The image will be transferred as an YUV image with 30 bit of usable data per pixel.
     This is an interleaved pixel format with 2 bytes per color component.
     The data is stored pixel-wise:

    .. code-block:: c++

         6 bytes        6 bytes        6 bytes      etc.
         Cb(1)Y(1)Cr(1) Cb(2)Y(2)Cr(2) Cb(3)Y(3)Cr(3) etc.
         ..........................................
         ...........................   Cb(n)Y(n)Cr(n)

     The data of each color component will be LSB aligned, thus the 6 MSB of each 16 bit will
     not contain valid data.

     So the first byte in memory is the first pixels Cb component. **ImageBuffer::vpData** will therefore
     point to Cb(1) when using a 16 bit pointer.

    See also: 'Channel_Split_PackedToPlanar'
    """
ibpfYUV444Packed = lib_mvIMPACT_acquire.ibpfYUV444Packed
r"""
     The image will be transferred as an YUV image with 24 bit per pixel.
     This is an interleaved pixel format.

     The data is stored pixel-wise:

    .. code-block:: c++

         3 bytes        3 bytes        3 bytes      etc.
         Y(1)Cb(1)Cr(1) Y(2)Cb(2)Cr(2) Y(3)Cb(3)Cr(3) etc.
         ..........................................
         ...........................   Y(n)Cb(n)Cr(n)

     So the first byte in memory is the first pixels luminance component. **ImageBuffer::vpData** will therefore
     point to Y(1) when using a byte pointer.

    See also: 'Channel_Split_PackedToPlanar'
    """
ibpfYUV444_10Packed = lib_mvIMPACT_acquire.ibpfYUV444_10Packed
r"""
     The image will be transferred as an YUV image with 30 bit of usable data per pixel.
     This is an interleaved pixel format with 2 bytes per color component.
     The data is stored pixel-wise:

    .. code-block:: c++

         6 bytes        6 bytes        6 bytes      etc.
         Y(1)Cb(1)Cr(1) Y(2)Cb(2)Cr(2) Y(3)Cb(3)Cr(3) etc.
         ..........................................
         ...........................   Y(n)Cb(n)Cr(n)

     The data of each color component will be LSB aligned, thus the 6 MSB of each 16 bit will
     not contain valid data.

     So the first byte in memory is the first pixels luminance component. **ImageBuffer::vpData** will therefore
     point to Y(1) when using a 16 bit pointer.

    See also: 'Channel_Split_PackedToPlanar'
    """
ibpfMono12Packed_V1 = lib_mvIMPACT_acquire.ibpfMono12Packed_V1
r"""
     A single channel 12 bit per pixel packed format.
     This format will use 3 bytes to store 2 12 bit pixel. Every 3 bytes will use the following layout in
     memory:

    .. code-block:: c++

         3 bytes                                               3 bytes                                               etc.
         bits 0..7(1) bits 8..11(1) bits 0..3(2) bits 4..11(2) bits 0..7(3) bits 8..11(3) bits 0..3(4) bits 4..11(4) etc.

     Notes: 
     When the width is not divisible by 2 the line pitch of a buffer can't be used to calculate line start offsets in a buffer!
     In that case something like this can be used to access a certain pixel (pseudo code assuming 'pointerToStartOfTheBuffer' is a 'byte pointer'):

    .. code-block:: c++

         GetMono12Packed_V1Pixel( pointerToStartOfTheBuffer, pixelIndex )
           const int offsetFromStartOfTheBuffer = pixel + pixel/2
           if pixel divisible by 2
             return (pointerToStartOfTheBuffer[offset]  4) | (pointerToStartOfTheBuffer[offset+1] < 4)
           return pointerToStartOfTheBuffer[offset]) | (pointerToStartOfTheBuffer[offset+1]  0xF) < 8)

    Since: 2.5.0
    """
ibpfYUV411_UYYVYY_Packed = lib_mvIMPACT_acquire.ibpfYUV411_UYYVYY_Packed
r"""
     This is a YUV411 packed image with 48 bits for four pixels.
     This format uses 4:1 horizontal downsampling, which means that the Y component is
     sampled at each pixel, while U(Cb) and V(Cr) components are sampled every 4 pixels in
     horizontal direction. If each component takes 8 bits, four pixels require 48 bits.

     Four consecutive pixels (48 bit, 0xaabbccddeeff ) contain 8 bit chrominance blue of pixels 1, 2, 3 and 4(aa),
     8 bit luminance of pixel 1(bb),8 bit luminance of pixel 2(cc), 8 bit chrominance red of pixels 1, 2, 3 and 4(dd),
     8 bit luminance of pixel 3(ee) and finally 8 bit luminance of pixel 4(ff).

     Thus in memory the data will be stored like this:

    .. code-block:: c++

         6 bytes                                     6 bytes                                     etc.
         Cb(1,2,3,4) Y(1) Y(2) Cr(1,2,3,4) Y(3) Y(4) Cb(5,6,7,8) Y(5) Y(6) Cr(5,6,7,8) Y(7) Y(8) etc.
         ..................                          Cb(n,n+1,n+2,n+3) Y(n) Y(n+1) Cr(n,n+1,n+2,n+3) Y(n+2) Y(n+3)

     So the first byte in memory is the chrominance blue component. **ImageBuffer::vpData** will therefore
     point to Cb when using a byte pointer.

    See also: 'Channel_Split_PackedToPlanar'

    Since: 2.13.0
    """
ibpfRGB888Planar = lib_mvIMPACT_acquire.ibpfRGB888Planar
r"""
     The image will be transferred as an RGB image in planar format.
     This is a format best suitable for most image processing functions.
     The image will be converted into 3 planes(a plane for each color component).

    .. code-block:: c++

         R(1) R(2) R(3) R(4) etc.
         ...................
         .............. R(n)
         G(1) G(2) G(3) G(4) etc.
         ...................
         .............. G(n)
         B(1) B(2) B(3) B(4) etc.
         ...................
         .............. B(n)

     So the first byte in memory is the first pixels red component. **ImageBuffer::vpData** will therefore
     point to R(1) when using a byte pointer.

    Since: 2.17.0
    """
ibpfAuto = lib_mvIMPACT_acquire.ibpfAuto
r""" The driver will decide which format will be used."""
ibfrmMono8_To_Mono8 = lib_mvIMPACT_acquire.ibfrmMono8_To_Mono8
r"""
    Attach or remove a **mvIMPACT::acquire::TBayerMosaicParity** attribute to a **mvIMPACT::acquire::ibpfMono8** buffer OR change the existing Bayer attribute to a different value.
    The new **mvIMPACT::acquire::TBayerMosaicParity** value for the buffer can be selected by the property **FormatReinterpreterBayerMosaicParity**.
    """
ibfrmMono8_To_RGB888Packed = lib_mvIMPACT_acquire.ibfrmMono8_To_RGB888Packed
r"""
     Reinterpret **mvIMPACT::acquire::ibpfMono8** as **mvIMPACT::acquire::ibpfRGB888Packed**.
    This will effectively divide the width by 3 but preserve the original line pitch.
    """
ibfrmMono8_To_BGR888Packed = lib_mvIMPACT_acquire.ibfrmMono8_To_BGR888Packed
r"""
     Reinterpret **mvIMPACT::acquire::ibpfMono8** as **mvIMPACT::acquire::ibpfBGR888Packed**.
    This will effectively divide the width by 3 but preserve the original line pitch.
    """
ibfrmMono10_To_Mono10 = lib_mvIMPACT_acquire.ibfrmMono10_To_Mono10
r"""
    Attach or remove a **mvIMPACT::acquire::TBayerMosaicParity** attribute to a **mvIMPACT::acquire::ibpfMono8** buffer OR change the existing Bayer attribute to a different value.
    The new **mvIMPACT::acquire::TBayerMosaicParity** value for the buffer can be selected by the property **FormatReinterpreterBayerMosaicParity**.
    """
ibfrmMono10_To_RGB101010Packed = lib_mvIMPACT_acquire.ibfrmMono10_To_RGB101010Packed
r"""
     Reinterpret **mvIMPACT::acquire::ibpfMono10** as **mvIMPACT::acquire::ibpfRGB101010Packed**.
    This will effectively divide the width by 3 but preserve the original line pitch.
    """
ibfrmMono12_To_Mono12 = lib_mvIMPACT_acquire.ibfrmMono12_To_Mono12
r"""
    Attach or remove a **mvIMPACT::acquire::TBayerMosaicParity** attribute to a **mvIMPACT::acquire::ibpfMono8** buffer OR change the existing Bayer attribute to a different value.
    The new **mvIMPACT::acquire::TBayerMosaicParity** value for the buffer can be selected by the property **FormatReinterpreterBayerMosaicParity**.
    """
ibfrmMono12_To_RGB121212Packed = lib_mvIMPACT_acquire.ibfrmMono12_To_RGB121212Packed
r"""
     Reinterpret **mvIMPACT::acquire::ibpfMono12** as **mvIMPACT::acquire::ibpfRGB121212Packed**.
    This will effectively divide the width by 3 but preserve the original line pitch.
    """
ibfrmMono14_To_Mono14 = lib_mvIMPACT_acquire.ibfrmMono14_To_Mono14
r"""
    Attach or remove a **mvIMPACT::acquire::TBayerMosaicParity** attribute to a **mvIMPACT::acquire::ibpfMono8** buffer OR change the existing Bayer attribute to a different value.
    The new **mvIMPACT::acquire::TBayerMosaicParity** value for the buffer can be selected by the property **FormatReinterpreterBayerMosaicParity**.
    """
ibfrmMono14_To_RGB141414Packed = lib_mvIMPACT_acquire.ibfrmMono14_To_RGB141414Packed
r"""
     Reinterpret **mvIMPACT::acquire::ibpfMono14** as **mvIMPACT::acquire::ibpfRGB141414Packed**.
    This will effectively divide the width by 3 but preserve the original line pitch.
    """
ibfrmMono16_To_Mono16 = lib_mvIMPACT_acquire.ibfrmMono16_To_Mono16
r"""
    Attach or remove a **mvIMPACT::acquire::TBayerMosaicParity** attribute to a **mvIMPACT::acquire::ibpfMono8** buffer OR change the existing Bayer attribute to a different value.
    The new **mvIMPACT::acquire::TBayerMosaicParity** value for the buffer can be selected by the property **FormatReinterpreterBayerMosaicParity**.
    """
ibfrmMono16_To_RGB161616Packed = lib_mvIMPACT_acquire.ibfrmMono16_To_RGB161616Packed
r"""
     Reinterpret **mvIMPACT::acquire::ibpfMono16** as **mvIMPACT::acquire::ibpfRGB161616Packed**.
    This will effectively divide the width by 3 but preserve the original line pitch.
    """
idpfAuto = lib_mvIMPACT_acquire.idpfAuto
r""" The driver will decide which destination format will be used."""
idpfRaw = lib_mvIMPACT_acquire.idpfRaw
r""" The image will be transferred as an unprocessed block of data."""
idpfMono8 = lib_mvIMPACT_acquire.idpfMono8
r""" The image will be transferred as a mono channel 8 bit per pixel image."""
idpfRGBx888Packed = lib_mvIMPACT_acquire.idpfRGBx888Packed
r"""
     The image will be transferred as an RGB image with 32 bit per pixel containing one fill byte per pixel.
     This is an interleaved pixel format suitable for most display functions. The data
     is stored pixel-wise. When accessed 4-byte wise the data layout in memory can be
     interpreted like this (starting with the MSB):

    .. code-block:: c++

         4 bytes             4 bytes             etc.
         B(1) G(1) R(1) A(1) B(2) G(2) R(2) A(2) etc.
         .......................................
                             B(n) G(n) R(n) A(n)

     So the first byte in memory is the first pixels blue component. **ImageBuffer::vpData** will therefore
     point to B(1) when using a byte pointer.

    See also: 'Channel_Split_PackedToPlanar'
    """
idpfYUV422Packed = lib_mvIMPACT_acquire.idpfYUV422Packed
r"""
     This is a YUV422 packed image with 32 bit for a pair of pixels.
     This format uses 2:1 horizontal downsampling, which means that the Y component is
     sampled at each pixel, while U(Cb) and V(Cr) components are sampled every 2 pixels in
     horizontal direction. If each component takes 8 bits, the pair of pixels requires 32 bits.

     Two consecutive pixels (32 bit, 0xaabbccdd ) contain 8 bit luminance of pixel 1(aa),
     8 bit chrominance blue of pixel 1 and 2(bb), 8 bit luminance of pixel 2(cc) and finally 8 bit chrominance red of pixels 1 and 2(dd).

     Thus in memory the data will be stored like this:

    .. code-block:: c++

         4 bytes                   4 bytes                         etc.
         Y(1) Cb(1,2) Y(2) Cr(1,2) Y(3)   Cb(3,4)   Y(4) Cr(3,4)   etc.
         ..........................Y(n-1) Cb(n-1,n) Y(n) Cr(n-1,n)

     So the first byte in memory is the first pixels luminance component. **ImageBuffer::vpData** will therefore
     point to Y(1) when using a byte pointer.

    See also: 'Channel_Split_PackedToPlanar'
    """
idpfRGBx888Planar = lib_mvIMPACT_acquire.idpfRGBx888Planar
r"""
     The image will be transferred as an RGB image in planar format.
     This is a format best suitable for most image processing functions.
     The image will be converted into four planes(a plane for each color component and one
     alpha plane).

    .. code-block:: c++

         R(1) R(2) R(3) R(4) etc.
         ...................
         .............. R(n)
         G(1) G(2) G(3) G(4) etc.
         ...................
         .............. G(n)
         B(1) B(2) B(3) B(4) etc.
         ...................
         .............. B(n)
         A(1) A(2) A(3) A(4) etc.
         ...................
         .............. A(n)

     So the first byte in memory is the first pixels red component. **ImageBuffer::vpData** will therefore
     point to R(1) when using a byte pointer.
    """
idpfMono10 = lib_mvIMPACT_acquire.idpfMono10
r"""
    The image will be transferred as a mono channel 10 bit per pixel image.
    Each pixel in this format consumes 2 bytes of memory. The lower 10 bit of this 2 bytes will contain valid data.
    """
idpfMono12 = lib_mvIMPACT_acquire.idpfMono12
r"""
    The image will be transferred as a mono channel 12 bit per pixel image.
    Each pixel in this format consumes 2 bytes of memory. The lower 12 bit of this 2 bytes will contain valid data.
    """
idpfMono14 = lib_mvIMPACT_acquire.idpfMono14
r"""
    The image will be transferred as a mono channel 14 bit per pixel image.
    Each pixel in this format consumes 2 bytes of memory. The lower 14 bit of this 2 bytes will contain valid data.
    """
idpfMono16 = lib_mvIMPACT_acquire.idpfMono16
r""" The image will be transferred as a mono channel 16 bit per pixel image."""
idpfRGB888Packed = lib_mvIMPACT_acquire.idpfRGB888Packed
r"""
     The image will be transferred as an RGB image with 24 bit per pixel.
     This is an interleaved pixel format suitable for most display and processing functions.
     The data is stored pixel-wise:

    .. code-block:: c++

         3 bytes        3 bytes        3 bytes      etc.
         B(1)G(1)R(1)   B(2)G(2)R(2)   B(3)G(3)R(3) etc.
         ..........................................
         ...........................   B(n)G(n)R(n)

     So the first byte in memory is the first pixels blue component. **ImageBuffer::vpData** will therefore
     point to B(1) when using a byte pointer.

    See also: 'Channel_Split_PackedToPlanar'
    """
idpfYUV422Planar = lib_mvIMPACT_acquire.idpfYUV422Planar
r"""
     The image will be transferred as a YUV422 image with 16 bit per pixel.
     This format uses 2:1 horizontal downsampling, which means that the Y component is
     sampled at each pixel, while U(Cb) and V(Cr) components are sampled every 2 pixels in
     horizontal direction. If each component takes 8 bits, the pair of pixels requires 32 bits.

     In memory the data will be stored like this:

    .. code-block:: c++

         Y(1)    Y(2)    Y(3)    Y(4) etc.
         ............................
         ..............  Y(n-1)  Y(n)
         Cr(1,2) Cr(3,4) etc.
         ...............
         ....... Cr(n/2)
         Cb(1,2) Cb(3,4) etc.
         ...............
         ....... Cb(n/2)

     Thus the Y planes size in bytes equals the sum of the 2 other planes.

     So the first byte in memory is the first pixels luminance component. **ImageBuffer::vpData** will therefore
     point to Y(1) when using a byte pointer.
    """
idpfRGB101010Packed = lib_mvIMPACT_acquire.idpfRGB101010Packed
r"""
     The image will be transferred as an RGB image with 30 bit of usable data per pixel.
     This is an interleaved pixel format with 2 bytes per color component.
     The data is stored pixel-wise:

    .. code-block:: c++

         6 bytes        6 bytes        6 bytes      etc.
         B(1)G(1)R(1)   B(2)G(2)R(2)   B(3)G(3)R(3) etc.
         ..........................................
         ...........................   B(n)G(n)R(n)

     The data of each color component will be LSB aligned, thus the 6 MSB of each 16 bit will
     not contain valid data.

     So the first byte in memory is the first pixels blue component. **ImageBuffer::vpData** will therefore
     point to B(1) when using a 16 bit pointer.

    See also: 'Channel_Split_PackedToPlanar'
    """
idpfRGB121212Packed = lib_mvIMPACT_acquire.idpfRGB121212Packed
r"""
     The image will be transferred as an RGB image with 36 bit of usable data per pixel.
     This is an interleaved pixel format with 2 bytes per color component.
     The data is stored pixel-wise:

    .. code-block:: c++

         6 bytes        6 bytes        6 bytes      etc.
         B(1)G(1)R(1)   B(2)G(2)R(2)   B(3)G(3)R(3) etc.
         ..........................................
         ...........................   B(n)G(n)R(n)

     The data of each color component will be LSB aligned, thus the 4 MSB of each 16 bit will
     not contain valid data.

     So the first byte in memory is the first pixels blue component. **ImageBuffer::vpData** will therefore
     point to B(1) when using a 16 bit pointer.

    See also: 'Channel_Split_PackedToPlanar'
    """
idpfRGB141414Packed = lib_mvIMPACT_acquire.idpfRGB141414Packed
r"""
     The image will be transferred as an RGB image with 42 bit of usable data per pixel.
     This is an interleaved pixel format with 2 bytes per color component.
     The data is stored pixel-wise:

    .. code-block:: c++

         6 bytes        6 bytes        6 bytes      etc.
         B(1)G(1)R(1)   B(2)G(2)R(2)   B(3)G(3)R(3) etc.
         ..........................................
         ...........................   B(n)G(n)R(n)

     The data of each color component will be LSB aligned, thus the 2 MSB of each 16 bit will
     not contain valid data.

     So the first byte in memory is the first pixels blue component. **ImageBuffer::vpData** will therefore
     point to B(1) when using a 16 bit pointer.

    See also: 'Channel_Split_PackedToPlanar'
    """
idpfRGB161616Packed = lib_mvIMPACT_acquire.idpfRGB161616Packed
r"""
     The image will be transferred as an RGB image with 48 bit of usable data per pixel.
     This is an interleaved pixel format with 2 bytes per color component.
     The data is stored pixel-wise:

    .. code-block:: c++

         6 bytes        6 bytes        6 bytes      etc.
         B(1)G(1)R(1)   B(2)G(2)R(2)   B(3)G(3)R(3) etc.
         ..........................................
         ...........................   B(n)G(n)R(n)

     The data of each color component will be LSB aligned.

     So the first byte in memory is the first pixels blue component. **ImageBuffer::vpData** will therefore
     point to B(1) when using a 16 bit pointer.

    See also: 'Channel_Split_PackedToPlanar'
    """
idpfYUV422_UYVYPacked = lib_mvIMPACT_acquire.idpfYUV422_UYVYPacked
r"""
     This is a YUV422 packed image with 32 bit for a pair of pixels.
     This format uses 2:1 horizontal downsampling, which means that the Y component is
     sampled at each pixel, while U(Cb) and V(Cr) components are sampled every 2 pixels in
     horizontal direction. If each component takes 8 bits, the pair of pixels requires 32 bits.

     Two consecutive pixels (32 bit, 0xaabbccdd ) will contain 8 bit chrominance blue of pixel 1 and 2(aa),
     8 bit luminance of pixel 1(bb), 8 bit chrominance red of pixel 1 and 2 (cc) and finally 8 bit luminance of pixel 2(dd).

     Thus in memory the data will be stored like this:

    .. code-block:: c++

         4 bytes                   4 bytes                         etc.
         Cb(1,2) Y(1) Cr(1,2) Y(2) Cb(3,4)   Y(3)   Cr(3,4)   Y(4)    etc.
         ..........................Cb(n-1,n) Y(n-1) Cr(n-1,n) Y(n)

     So the first byte in memory is the first pixels Cb component. **ImageBuffer::vpData** will therefore
     point to Cb(1,2) when using a byte pointer.

    See also: 'Channel_Split_PackedToPlanar'
    """
idpfMono12Packed_V2 = lib_mvIMPACT_acquire.idpfMono12Packed_V2
r"""
     A single channel 12 bit per pixel packed format.
     This format will use 3 bytes to store 2 12 bit pixel. Every 3 bytes will use the following layout in
     memory:

    .. code-block:: c++

         3 bytes                                               3 bytes                                               etc.
         bits 11..4(1) bits 3..0(1) bits 3..0(2) bits 11..4(2) bits 11..4(3) bits 3..0(3) bits 3..0(4) bits 11..4(4) etc.

     Notes: 
     When the width is not divisible by 2 the line pitch of a buffer can't be used to calculate line start offsets in a buffer!
     In that case something like this can be used to access a certain pixel (pseudo code assuming 'pointerToStartOfTheBuffer' is a 'byte pointer'):

    .. code-block:: c++

         GetMono12Packed_V1Pixel( pointerToStartOfTheBuffer, pixelIndex )
           const int offsetFromStartOfTheBuffer = (3*pixel)/2
           if pixel divisible by 2
             return (pointerToStartOfTheBuffer[offset+1] < shift) | (pointerToStartOfTheBuffer[offset]  4)
           return pointerToStartOfTheBuffer[offset] < shift) | (pointerToStartOfTheBuffer[offset+1]  0xF)
         }
    """
idpfYUV422_10Packed = lib_mvIMPACT_acquire.idpfYUV422_10Packed
r"""
     This is a YUV422 packed image with 64 bit for a pair of pixels.
     This format uses 2:1 horizontal downsampling, which means that the Y component is
     sampled at each pixel, while U(Cb) and V(Cr) components are sampled every 2 pixels in
     horizontal direction. If each component takes 16 bits, the pair of pixels requires 64 bits.

     Two consecutive pixels (64 bit, 0xaaaabbbbccccdddd ) contain 10 bit luminance of pixel 1(aaaa),
     10 bit chrominance blue of pixel 1 and 2(bbbb), 10 bit luminance of pixel 2(cccc) and finally 10 bit chrominance red of pixels 1 and 2(dddd).
     The upper 6 bits of each component will be 0.

     Thus in memory the data will be stored like this:

    .. code-block:: c++

         8 bytes                   8 bytes                         etc.
         Y(1) Cb(1,2) Y(2) Cr(1,2) Y(3)   Cb(3,4)   Y(4) Cr(3,4)   etc.
         ..........................Y(n-1) Cb(n-1,n) Y(n) Cr(n-1,n)

     So the first 2 bytes in memory are the first pixels luminance component. **ImageBuffer::vpData** will therefore
     point to Y(1) when using a 16 bit pointer.

    See also: 'Channel_Split_PackedToPlanar'
    """
idpfYUV422_UYVY_10Packed = lib_mvIMPACT_acquire.idpfYUV422_UYVY_10Packed
r"""
     This is a YUV422 packed image with 64 bit for a pair of pixels.
     This format uses 2:1 horizontal downsampling, which means that the Y component is
     sampled at each pixel, while U(Cb) and V(Cr) components are sampled every 2 pixels in
     horizontal direction. If each component takes 16 bits, the pair of pixels requires 64 bits.

     Two consecutive pixels (64 bit, 0xaaaabbbbccccdddd ) will contain 10 bit chrominance blue of pixel 1 and 2(aaaa),
     10 bit luminance of pixel 1(bbbb), 10 bit chrominance red of pixel 1 and 2 (cccc) and finally 10 bit luminance of pixel 2(dddd).
     The upper 6 bits of each component will be 0.

     Thus in memory the data will be stored like this:

    .. code-block:: c++

         8 bytes                   8 bytes                         etc.
         Cb(1,2) Y(1) Cr(1,2) Y(2) Cb(3,4)   Y(3)   Cr(3,4)   Y(4)    etc.
         ..........................Cb(n-1,n) Y(n-1) Cr(n-1,n) Y(n)

     So the first 2 bytes in memory are the first pixels luminance component. **ImageBuffer::vpData** will therefore
     point to Cb(1,2) when using a 16 bit pointer.

    See also: 'Channel_Split_PackedToPlanar'
    """
idpfBGR888Packed = lib_mvIMPACT_acquire.idpfBGR888Packed
r"""
     The image will be transferred as an RGB image with 24 bit per pixel.
     This is an interleaved pixel format suitable for most processing functions. Most
     blit/display function however will expect idpfRGB888Packed.
     The data is stored pixel-wise:

    .. code-block:: c++

         3 bytes        3 bytes        3 bytes      etc.
         R(1)G(1)B(1)   R(2)G(2)B(2)   R(3)G(3)B(3) etc.
         ..........................................
         ...........................   R(n)G(n)B(n)

     So the first byte in memory is the first pixels red component. **ImageBuffer::vpData** will therefore
     point to R(1) when using a byte pointer.

    See also: 'Channel_Split_PackedToPlanar'
    """
idpfBGR101010Packed_V2 = lib_mvIMPACT_acquire.idpfBGR101010Packed_V2
r"""
     A 10 bit per color component RGB packed format.
     This format will use 4 bytes to store one 10 bit per color component RGB pixel. The following memory layout is
     used for each pixel:

    .. code-block:: c++

         byte 0   | byte 1   | byte 2   | byte 3   |
         0      7 | 890....5 | 6..90..3 | 4    9xx |
         RRRRRRRR | RRGGGGGG | GGGGBBBB | BBBBBB   |

    If: (DOXYGEN_C_DOCUMENTATION { || DOXYGEN_CPP_DOCUMENTATION)
     Notes: 
     Access to a certain pixel can e.g. be implemented like this:

    .. code-block:: c++

         //-----------------------------------------------------------------------------
         // slow version
         inline void GetBGR101010Packed_V2Pixel( void* p, const int pitch, int x, int y, unsigned short red, unsigned short green, unsigned short blue )
         //-----------------------------------------------------------------------------
         {
           unsigned int* pSrc = reinterpret_castunsigned int*(static_castunsigned char*(p) + y * pitch) + x;
           red   = static_castunsigned short( (*pSrc)          0x3FF);
           green = static_castunsigned short(((*pSrc)  10 )  0x3FF);
           blue  = static_castunsigned short(((*pSrc)  20 )  0x3FF);
         }

         //-----------------------------------------------------------------------------
         // faster version
         inline void GetBGR101010Packed_V2Pixel( unsigned int pixel, unsigned short red, unsigned short green, unsigned short blue )
         //-----------------------------------------------------------------------------
         {
           red   = static_castunsigned short(  pixel          0x3FF);
           green = static_castunsigned short(( pixel  10 )  0x3FF);
           blue  = static_castunsigned short(( pixel  20 )  0x3FF);
         }
    }

    See also: 'Channel_Split_PackedToPlanar'
    """
idpfYUV444_UYVPacked = lib_mvIMPACT_acquire.idpfYUV444_UYVPacked
r"""
     The image will be transferred as an YUV image with 24 bit per pixel.
     This is an interleaved pixel format.

     The data is stored pixel-wise:

    .. code-block:: c++

         3 bytes        3 bytes        3 bytes      etc.
         Cb(1)Y(1)Cr(1) Cb(2)Y(2)Cr(2) Cb(3)Y(3)Cr(3) etc.
         ..........................................
         ...........................   Cb(n)Y(n)Cr(n)

     So the first byte in memory is the first pixels Cb component. **ImageBuffer::vpData** will therefore
     point to Cb(1) when using a byte pointer.

    See also: 'Channel_Split_PackedToPlanar'
    """
idpfYUV444_UYV_10Packed = lib_mvIMPACT_acquire.idpfYUV444_UYV_10Packed
r"""
     The image will be transferred as an YUV image with 30 bit of usable data per pixel.
     This is an interleaved pixel format with 2 bytes per color component.
     The data is stored pixel-wise:

    .. code-block:: c++

         6 bytes        6 bytes        6 bytes      etc.
         Cb(1)Y(1)Cr(1) Cb(2)Y(2)Cr(2) Cb(3)Y(3)Cr(3) etc.
         ..........................................
         ...........................   Cb(n)Y(n)Cr(n)

     The data of each color component will be LSB aligned, thus the 6 MSB of each 16 bit will
     not contain valid data.

     So the first byte in memory is the first pixels Cb component. **ImageBuffer::vpData** will therefore
     point to Cb(1) when using a 16 bit pointer.

    See also: 'Channel_Split_PackedToPlanar'
    """
idpfYUV444Packed = lib_mvIMPACT_acquire.idpfYUV444Packed
r"""
     The image will be transferred as an YUV image with 24 bit per pixel.
     This is an interleaved pixel format.

     The data is stored pixel-wise:

    .. code-block:: c++

         3 bytes        3 bytes        3 bytes      etc.
         Y(1)Cb(1)Cr(1) Y(2)Cb(2)Cr(2) Y(3)Cb(3)Cr(3) etc.
         ..........................................
         ...........................   Y(n)Cb(n)Cr(n)

     So the first byte in memory is the first pixels luminance component. **ImageBuffer::vpData** will therefore
     point to Y(1) when using a byte pointer.

    See also: 'Channel_Split_PackedToPlanar'
    """
idpfYUV444_10Packed = lib_mvIMPACT_acquire.idpfYUV444_10Packed
r"""
     The image will be transferred as an YUV image with 30 bit of usable data per pixel.
     This is an interleaved pixel format with 2 bytes per color component.
     The data is stored pixel-wise:

    .. code-block:: c++

         6 bytes        6 bytes        6 bytes      etc.
         Y(1)Cb(1)Cr(1) Y(2)Cb(2)Cr(2) Y(3)Cb(3)Cr(3) etc.
         ..........................................
         ...........................   Y(n)Cb(n)Cr(n)

     The data of each color component will be LSB aligned, thus the 6 MSB of each 16 bit will
     not contain valid data.

     So the first byte in memory is the first pixels luminance component. **ImageBuffer::vpData** will therefore
     point to Y(1) when using a 16 bit pointer.

    See also: 'Channel_Split_PackedToPlanar'
    """
idpfMono12Packed_V1 = lib_mvIMPACT_acquire.idpfMono12Packed_V1
r"""
     A single channel 12 bit per pixel packed format.
     This format will use 3 bytes to store 2 12 bit pixel. Every 3 bytes will use the following layout in
     memory:

    .. code-block:: c++

         3 bytes                                               3 bytes                                               etc.
         bits 0..7(1) bits 8..11(1) bits 0..3(2) bits 4..11(2) bits 0..7(3) bits 8..11(3) bits 0..3(4) bits 4..11(4) etc.

     Notes: 
     When the width is not divisible by 2 the line pitch of a buffer can't be used to calculate line start offsets in a buffer!
     In that case something like this can be used to access a certain pixel (pseudo code assuming 'pointerToStartOfTheBuffer' is a 'byte pointer'):

    .. code-block:: c++

         GetMono12Packed_V1Pixel( pointerToStartOfTheBuffer, pixelIndex )
           const int offsetFromStartOfTheBuffer = pixel + pixel/2
           if pixel divisible by 2
             return (pointerToStartOfTheBuffer[offset]  4) | (pointerToStartOfTheBuffer[offset+1] < 4)
           return pointerToStartOfTheBuffer[offset]) | (pointerToStartOfTheBuffer[offset+1]  0xF) < 8)

    Since: 2.5.0
    """
idpfYUV411_UYYVYY_Packed = lib_mvIMPACT_acquire.idpfYUV411_UYYVYY_Packed
r"""
     This is a YUV411 packed image with 48 bits for four pixels.
     This format uses 4:1 horizontal downsampling, which means that the Y component is
     sampled at each pixel, while U(Cb) and V(Cr) components are sampled every 4 pixels in
     horizontal direction. If each component takes 8 bits, four pixels require 48 bits.

     Four consecutive pixels (48 bit, 0xaabbccddeeff ) contain 8 bit chrominance blue of pixels 1, 2, 3 and 4(aa),
     8 bit luminance of pixel 1(bb),8 bit luminance of pixel 2(cc), 8 bit chrominance red of pixels 1, 2, 3 and 4(dd),
     8 bit luminance of pixel 3(ee) and finally 8 bit luminance of pixel 4(ff).

     Thus in memory the data will be stored like this:

    .. code-block:: c++

         6 bytes                                     6 bytes                                     etc.
         Cb(1,2,3,4) Y(1) Y(2) Cr(1,2,3,4) Y(3) Y(4) Cb(5,6,7,8) Y(5) Y(6) Cr(5,6,7,8) Y(7) Y(8) etc.
         ..................                          Cb(n,n+1,n+2,n+3) Y(n) Y(n+1) Cr(n,n+1,n+2,n+3) Y(n+2) Y(n+3)

     So the first byte in memory is the chrominance blue component. **ImageBuffer::vpData** will therefore
     point to Cb when using a byte pointer.

    See also: 'Channel_Split_PackedToPlanar'

    Since: 2.13.0
    """
idpfRGB888Planar = lib_mvIMPACT_acquire.idpfRGB888Planar
r"""
     The image will be transferred as an RGB image in planar format.
     This is a format best suitable for most image processing functions.
     The image will be converted into 3 planes(a plane for each color component).

    .. code-block:: c++

         R(1) R(2) R(3) R(4) etc.
         ...................
         .............. R(n)
         G(1) G(2) G(3) G(4) etc.
         ...................
         .............. G(n)
         B(1) B(2) B(3) B(4) etc.
         ...................
         .............. B(n)

     So the first byte in memory is the first pixels red component. **ImageBuffer::vpData** will therefore
     point to R(1) when using a byte pointer.

    Since: 2.17.0
    """
iffAuto = lib_mvIMPACT_acquire.iffAuto
r""" Automatically tries to select the file format e.g. from the file extension"""
iffBMP = lib_mvIMPACT_acquire.iffBMP
r""" The BMP format."""
iffJPEG = lib_mvIMPACT_acquire.iffJPEG
r""" The JPEG format."""
iffPNG = lib_mvIMPACT_acquire.iffPNG
r""" The PNG format."""
iffTIFF = lib_mvIMPACT_acquire.iffTIFF
r""" The TIFF format."""
ipfOff = lib_mvIMPACT_acquire.ipfOff
r""" No filter function will be applied to the image."""
ipfSharpen = lib_mvIMPACT_acquire.ipfSharpen
r""" A sharpen filter will be applied to the image."""
ipmDefault = lib_mvIMPACT_acquire.ipmDefault
r""" The default mode where every image is processed in the order they have been acquired"""
ipmProcessLatestOnly = lib_mvIMPACT_acquire.ipmProcessLatestOnly
r"""
    This mode can be useful for applications where processing on the host takes longer than the average time between two consecutive frames transmitted by the device.
    This might be useful for applications that display the processed result but that also want to
    capture data at the highest possible frame rate and is not important that EVERY image gets processed.

    This mode might result in images being returned without the expected processing on the host.

    See also: **mvIMPACT::acquire::Device::userControlledImageProcessingEnable**,

        **mvIMPACT::acquire::Request::hasProcessingBeenSkipped**,

        **mvIMPACT::acquire::Request::getImageProcessingResultsIterator**
    """
ipoMaximizeSpeed = lib_mvIMPACT_acquire.ipoMaximizeSpeed
r""" Will maximize the execution speed. This might result in a higher memory consumption."""
ipoMinimizeMemoryUsage = lib_mvIMPACT_acquire.ipoMinimizeMemoryUsage
r"""
    Will minimize the memory footprint. This might result in a higher CPU load.
    This mode will also result in a higher amount of memory allocation and freeing operations
    thus if the application itself is working with heap memory a lot the long term effects of heap
    fragmentation should be considered!
    """
iprNotActive = lib_mvIMPACT_acquire.iprNotActive
r"""
    This algorithm was either switched off or not needed when applied to this request object.
    When an algorithm is switched on and this result is returned this can indicate e.g. that for a format conversion
    the input and output format where identical.
    """
iprApplied = lib_mvIMPACT_acquire.iprApplied
r""" This algorithm has been applied to this request object."""
iprFailure = lib_mvIMPACT_acquire.iprFailure
r"""
    A problem was encountered when this algorithm has been applied to this request object.
    One reason for this result might be that an unsupported pixel format was fed into this algorithm. The log-file
    will provide additional information then.
    """
iprSkipped = lib_mvIMPACT_acquire.iprSkipped
r"""
    This algorithm has NOT been applied because of a lack of processing time.
    In most cases the acquisition frame rate(thus the frame rate generated on the device) was higher
    than the processing frame rate the host can handle and the user has explicitly
    configured the image processing mode to skip images then.
    """
iprNotApplicable = lib_mvIMPACT_acquire.iprNotApplicable
r"""
     This algorithm has NOT been applied because it was not applicable.
     This result will be reported whenever a buffer was fed into a filter that was not applicable. An example
     for such a situation would be a JPEG image that has been fed into a de-Bayer algorithm.

    Since: 2.22.1
    """
ircmManual = lib_mvIMPACT_acquire.ircmManual
r"""
    The standard mode for image requests.
    In this mode one image will be captured from the hardware for each request
    that is send to the device driver. The image will be taken with respect to the
    current parameters as defined in the setting selected in the corresponding
    image request control.
    """
ircmLive = lib_mvIMPACT_acquire.ircmLive
r""" Reserved. Currently not implemented."""
ircmCounting = lib_mvIMPACT_acquire.ircmCounting
r""" Reserved. Currently not implemented."""
ircmTrial = lib_mvIMPACT_acquire.ircmTrial
r"""
    In this mode no 'real' image will be captured, but the whole processing chain will be traversed once.
    This mode can be used either to find out what the image format and parameters
    after an image capture would be with the current settings or to prepare
    the hardware before starting the first image acquisition to save time when
    real image data is processed.

    When requesting an image in this mode, the corresponding wait function will return
    a complete request object with pixel format, dimensions and image buffer that contains
    some dummy data.
    """
ircmUpdateBufferLayout = lib_mvIMPACT_acquire.ircmUpdateBufferLayout
r"""
    In this mode no 'real' image will be captured, but the whole processing chain will be traversed once.
    This mode can be used either to find out what the image format and parameters
    after an image capture would be with the current settings or to prepare
    the hardware before starting the first image acquisition to save time when
    real image data is processed.

    In this mode, no wait function must be called. When the image request function has
    returned successfully, the current destination buffer layout will be available as part
    of the general information properties.
    """
iscmUnknown = lib_mvIMPACT_acquire.iscmUnknown
r""" This is an unknown type of sensor."""
iscmMono = lib_mvIMPACT_acquire.iscmMono
r""" This is a mono sensor."""
iscmBayer = lib_mvIMPACT_acquire.iscmBayer
r""" This is a Bayer color sensor."""
iscmColor = lib_mvIMPACT_acquire.iscmColor
r""" This is a color sensor."""
iscmNIR = lib_mvIMPACT_acquire.iscmNIR
r""" This is a sensor sensitive in the near IF spectrum only."""
iscpGreenRed = lib_mvIMPACT_acquire.iscpGreenRed
r"""
    This sensor starts to transmit a green pixel from a green and red line.
    The raw image therefore is structured like this:

    GRGRGRGRGRGRG etc.

    BGBGBGBGBGBGB etc.

    GRGRGRGRGRGRG etc.

    etc.
    """
iscpRedGreen = lib_mvIMPACT_acquire.iscpRedGreen
r"""
    This sensor starts to transmit a red pixel from a green and red line.
    The raw image therefore is structured like this:

    RGRGRGRGRGRGR etc.

    GBGBGBGBGBGBG etc.

    RGRGRGRGRGRGR etc.

    etc.
    """
iscpBlueGreen = lib_mvIMPACT_acquire.iscpBlueGreen
r"""
    This sensor starts to transmit a green pixel from a green and blue line.
    The raw image therefore is structured like this:

    GBGBGBGBGBGBG etc.

    RGRGRGRGRGRGR etc.

    GBGBGBGBGBGBG etc.

    etc.
    """
iscpGreenBlue = lib_mvIMPACT_acquire.iscpGreenBlue
r"""
    This sensor starts to transmit a blue pixel from a green and blue line.
    The raw image therefore is structured like this:

    BGBGBGBGBGBGB etc.

    GRGRGRGRGRGRG etc.

    BGBGBGBGBGBGB etc.

    etc.
    """
iscpUnknown = lib_mvIMPACT_acquire.iscpUnknown
r""" Nothing is known about the way the sensor transmits data."""
istUnknown = lib_mvIMPACT_acquire.istUnknown
r""" This is an unknown type of sensor."""
istCCD = lib_mvIMPACT_acquire.istCCD
r""" This is a CCD sensor."""
istCMOS = lib_mvIMPACT_acquire.istCMOS
r""" This is a CMOS sensor."""
iebNotConfigured = lib_mvIMPACT_acquire.iebNotConfigured
r""" The interface will enumerate devices or not according to the general enumeration behavior of this interface type(according to EnumerateEnable setting)."""
iebForceIgnore = lib_mvIMPACT_acquire.iebForceIgnore
r""" The interface will not enumerate devices, regardless of the general enumeration behavior of this interface type(overrides EnumerateEnable setting)."""
iebForceEnumerate = lib_mvIMPACT_acquire.iebForceEnumerate
r""" The interface will forcefully enumerate devices, regardless of the general enumeration behavior of this interface type(overrides EnumerateEnable setting)."""
imOn = lib_mvIMPACT_acquire.imOn
r"""
    Enable the interlaced function.
    The device will re-construct the interlaced data into a full frame.
    InvInterlaced/Interlaced is controlled by the camera parameter.
    """
imOff = lib_mvIMPACT_acquire.imOff
r""" Disable the interlaced function."""
lcOff = lib_mvIMPACT_acquire.lcOff
r""" Disables line counter."""
lcOn = lib_mvIMPACT_acquire.lcOn
r""" Enables line counter."""
LUTgmStandard = lib_mvIMPACT_acquire.LUTgmStandard
r"""
    Default gamma mode.
    Maps an image by applying intensity transformation with gamma correction to the complete intensity range of the LUT.
    """
LUTgmLinearStart = lib_mvIMPACT_acquire.LUTgmLinearStart
r""" Maps an image by applying a linear interpolation in the lower intensity range of the LUT and an intensity transformation with gamma correction to the upper intensity range of the LUT."""
LUTiHardware = lib_mvIMPACT_acquire.LUTiHardware
r"""
    The mapping of the image data will be done in hardware.
    When set to 'Hardware' the LUT operation will NOT introduce additional CPU load.
    This feature will no be available for every device.
    """
LUTiSoftware = lib_mvIMPACT_acquire.LUTiSoftware
r""" The mapping of the image data will be done with an optimized software algorithm."""
LUTimThreshold = lib_mvIMPACT_acquire.LUTimThreshold
r""" Maps an image by applying intensity transformation based on a set of given threshold values."""
LUTimLinear = lib_mvIMPACT_acquire.LUTimLinear
r""" Maps an image by applying intensity transformation with linear interpolation."""
LUTimCubic = lib_mvIMPACT_acquire.LUTimCubic
r""" Maps an image by applying intensity transformation with cubic interpolation."""
LUTm8To8 = lib_mvIMPACT_acquire.LUTm8To8
r""" 8 bit input data will be mapped to 8 bit output data."""
LUTm10To8 = lib_mvIMPACT_acquire.LUTm10To8
r""" 10 bit input data will be mapped to 8 bit output data."""
LUTm10To10 = lib_mvIMPACT_acquire.LUTm10To10
r""" 10 bit input data will be mapped to 10 bit output data."""
LUTm12To10 = lib_mvIMPACT_acquire.LUTm12To10
r""" 12 bit input data will be mapped to 10 bit output data."""
LUTm12To12 = lib_mvIMPACT_acquire.LUTm12To12
r""" 12 bit input data will be mapped to 12 bit output data."""
LUTm14To14 = lib_mvIMPACT_acquire.LUTm14To14
r"""
    14 bit input data will be mapped to 14 bit output data.
    Since: 2.0.2
    """
LUTm16To16 = lib_mvIMPACT_acquire.LUTm16To16
r"""
    16 bit input data will be mapped to 16 bit output data.
    Since: 2.0.2
    """
LUTmInterpolated = lib_mvIMPACT_acquire.LUTmInterpolated
r""" Maps an image by applying interpolated intensity transformation between a set of given sampling points."""
LUTmGamma = lib_mvIMPACT_acquire.LUTmGamma
r"""
    Maps an image by applying intensity transformation with gamma correction.
    Since the human eye perceives light similar to a logarithm of real light intensity it's characteristic curve is
    non-linear. It follows the rule of (intensity ^ gamma) with a gamma value between 0.3-0.5.
    To provide as much useful information as possible, the image is converted from 12-bit acquired by the sensor to 8-bit utilizing
    this characteristic curve. The result is a linearized image optimized for the human eye's non-linear behavior which allows
    to perceive as much intensity differences as possible.
    Image: Gamma_correction_filter.png
       Conversion from 12- to 8-bit utilizing the gamma function
    """
LUTmDirect = lib_mvIMPACT_acquire.LUTmDirect
r""" Maps an image by applying intensity transformation."""
mmmAuto = lib_mvIMPACT_acquire.mmmAuto
r"""
    Automatic mode.
    In this mode the DMA memory is only used as intermediate buffer. The user has no direct access to it
    instead he get always a copy of the image that resides on the heap. Internally the DMA memory is organized as
    ring buffer. It decouples the autonomous grabbing of the board from the application. The size of the
    memory should be big enough to hold as many images as requests are used in the application.
    """
mmmPool = lib_mvIMPACT_acquire.mmmPool
r"""
    Pool Mode
    This mode allows direct access to the DMA memory. So its not necessary for the driver to make copies
    of the images. This improves the performance of the system. But there is one disadvantage: The
    partitioning of the DMA memory is fixed and has to be done by the user. The block size must be set
    to the image size in bytes. Additional the block count must be set. Before these parameters can be
    changed it must be sure that all ImageBuffers are returned and the grabber is stopped.
    """
mmpmOff = lib_mvIMPACT_acquire.mmpmOff
r""" Dont use Pool"""
mmpmFixed = lib_mvIMPACT_acquire.mmpmFixed
r""" Use Pool in Manual Mode"""
mmpmAuto = lib_mvIMPACT_acquire.mmpmAuto
r""" Use Pool in Automatic Mode"""
mmOff = lib_mvIMPACT_acquire.mmOff
r""" No Mirroring."""
mmTopDown = lib_mvIMPACT_acquire.mmTopDown
r""" The resulting image will be flipped around a horizontal axis."""
mmLeftRight = lib_mvIMPACT_acquire.mmLeftRight
r""" The resulting image will be flipped around a vertical axis."""
mmTopDownAndLeftRight = lib_mvIMPACT_acquire.mmTopDownAndLeftRight
r""" The resulting image will be both around a horizontal and vertical axis."""
momGlobal = lib_mvIMPACT_acquire.momGlobal
r""" There will be a single mode option only and this mode will be applied to all channels of the image."""
momChannelBased = lib_mvIMPACT_acquire.momChannelBased
r""" The mirror mode can be selected for differently for each channel of the image."""
obmmDefault = lib_mvIMPACT_acquire.obmmDefault
r"""
    The device will work with reasonable default values.
    This option will be the right choice for most of the user.
    """
obmmUser = lib_mvIMPACT_acquire.obmmUser
r"""
    The user can define how the on board memory of the device will be used.
    This is for advanced user only and will not be necessary in most of
    the cases.
    """
prmVertical = lib_mvIMPACT_acquire.prmVertical
r"""
     The pixels will be re-arranged one after the other thus the resulting image will have a width of 'input image width / 2' and a height of 'input image height * 2'
    The resulting image will consist of several small images sitting on top of each other. The first image will contain all the upper left
    pixels from each extraction ROI, the last image all the lower right pixels. The images in between will be extracted line by line and then row by row.

    Since: 2.29.0
    """
prmHorizontal = lib_mvIMPACT_acquire.prmHorizontal
r"""
     The pixels will be re-arranged one after the other thus the resulting image will have a width of 'input image width * 2' and a height of 'input image height / 2'
    The resulting image will consist of several small images sitting next each other. The first image will contain all the upper left
    pixels from each extraction ROI, the last image all the lower right pixels. The images in between will be extracted line by line and then row by row.

    Since: 2.29.0
    """
prmExtractSingle = lib_mvIMPACT_acquire.prmExtractSingle
r"""
     The pixel selected by 'PolarizedDataExtractionChannelIndex' will be extracted and forwarded from each region defined by '2 * 2'.
    The resulting image therefore will have a width equal to 'input image width / 2' and a height equal to 'input image height / 2'

    Since: 2.29.0
    """
prmMinimumValue = lib_mvIMPACT_acquire.prmMinimumValue
r"""
     The pixel with the minimum value will be extracted and forwarded from each region defined by '2 * 2'.
    The resulting image therefore will have a width equal to 'input image width / 2' and a height equal to 'input image height / 2'

    Since: 2.29.0
    """
prmMeanValue = lib_mvIMPACT_acquire.prmMeanValue
r"""
     The mean value of all pixels whose value ranges from 'PolarizedDataExtractionLowerLimit' to 'PolarizedDataExtractionUpperLimit' will be calculated within each region defined by '2 * 2' in the source image and will be forwarded as a single new pixel in the destination image.
    The resulting image therefore will have a width equal to 'input image width / 2' and a height equal to 'input image height / 2'

    Since: 2.29.0
    """
prm2By2 = lib_mvIMPACT_acquire.prm2By2
r"""
     The pixels will be re-arranged in a way the image keeps its original dimension but each polarization angle will afterwards occupy a certain section in the image
    The upper left quarter of the resulting image will contain all the upper left pixels from each 2 by 2 pixel region etc.

    Since: 2.29.1
    """
prmExtractAngle = lib_mvIMPACT_acquire.prmExtractAngle
r"""
     The angle of the maximum polarization for every '2 * 2' region in the image will be calculated and the resulting value will then be mapped to the value range of the source pixel format.
    The resulting image therefore will have a width equal to 'input image width / 2' and a height equal to 'input image height / 2'. From each 2 by 2 region (thus 4 input values) a single output
    value will be calculated and placed into the resulting image. In this mode the output pixel format will be the same as the input pixel format and the resulting value will be mapped to this
    pixel formats value range thus the maximum angle (180 degree) will correspond the maximum pixel value in this format (e.g. 1023 for **mvIMPACT::acquire::ibpfMono10)**.

    The angle of the maximum polarization is calculated based the formula:

    .. math::

        \Theta = \frac{1}{2}*atan\left (\left ( P45-P135 \right ); \left (P0 - P90\right )\right )

    Warning: Pixels which are saturated or which don't show a signal at all will cause incorrect polarization data. This happens as a result of wrong relations between the different
    polarization directions which causes wrong values for the different stokes parameters resulting in incorrect pixel data. Different exposure settings might improve the result.
    Since: 2.38.0
    """
prmExtractDegree = lib_mvIMPACT_acquire.prmExtractDegree
r"""
     The degree of the polarization for every '2 * 2' region in the image will be calculated and the resulting value will then be mapped to the value range of the source pixel format.
    The resulting image therefore will have a width equal to 'input image width / 2' and a height equal to 'input image height / 2'. From each 2 by 2 region (thus 4 input values) a single output
    value will be calculated and placed into the resulting image. In this mode the output pixel format will be the same as the input pixel format and the resulting value will be mapped to this
    pixel formats value range thus the maximum polarization will correspond the maximum pixel value in this format (e.g. 1023 for **mvIMPACT::acquire::ibpfMono10)**.

    The calculation of the degree of the maximum polarization is based the formula:

    .. math::

        \Pi = \frac{\sqrt{\left(P0-P90\right)^{2}+\left(P45-P135\right)^{2}}}{\left(P0+P90\right)}

    Warning: Pixels which are saturated or which don't show a signal at all will cause incorrect polarization data. This happens as a result of wrong relations between the different
    polarization directions which causes wrong values for the different stokes parameters resulting in incorrect pixel data. Different exposure settings might improve the result.
    Since: 2.38.0
    """
prmPseudoColorRepresentation = lib_mvIMPACT_acquire.prmPseudoColorRepresentation
r"""
     The angle of the maximum polarization and the degree of the polarization for every '2 * 2' region in the image will be calculated and the resulting value will then be mapped to the value range of and 8-bit HSL image.
    The angle and the degree are calculated as described in **mvIMPACT::acquire::prmExtractDegree** and **mvIMPACT::acquire::prmExtractAngle** mode. Afterwards the angle is used as hue and the degree is used as saturation value
    in the HSL color representation and converted to RGB color representation.

    The resulting image therefore will have a width equal to 'input image width / 2' and a height equal to 'input image height / 2'. From each 2 by 2 region (thus 4 input values) 2 output
    values will be calculated and placed into the resulting temporary HSL image. Afterwards this HSL image will transformed back to RGB to generate a pseudo-color image in **mvIMPACT::acquire::ibpfRGB888Planar** format.

    Warning: Pixels which are saturated or which don't show a signal at all will cause incorrect polarization data. This happens as a result of wrong relations between the different
    polarization directions which causes wrong values for the different stokes parameters resulting in incorrect pixel data. Different exposure settings might improve the result.
    Since: 2.38.0
    """
primOff = lib_mvIMPACT_acquire.primOff
r"""
     No interpolation
    The resulting image therefore will have then same amount of pixels for horizontal or vertical polarization data extraction modes
    or a reduced number of pixels for all other modes.

    Since: 2.29.0
    """
primLinear = lib_mvIMPACT_acquire.primLinear
r"""
     Linear interpolation
    The resulting image therefore will have either 4 times the number of pixels for horizontal or vertical polarization data extraction modes
    or the same dimensions as the input image for single extraction mode. The additional pixel data will be generated using
    linear interpolation algorithm

    Since: 2.29.0
    """
pstDigitalSignal = lib_mvIMPACT_acquire.pstDigitalSignal
r""" Changes on one or more digital inputs will trigger the output of the pulse or pulse sequence."""
pstPeriodically = lib_mvIMPACT_acquire.pstPeriodically
r""" The output of a pulse or pulse sequence will be done periodically."""
pstRotaryDecoder = lib_mvIMPACT_acquire.pstRotaryDecoder
r""" The output of a rotary decoder will trigger the output of the pulse or pulse sequence."""
rimmAuto = lib_mvIMPACT_acquire.rimmAuto
r"""
    Automatic mode.
    In this mode the driver will decide what kind of memory will be used,
    when it will be allocated and when it will be freed.
    """
rimmUser = lib_mvIMPACT_acquire.rimmUser
r"""
    User supplied memory mode.
    A request in this mode can capture data directly into a user supplied
    buffer.

    The user can assign a buffer to each request that has been set into this
    mode. However some devices require the capture memory to be aligned thus
    then the buffer supplied by the user must be aligned to the requirements
    of the driver as well. To find out, which alignment is needed, the property
    *captureBufferAlignment* must be queried.
    """
rrOK = lib_mvIMPACT_acquire.rrOK
r""" This image request has been processed successfully."""
rrTimeout = lib_mvIMPACT_acquire.rrTimeout
r""" This image request resulted in a timeout. No image has been captured during the allowed period of time."""
rrError = lib_mvIMPACT_acquire.rrError
r"""
    An error occurred during the processing of this request.
    **mvBlueFOX** **specific**:
    This error typically results in some kind of USB transmission problem. The log-file will contain
    more information in that case.
    """
rrRequestAborted = lib_mvIMPACT_acquire.rrRequestAborted
r""" This request has been aborted either because there are no free internal buffers or the user itself caused this abort e.g. by clearing the request queue."""
rrFrameIncomplete = lib_mvIMPACT_acquire.rrFrameIncomplete
r"""
    An incomplete frame was transferred.
    This can have several reasons, however the one most likely is that the transfer channel couldn't cope with
    the amount of data that was transmitted resulting in parts of the frame or in the worst case the complete
    frame being lost.

    This e.g. might happen if several network devices transmit at the same time or a single device (e.g. connected
    to a PCI bus transfers more data then the PCI bus can pass to the receiving end until a temporary buffer on the
    device runs full. The log output will contain additional information.

    If the information is available the property 'MissingData_pc' belonging to that request will contain information
    about the amount of data missing. Also some of the statistical properties will provide hints about how much
    data is lost. E.g. the properties 'MissingPacktesRecovered', 'RetransmitCount' and 'MissingDataAverage_pc' might
    be of interest here. Please note that not every property is supported by every device.
    """
rrDeviceAccessLost = lib_mvIMPACT_acquire.rrDeviceAccessLost
r"""
    The access to the device has been lost.
    In this case no further access to the device will succeed. Only closing and re-opening the device
    will fix this problem. There can be numerous reasons for this error to occur, however the most likely one
    is that a device, that a timeout register inside the device, that needs to be refreshed constantly by
    the driver hasn't been refreshed during the timeout period. In this case the device will disconnect
    itself from the driver. This e.g. can happen if a network device is used and the application is operated in
    debug mode. For debugging the corresponding timeout register must be set to an appropriate value.
    """
rrInconsistentBufferContent = lib_mvIMPACT_acquire.rrInconsistentBufferContent
r"""
    A complete buffer has been delivered, but it did fail to pass the internal validation check.
    This e.g. might happen with drivers that transmit buffers that contain more than a pure block of pixel
    data. Examples for this might be run-length encoded images, or buffers with additional information
    somewhere in the buffer that will be interpreted by the device driver. This error is most likely a
    result of a device that doesn't transfer data in the requested format. The log output will contain
    additional information.
    """
rrFrameCorrupt = lib_mvIMPACT_acquire.rrFrameCorrupt
r"""
    The device has reported that an image acquisition did fail on the device side thus **BEFORE** the data transfer.
    This e.g. might happen if a device is running low on local memory or because of some other problem detected
    on the device itself. This result status is just meant for information. The associated buffer will not contain
    valid image data.
    """
rrUnprocessibleRequest = lib_mvIMPACT_acquire.rrUnprocessibleRequest
r"""
    This request is not processible.
    If this flag (the MSB) is set this either indicates that the current input parameters
    can't be used to capture an image (in that case the result will not be the MSB alone)
    or that an internal error occurred during the process of this request.
    """
rrNoBufferAvailable = lib_mvIMPACT_acquire.rrNoBufferAvailable
r"""
    No free buffer available to process this request.
    To get more memory either some old requests should be unlocked or the size of the
    DMA memory (frame grabbers only) could be increased using the tools provided.
    """
rrNotEnoughMemory = lib_mvIMPACT_acquire.rrNotEnoughMemory
r"""
    There is not enough memory available to the driver to process the current image request.
    To get more memory either some old requests should be unlocked or the size of the
    DMA memory (frame grabbers only) could be increased using the tools provided.

    Another possibility might be, that the process currently hosting the application cannot
    map all the capture memory requested by the application. In this case adding more memory to
    the system might solve the problem. Please note that when running on a 32 bit system no
    more than 2 GB of RAM can be used by a single process, thus applications demanding a lot
    of memory might still not run then. In this case only reducing the number of request buffers
    will help.
    """
rrCameraNotSupported = lib_mvIMPACT_acquire.rrCameraNotSupported
r"""
    The current camera description is not supported by the capture device.
    This error code currently is relevant for frame grabbers only and might occur e.g.
    when selecting a **MEDIUM CameraLink(R)** camera description for a grabber,
    that only supports **BASE** cameras.
    """
rrDataAcquisitionNotSupported = lib_mvIMPACT_acquire.rrDataAcquisitionNotSupported
r"""
    The device does not support capturing data in the current configuration.
    This error code will occur if a request has been sent to a device that does not
    support the acquisition of data. This can e.g. be the case

    - for GEV or U3V devices that do **NOT** support at least 1 streaming channel
    - for U3V devices that have been opened with **mvIMPACT::acquire::damRead** access

    Since: 2.5.0
    """
rsIdle = lib_mvIMPACT_acquire.rsIdle
r""" This **mvIMPACT::acquire::Request** is currently unused."""
rsWaiting = lib_mvIMPACT_acquire.rsWaiting
r""" This **mvIMPACT::acquire::Request** has been sent into the drivers image request queue and currently awaits processing."""
rsCapturing = lib_mvIMPACT_acquire.rsCapturing
r""" This **mvIMPACT::acquire::Request** is currently being processed."""
rsReady = lib_mvIMPACT_acquire.rsReady
r"""
    This **mvIMPACT::acquire::Request** has been processed.
    The user is now responsible for this request. Before this **mvIMPACT::acquire::Request** is not unlocked
    again it can't be used by the driver. A **mvIMPACT::acquire::Request** in this state can safely be processed
    by the user. Its data will remain valid until either the **mvIMPACT::acquire::Request** is unlocked by
    the user or the device is closed.
    """
rsBeingConfigured = lib_mvIMPACT_acquire.rsBeingConfigured
r"""
    This **mvIMPACT::acquire::Request** is currently in configuration mode.
    Within this mode certain properties of the request object will become writeable, which
    e.g. will allow the user to pass a capture buffer to the request object.
    """
rtctrlModeStop = lib_mvIMPACT_acquire.rtctrlModeStop
r""" RTC switched off and editable."""
rtctrlModeRun = lib_mvIMPACT_acquire.rtctrlModeRun
r""" RTC switched on and NOT editable."""
rtctrlModeRunRestart = lib_mvIMPACT_acquire.rtctrlModeRunRestart
r""" RTC switched on and restart after changes."""
rtctrlProgNop = lib_mvIMPACT_acquire.rtctrlProgNop
r""" Do nothing."""
rtctrlProgSetDigout = lib_mvIMPACT_acquire.rtctrlProgSetDigout
r""" Set digital outputs."""
rtctrlProgWaitDigin = lib_mvIMPACT_acquire.rtctrlProgWaitDigin
r""" Wait for digital inputs."""
rtctrlProgWaitClocks = lib_mvIMPACT_acquire.rtctrlProgWaitClocks
r""" Wait for n clocks."""
rtctrlProgJumpLoc = lib_mvIMPACT_acquire.rtctrlProgJumpLoc
r""" Jump to location."""
rtctrlProgTriggerSet = lib_mvIMPACT_acquire.rtctrlProgTriggerSet
r""" Set internal trigger signal of the sensor controller."""
rtctrlProgTriggerReset = lib_mvIMPACT_acquire.rtctrlProgTriggerReset
r""" Reset internal trigger signal of the sensor controller."""
rtctrlProgExposeSet = lib_mvIMPACT_acquire.rtctrlProgExposeSet
r""" Set internal expose signal of the sensor controller."""
rtctrlProgExposeReset = lib_mvIMPACT_acquire.rtctrlProgExposeReset
r""" Reset internal expose signal of the sensor controller."""
rtctrlProgFrameNrReset = lib_mvIMPACT_acquire.rtctrlProgFrameNrReset
r""" Reset internal sensor frame counter."""
rtctrlProgJumpLocOnZero = lib_mvIMPACT_acquire.rtctrlProgJumpLocOnZero
r""" Jump to location if a certain register contains zero."""
rtctrlProgJumpLocOnNotZero = lib_mvIMPACT_acquire.rtctrlProgJumpLocOnNotZero
r""" Jump to location if a certain register differs from zero."""
rtctrlProgRegisterSet = lib_mvIMPACT_acquire.rtctrlProgRegisterSet
r""" Set a registers value."""
rtctrlProgRegisterAdd = lib_mvIMPACT_acquire.rtctrlProgRegisterAdd
r""" Add a constant value to a register."""
rtctrlProgRegisterSub = lib_mvIMPACT_acquire.rtctrlProgRegisterSub
r""" Subtract a constant value from a register."""
simNearestNeighbor = lib_mvIMPACT_acquire.simNearestNeighbor
r""" Nearest neighbor interpolation (default)."""
simLinear = lib_mvIMPACT_acquire.simLinear
r""" Linear interpolation."""
simCubic = lib_mvIMPACT_acquire.simCubic
r""" Cubic interpolation."""
smOff = lib_mvIMPACT_acquire.smOff
r""" The scaler is switched off (default)."""
smOn = lib_mvIMPACT_acquire.smOn
r""" The scaler is switched on."""
scAuto = lib_mvIMPACT_acquire.scAuto
r"""
    The cameras clock signal is used.
    If the property *pixelClockOutput* in the camera description is either set to
    **mvIMPACT::acquire::ceseFallingEdge** or
    **mvIMPACT::acquire::ceseRisingEdge**.
    Otherwise **mvIMPACT::acquire::scAnalogue** is used for **mvTITAN-RGB**
    and **mvTITAN-G1** devices and **mvIMPACT::acquire::scDigital** for
    **mvGAMMA-G** devices. Other devices currently do not support this feature.
    """
scAnalogue = lib_mvIMPACT_acquire.scAnalogue
r"""
    The scan clock is generated by genlocking on horizontal sync.(HD) signal.
    **ADVANTAGES:**

    - very small jitter (typically around some 100 pico seconds) -> suitable for high pixel clock (>20Mhz)
    - for matching HD freq. values (with respect to the signal send by the camera) this will produce
    results almost as good as when working with an external clock signal(less scan artifacts)

    **DISADVANTAGES:**

    - slow reaction time -> not suitable for fast channel switching
    - not suitable for signals with a pixel clock below 12 MHz
    """
scDigital = lib_mvIMPACT_acquire.scDigital
r"""
    The scan clock is generated digitally.
    **ADVANTAGE:**

    - locked after a single line, therefore this mode is very useful for fast channel switching

    **DISADVANTAGE:**

    - bigger jitter as the analogue mode(<10ns), therefore not suitable for cameras with a pixel clock higher then about 20Mhz
    """
ssITU601 = lib_mvIMPACT_acquire.ssITU601
r""" 720 x 576 Pixels for 50 Hz standard cameras, 720 x 480 Pixels for 60 Hz standard cameras"""
ssSquare = lib_mvIMPACT_acquire.ssSquare
r""" 768 x 576 Pixels for 50 Hz standard cameras, 640 x 480 Pixels for 60 Hz standard cameras"""
ssUser = lib_mvIMPACT_acquire.ssUser
r""" The user can define scan rate and camera AOI"""
tmOnFallingEdge = lib_mvIMPACT_acquire.tmOnFallingEdge
r""" A falling edge will trigger the event."""
tmOnRisingEdge = lib_mvIMPACT_acquire.tmOnRisingEdge
r""" A rising edge will trigger the event."""
udarRead = lib_mvIMPACT_acquire.udarRead
r""" The user has read rights for this entry."""
udarWrite = lib_mvIMPACT_acquire.udarWrite
r"""
    The user has principle write rights for this entry.
    If **mvIMPACT::acquire::udarPassword** is not set for this entry or
    the corresponding password has been set correctly, the user can modify the
    corresponding entry.
    """
udarRW = lib_mvIMPACT_acquire.udarRW
r""" Just combines **mvIMPACT::acquire::udarRead** and **mvIMPACT::acquire::udarWrite**."""
udarPassword = lib_mvIMPACT_acquire.udarPassword
r"""
    A password is needed to modify this entry.
    Even if **mvIMPACT::acquire::udarWrite** is specified the user can only modify this entry
    if the correct password has been set.
    """
udarFull = lib_mvIMPACT_acquire.udarFull
r""" Combines all other flags."""
udrbKeepCachedData = lib_mvIMPACT_acquire.udrbKeepCachedData
r"""
    Keep the data currently buffered in the properties describing the user data.
    When the user data has been modified on another machine this
    will result in a loss of that data once this buffered data is written back
    to the devices non-volatile memory.
    """
udrbUpdateFromDeviceData = lib_mvIMPACT_acquire.udrbUpdateFromDeviceData
r"""
    Updates the properties describing the user data with the fresh data as read from the devices non-volatile memory.
    This might result in the loss of data that has been edited but **NOT** written
    to the devices non-volatile memory if this data differs from the current
    data stored in the devices non-volatile memory.
    """
vcMPEG2 = lib_mvIMPACT_acquire.vcMPEG2
r"""
     MPEG2.
    Recommend file extension for this codec: .m2v

    Supported input pixel formats for this video codec:
    - **mvIMPACT::acquire::ibpfYUV422Packed**
    - **mvIMPACT::acquire::ibpfYUV422Planar**
    """
vcH264 = lib_mvIMPACT_acquire.vcH264
r"""
     H264.
    Recommend file extension for this codec: .mp4

    Supported input pixel formats for this video codec:
    - **mvIMPACT::acquire::ibpfYUV422Packed**
    - **mvIMPACT::acquire::ibpfYUV422Planar**
    """
vcH265 = lib_mvIMPACT_acquire.vcH265
r"""
     H265.
    Recommend file extension for this codec: .mp4

    Supported input pixel formats for this video codec:
    - **mvIMPACT::acquire::ibpfYUV422Packed**
    - **mvIMPACT::acquire::ibpfYUV422Planar**
    """
vsCCIR = lib_mvIMPACT_acquire.vsCCIR
r""" CCIR video signal: Grey, 50 fields per second, 625 lines."""
vsRS170 = lib_mvIMPACT_acquire.vsRS170
r""" RS 170 video signal: Grey, 60 fields per second, 525 lines."""
vsPALBGH = lib_mvIMPACT_acquire.vsPALBGH
r""" PAL video signal: Color, 50 fields per second, 625 lines."""
vsNTSCM = lib_mvIMPACT_acquire.vsNTSCM
r""" NTSC video signal: Color, 60 fields per second, 525 lines."""
vsSDI480i = lib_mvIMPACT_acquire.vsSDI480i
r""" SDI video signal: 60 fields per second, 480 lines, interlaced."""
vsSDI576i = lib_mvIMPACT_acquire.vsSDI576i
r""" SDI video signal: 50 fields per second, 576 lines, interlaced."""
vsSDI720p = lib_mvIMPACT_acquire.vsSDI720p
r""" SDI video signal: Different frame rates, 720 lines, progressive."""
vsSDI1080i = lib_mvIMPACT_acquire.vsSDI1080i
r""" SDI video signal: Different frame rates, 1080 lines, interlaced."""
vsSDI1080p = lib_mvIMPACT_acquire.vsSDI1080p
r""" SDI video signal: Different frame rates, 1080 lines, progressive."""
vditNone = lib_mvIMPACT_acquire.vditNone
r""" Will capture none of the recognized image formats"""
vditBMP = lib_mvIMPACT_acquire.vditBMP
r""" Will capture BMP files."""
vditPGM = lib_mvIMPACT_acquire.vditPGM
r""" Will capture PGM files."""
vditPNG = lib_mvIMPACT_acquire.vditPNG
r"""
     Will capture PNG files.
    Notes: 
    This requires the FreeImage (see http://freeimage.sourceforge.net/) library being present on the target system. See **Use** **Cases** section of the mvVirtualDriver for details.

    Since: 2.11.9
    """
vditJPG = lib_mvIMPACT_acquire.vditJPG
r"""
     Will capture JPG files.
    Notes: 
    This requires the FreeImage (see http://freeimage.sourceforge.net/) library being present on the target system. See **Use** **Cases** section of the mvVirtualDriver for details.

    Since: 2.11.9
    """
vditTIFF = lib_mvIMPACT_acquire.vditTIFF
r"""
     Will capture TIFF files.
    Notes: 
    This requires the FreeImage (see http://freeimage.sourceforge.net/) library being present on the target system. See **Use** **Cases** section of the mvVirtualDriver for details.

    Since: 2.11.9
    """
vditALL = lib_mvIMPACT_acquire.vditALL
r""" Will capture all supported image formats."""
vdtmMovingRGBx888PackedImage = lib_mvIMPACT_acquire.vdtmMovingRGBx888PackedImage
r""" Will generate a moving test pattern with pixel format **mvIMPACT::acquire::ibpfRGBx888Packed**."""
vdtmMovingRGB888PackedImage = lib_mvIMPACT_acquire.vdtmMovingRGB888PackedImage
r""" Will generate a moving test pattern with pixel format **mvIMPACT::acquire::ibpfRGB888Packed**."""
vdtmMovingRGBx888PlanarImage = lib_mvIMPACT_acquire.vdtmMovingRGBx888PlanarImage
r""" Will generate a moving test pattern with pixel format **mvIMPACT::acquire::ibpfRGBx888Planar**."""
vdtmMovingMonoRamp = lib_mvIMPACT_acquire.vdtmMovingMonoRamp
r""" Will generate a moving horizontal test pattern with a mono pixel format."""
vdtmMovingYUV422PackedRamp = lib_mvIMPACT_acquire.vdtmMovingYUV422PackedRamp
r""" Will generate a moving test pattern with pixel format **mvIMPACT::acquire::ibpfYUV422Packed** or **mvIMPACT::acquire::ibpfYUV422_10Packed** depending on the value of the 'ChannelBitDepth' property."""
vdtmMovingYUV422PlanarRamp = lib_mvIMPACT_acquire.vdtmMovingYUV422PlanarRamp
r""" Will generate a moving test pattern with pixel format **mvIMPACT::acquire::ibpfYUV422Planar**."""
vdtmMovingRGB101010PackedImage = lib_mvIMPACT_acquire.vdtmMovingRGB101010PackedImage
r""" Will generate a moving test pattern with pixel format **mvIMPACT::acquire::ibpfRGB101010Packed**."""
vdtmMovingRGB121212PackedImage = lib_mvIMPACT_acquire.vdtmMovingRGB121212PackedImage
r""" Will generate a moving test pattern with pixel format **mvIMPACT::acquire::ibpfRGB121212Packed**."""
vdtmMovingRGB141414PackedImage = lib_mvIMPACT_acquire.vdtmMovingRGB141414PackedImage
r""" Will generate a moving test pattern with pixel format **mvIMPACT::acquire::ibpfRGB141414Packed**."""
vdtmMovingRGB161616PackedImage = lib_mvIMPACT_acquire.vdtmMovingRGB161616PackedImage
r""" Will generate a moving test pattern with pixel format **mvIMPACT::acquire::ibpfRGB161616Packed**."""
vdtmMovingBayerDataRamp = lib_mvIMPACT_acquire.vdtmMovingBayerDataRamp
r""" Will generate a moving Bayer test pattern."""
vdtmBayerWhiteBalanceTestImage = lib_mvIMPACT_acquire.vdtmBayerWhiteBalanceTestImage
r""" Will generate a still Bayer test pattern that can be used for white balancing."""
vdtmImageDirectory = lib_mvIMPACT_acquire.vdtmImageDirectory
r""" Will capture images from a user supplied directory."""
vdtmLeakyPixelTestImageMono8Bayer = lib_mvIMPACT_acquire.vdtmLeakyPixelTestImageMono8Bayer
r""" Will generate a still 8 bit Bayer test pattern for leaky pixel calibration."""
vdtmMovingYUV422_UYVYPackedRamp = lib_mvIMPACT_acquire.vdtmMovingYUV422_UYVYPackedRamp
r""" Will generate a moving test pattern with pixel format **mvIMPACT::acquire::ibpfYUV422_UYVYPacked** or **mvIMPACT::acquire::ibpfYUV422_UYVY_10Packed** depending on the value of the 'ChannelBitDepth' property."""
vdtmHorizontalMonoRamp = lib_mvIMPACT_acquire.vdtmHorizontalMonoRamp
r""" Will generate a horizontal mono ramp."""
vdtmVerticalMonoRamp = lib_mvIMPACT_acquire.vdtmVerticalMonoRamp
r""" Will generate a vertical mono ramp."""
vdtmMovingVerticalMonoRamp = lib_mvIMPACT_acquire.vdtmMovingVerticalMonoRamp
r""" Will generate a moving vertical mono ramp."""
vdtmHorizontalMono12Packed_V2Ramp = lib_mvIMPACT_acquire.vdtmHorizontalMono12Packed_V2Ramp
r""" Will generate a horizontal mono ramp with pixel format **mvIMPACT::acquire::ibpfMono12Packed_V2**."""
vdtmMovingBGR888PackedImage = lib_mvIMPACT_acquire.vdtmMovingBGR888PackedImage
r""" Will generate a moving test pattern with pixel format **mvIMPACT::acquire::ibpfBGR888Packed**."""
vdtmMovingYUV444PackedRamp = lib_mvIMPACT_acquire.vdtmMovingYUV444PackedRamp
r""" Will generate a moving test pattern with pixel format **mvIMPACT::acquire::ibpfYUV444Packed** or **mvIMPACT::acquire::ibpfYUV444_10Packed** depending on the value of the 'ChannelBitDepth' property."""
vdtmMovingYUV444_UYVPackedRamp = lib_mvIMPACT_acquire.vdtmMovingYUV444_UYVPackedRamp
r""" Will generate a moving test pattern with pixel format **mvIMPACT::acquire::ibpfYUV444_UYVPacked** or **mvIMPACT::acquire::ibpfYUV444_UYV_10Packed** depending on the value of the 'ChannelBitDepth' property."""
vdtmMovingBGRPacked_V2Image = lib_mvIMPACT_acquire.vdtmMovingBGRPacked_V2Image
r""" Will generate a moving test pattern with pixel format **mvIMPACT::acquire::ibpfBGR101010Packed_V2**."""
vdtmEmptyMonoBuffer = lib_mvIMPACT_acquire.vdtmEmptyMonoBuffer
r""" Will just allocate but not initialize a mono buffer."""
vdtmHorizontalMono12Packed_V1Ramp = lib_mvIMPACT_acquire.vdtmHorizontalMono12Packed_V1Ramp
r"""
     Will generate a horizontal mono ramp with pixel format **mvIMPACT::acquire::ibpfMono12Packed_V1**.
    Since: 2.5.0
    """
vdtmHorizontalBayer12Packed_V1Ramp = lib_mvIMPACT_acquire.vdtmHorizontalBayer12Packed_V1Ramp
r"""
     Will generate a horizontal Bayer ramp with pixel format **mvIMPACT::acquire::ibpfMono12Packed_V1**.
    Since: 2.5.2
    """
vdtmHorizontalBayer12Packed_V2Ramp = lib_mvIMPACT_acquire.vdtmHorizontalBayer12Packed_V2Ramp
r"""
     Will generate a horizontal Bayer ramp with pixel format **mvIMPACT::acquire::ibpfMono12Packed_V2**.
    Since: 2.5.2
    """
vdtmMovingYUV411_UYYVYY_PackedRamp = lib_mvIMPACT_acquire.vdtmMovingYUV411_UYYVYY_PackedRamp
r"""
     Will generate a moving test pattern with pixel format **mvIMPACT::acquire::ibpfYUV411_UYYVYY_Packed**.
    Since: 2.13.0
    """
vdtmMovingRGB888PlanarImage = lib_mvIMPACT_acquire.vdtmMovingRGB888PlanarImage
r"""
     Will generate a moving test pattern with pixel format **mvIMPACT::acquire::ibpfRGB888Planar**.
    Since: 2.17.0
    """
vdtmHotAndColdPixelTestImageBayer = lib_mvIMPACT_acquire.vdtmHotAndColdPixelTestImageBayer
r"""
     Will generate a still Bayer test pattern for hot and cold pixel calibration.
    Since: 2.31.0
    """
vdtmHotAndColdPixelTestImageRGB888Packed = lib_mvIMPACT_acquire.vdtmHotAndColdPixelTestImageRGB888Packed
r"""
     Will generate a still RGB8 test pattern for hot and cold pixel calibration.
    Since: 2.33.0
    """
wbcmOff = lib_mvIMPACT_acquire.wbcmOff
r""" Do not perform calibration, current values will be used."""
wbcmNextFrame = lib_mvIMPACT_acquire.wbcmNextFrame
r"""
    Use the next image to perform the white balance calibration.
    This is defined for bayer color sensors only.
    """
wbcmContinuous = lib_mvIMPACT_acquire.wbcmContinuous
r""" Do a continuous white balance calibration."""
wbpTungsten = lib_mvIMPACT_acquire.wbpTungsten
r""" A set of constant parameters optimised for scenes illuminated by tungsten light sources."""
wbpHalogen = lib_mvIMPACT_acquire.wbpHalogen
r""" A set of constant parameters optimised for scenes illuminated by halogen light sources."""
wbpFluorescent = lib_mvIMPACT_acquire.wbpFluorescent
r""" A set of constant parameters optimised for scenes illuminated by fluorescent light sources."""
wbpDayLight = lib_mvIMPACT_acquire.wbpDayLight
r""" A set of constant parameters optimised for scenes illuminated by day light."""
wbpPhotoFlash = lib_mvIMPACT_acquire.wbpPhotoFlash
r""" A set of constant parameters optimised for scenes illuminated by photo flash light sources."""
wbpBlueSky = lib_mvIMPACT_acquire.wbpBlueSky
r""" A set of constant parameters optimised for scenes illuminated by day light and perfect weather."""
wbpUser1 = lib_mvIMPACT_acquire.wbpUser1
r""" A parameter set which can be modified by the user."""
wbpUser2 = lib_mvIMPACT_acquire.wbpUser2
r""" A parameter set which can be modified by the user."""
wbpUser3 = lib_mvIMPACT_acquire.wbpUser3
r""" A parameter set which can be modified by the user."""
wbpUser4 = lib_mvIMPACT_acquire.wbpUser4
r""" A parameter set which can be modified by the user."""
ctOnChanged = lib_mvIMPACT_acquire.ctOnChanged
r""" Execute callback whenever this component has been modified."""
ctOnReadData = lib_mvIMPACT_acquire.ctOnReadData
r""" Executed when a property's value is read. The callback is executed before the value is returned to the user. This allows i.e. a driver to determine the value for this property only if the user is interested in its data."""
ctOnWriteData = lib_mvIMPACT_acquire.ctOnWriteData
r""" Executed when a property's value is written. The callback is executed before the value is actually assigned. This allows i.e. a driver to validate if this is a valid value for the property."""
ctOnRefreshCache = lib_mvIMPACT_acquire.ctOnRefreshCache
r""" Executed when a component is accessed (read or write) and some of the internal data needs to be refreshed from an external source. The callback is executed before the component data is accessed. This allows i.e. a driver to update the data before."""
cfUndefined = lib_mvIMPACT_acquire.cfUndefined
r"""
    This is used to define an inconsistent/invalid flag.
    This e.g. can be used as a return value for a function, that could not
    calculate a valid flag mask.
    """
cfReadAccess = lib_mvIMPACT_acquire.cfReadAccess
r"""
    This component can be accessed for reading.
    If this flag is set this component can be accessed for reading. This
    involves reading a property's data, reading a component list's elements
    reading the size of a component list and so on.
    """
cfWriteAccess = lib_mvIMPACT_acquire.cfWriteAccess
r"""
    This component can be accessed for writing.
    If this flag is set this component can be accessed for writing or modifying its data.
    This involves writing values to a property, adding components to a list and so on.
    """
cfRWAccess = lib_mvIMPACT_acquire.cfRWAccess
r"""
    This component can be accessed for both reading and writing.
    This just combines **mvIMPACT::acquire::cfReadAccess** and
    **mvIMPACT::acquire::cfWriteAccess**
    """
cfFixedSize = lib_mvIMPACT_acquire.cfFixedSize
r"""
    This components element count can be modified.
    If this flag is set this components element count can't be modified. For a list this would mean,
    that the number of elements stored in this list can't be modified. For a property this means,
    that the number of values stored in the property can't be modified.
    """
cfInvisible = lib_mvIMPACT_acquire.cfInvisible
r"""
    The component is shadowed by other settings currently if set.
    This flag is used to specify that this component currently has no effect on the behaviour
    of the system. This flag is just meant as a hint for the user. The property module
    itself does **NOT** use this flag for anything.
    """
cfAllowValueCombinations = lib_mvIMPACT_acquire.cfAllowValueCombinations
r"""
    Allows combinations of translation dictionary entry as valid values.
    If this flag is set for a property that defines a translation dictionary not
    only values, which are registered in the translation dictionary are allowed
    values for this property, but also values logical OR-ed together with values from
    the translation dictionary (these obviously can't be set as strings).

    A property defines two entries ("one", 1) and ("two", 2) then 1 | 2 = 3 will be a
    valid value as well, but "three" obviously won't.

    In a GUI application a property specifying this flag should be displayed
    as a set of check-box controls (one for each dictionary entry) or something
    similar.

    Notes: 
    If this flag is specified for a component, which is not a property, it will have no
    effect on the behaviour of the component. Only integer properties can use this feature
    """
cfShouldBeDisplayedAsList = lib_mvIMPACT_acquire.cfShouldBeDisplayedAsList
r"""
    Informs a displaying GUI that this component should be displayed as a list.
    This flag e.g. can be set for an array property to inform a displaying GUI, that
    this property is best displayed as a list with a entry for each element.
    This flag is just meant as a hint for the user. The property module
    itself does **NOT** use this flag for anything.
    """
cfDisallowSerialize = lib_mvIMPACT_acquire.cfDisallowSerialize
r""" If set this component or derived components can't be stored as external data."""
cfAlwaysForceClone = lib_mvIMPACT_acquire.cfAlwaysForceClone
r"""
    If set this component is always cloned completely.
    This results in the component being completely independent from its parent no matter
    whether it has been built while deriving or cloning a list and thus the components
    within this list and its sub-lists.

    This will change the behaviour to that effect that changing the parent component
    will no longer affect the 'derived' component. So
    different default values, constants and translation dictionaries for properties
    within an inheritance hierarchy can be defined.

    Notes: 
    This feature is currently only supported for components of type
    **mvIMPACT::acquire::ctPropInt**, **mvIMPACT::acquire::ctPropInt64**
    and **mvIMPACT::acquire::ctPropFloat**.
    """
cfNotAvailable = lib_mvIMPACT_acquire.cfNotAvailable
r"""
    If set, this component is currently not available due to the setting of another feature.
    In this case this feature can't be written to nor can it be read.
    """
cfNotImplemented = lib_mvIMPACT_acquire.cfNotImplemented
r""" If set, this feature has been defined, but so far has not been implemented."""
cfContainsBinaryData = lib_mvIMPACT_acquire.cfContainsBinaryData
r"""
    Specifies a property, which contains binary data.
    This flag is used to specify a property that contains data in binary format
    """
cfShouldBeDisplayedAsEnumeration = lib_mvIMPACT_acquire.cfShouldBeDisplayedAsEnumeration
r"""
    Informs a displaying GUI that this component should be displayed as an enumeration(e.g. with a combo box).
    This flag e.g. can be set for a property to inform a displaying GUI, that
    this property is best displayed as a combo box or something similar.
    This flag is just meant as a hint for the user. The property module
    itself does **NOT** use this flag for anything.

    Since: 1.12.57
    """
cfAlwaysForceUpdate = lib_mvIMPACT_acquire.cfAlwaysForceUpdate
r""" This feature will **ALWAYS** execute internal update callbacks and will treat each write attempt to this feature as a value different from the current one."""
vtInt = lib_mvIMPACT_acquire.vtInt
r""" Defines a property for 32 bit integer types."""
vtFloat = lib_mvIMPACT_acquire.vtFloat
r""" Defines a property for float types."""
vtPtr = lib_mvIMPACT_acquire.vtPtr
r""" Defines a property for pointer types."""
vtString = lib_mvIMPACT_acquire.vtString
r""" Defines a property for strings."""
vtInt64 = lib_mvIMPACT_acquire.vtInt64
r""" Defines a property for 64 bit integer types."""
crUndefined = lib_mvIMPACT_acquire.crUndefined
crLinear = lib_mvIMPACT_acquire.crLinear
r""" Defines a feature with linear behaviour. One possible editor would be a slider with linear behaviour."""
crLogarithmic = lib_mvIMPACT_acquire.crLogarithmic
r""" Defines a feature with logarithmic behaviour. One possible editor would be a slider with logarithmic behaviour."""
crBoolean = lib_mvIMPACT_acquire.crBoolean
r""" Defines a boolean feature. This could be displayed to the user as a check box."""
crPureNumber = lib_mvIMPACT_acquire.crPureNumber
r""" Defines a feature representing a pure number. This could be displayed to the user as an edit control."""
crHexNumber = lib_mvIMPACT_acquire.crHexNumber
r""" Defines a feature representing a hexadecimal number."""
crIPv4Address = lib_mvIMPACT_acquire.crIPv4Address
r""" Defines a feature representing an IPv4 address. This could be displayed to the user as a custom IPv4 edit control."""
crMACAddress = lib_mvIMPACT_acquire.crMACAddress
r""" Defines a feature representing a MAC address. This could be displayed to the user as a custom MAC address edit control."""
crFileName = lib_mvIMPACT_acquire.crFileName
r""" Defines a feature representing a file name. This could be displayed to the user as a file selection dialog."""
crDirectoryName = lib_mvIMPACT_acquire.crDirectoryName
r""" Defines a feature representing a directory name. This could be displayed to the user as a directory selection dialog."""
ctProp = lib_mvIMPACT_acquire.ctProp
r"""
    A property type.
    This type will never occur in a real world application. It's just used
    to build up the other types. Properties can be used to store user specific
    data in a structured way.
    """
ctList = lib_mvIMPACT_acquire.ctList
r"""
    A list object.
    Lists can contain other components like lists, methods and properties.
    Thus lists can be used to build up hierarchical structures of different
    components.
    """
ctMeth = lib_mvIMPACT_acquire.ctMeth
r"""
    A method object.
    Method objects provide the possibility to organize functions in lists.
    """
ctPropInt = lib_mvIMPACT_acquire.ctPropInt
r""" Defines a property for 32 bit integer values."""
ctPropFloat = lib_mvIMPACT_acquire.ctPropFloat
r""" Defines a property for floating point values."""
ctPropString = lib_mvIMPACT_acquire.ctPropString
r""" Defines a property for string values."""
ctPropPtr = lib_mvIMPACT_acquire.ctPropPtr
r""" Defines a property for pointer values."""
ctPropInt64 = lib_mvIMPACT_acquire.ctPropInt64
r""" Defines a property for 64 bit integer values."""
cvBeginner = lib_mvIMPACT_acquire.cvBeginner
r""" Defines a feature that should be visible for all users via the GUI and API. This is the default visibility if no visibility has been specified for a particular component."""
cvExpert = lib_mvIMPACT_acquire.cvExpert
r""" Defines a feature that requires a more in-depth knowledge of the functionality. This is the preferred visibility level for all advanced features."""
cvGuru = lib_mvIMPACT_acquire.cvGuru
r""" Defines an advanced feature that if not configured correctly might result in unexpected behaviour."""
cvInvisible = lib_mvIMPACT_acquire.cvInvisible
r""" Defines a feature that should not be displayed in a GUI but is still accessible via API function calls."""
PROPHANDLING_NO_ERROR = lib_mvIMPACT_acquire.PROPHANDLING_NO_ERROR
r"""
    The operation has been executed successfully.
    **[0]**
    """
PROPHANDLING_NOT_A_LIST = lib_mvIMPACT_acquire.PROPHANDLING_NOT_A_LIST
r"""
     This component is not a list.
     A list operation for this component has been called but this
     component does not reference a list.


    **[-2000]**
    """
PROPHANDLING_NOT_A_PROPERTY = lib_mvIMPACT_acquire.PROPHANDLING_NOT_A_PROPERTY
r"""
     This component is not a property.
     A property operation for this component has been called but
     this component does not reference a property.


    **[-2001]**
    """
PROPHANDLING_NOT_A_METHOD = lib_mvIMPACT_acquire.PROPHANDLING_NOT_A_METHOD
r"""
     This component is not a method.
     A method operation for this component has been called but
     this component does not reference a method.


    **[-2002]**
    """
PROPHANDLING_NO_READ_RIGHTS = lib_mvIMPACT_acquire.PROPHANDLING_NO_READ_RIGHTS
r"""
     The caller has no read rights for this component.
     It has been tried to read data from this component, but the
     caller has no read rights for this component.


    **[-2003]**
    """
PROPHANDLING_NO_WRITE_RIGHTS = lib_mvIMPACT_acquire.PROPHANDLING_NO_WRITE_RIGHTS
r"""
     The caller has no write rights for this component.
     It has been tried to modify data of this component, but the
     caller has no write rights for this component.


    **[-2004]**
    """
PROPHANDLING_NO_MODIFY_SIZE_RIGHTS = lib_mvIMPACT_acquire.PROPHANDLING_NO_MODIFY_SIZE_RIGHTS
r"""
     The caller can't modify the size of this component.
     It has been tried to modify the size of this list or
     the number of values stored by a property, but the caller doesn't
     have the required right to do this.

     This error will also be reported if the user tried to increase
     the number of values handled by a property above the maximum number
     of values it can handle. Therefore before resizing a property
     check if the new size might exceeds this maximum value by calling
     the appropriate function.


    **[-2005]**
    """
PROPHANDLING_INCOMPATIBLE_COMPONENTS = lib_mvIMPACT_acquire.PROPHANDLING_INCOMPATIBLE_COMPONENTS
r"""
     The two involved components are not compatible.
     An operation requiring two compatible components has been
     called with two components, which are not compatible.


    **[-2006]**
    """
PROPHANDLING_UNSUPPORTED_PARAMETER = lib_mvIMPACT_acquire.PROPHANDLING_UNSUPPORTED_PARAMETER
r"""
     One or more of the specified parameters are not supported by the function.
     This error might also be generated if a certain feature is not available on the current
     platform.


    **[-2008]**
    """
PROPHANDLING_SIZE_MISMATCH = lib_mvIMPACT_acquire.PROPHANDLING_SIZE_MISMATCH
r"""
     Different sized value buffers have been passed.
     While trying to read value pairs the caller passed two different
     sized value buffers to a function while one is too small to hold
     all the information.


    **[-2009]**
    """
PROPHANDLING_IMPLEMENTATION_MISSING = lib_mvIMPACT_acquire.PROPHANDLING_IMPLEMENTATION_MISSING
r"""
     A feature that is not implemented so far has been requested.
     The caller requested a feature, that hasn't been implemented so
     far. This error code is only provided for compatibility and will be
     set in very rare cases only.


    **[-2010]**
    """
PROPHANDLING_ACCESSTOKEN_CREATION_FAILED = lib_mvIMPACT_acquire.PROPHANDLING_ACCESSTOKEN_CREATION_FAILED
r"""
     An access token object couldn't be created.
     This can either happen, because the caller has not the rights required
     to create an access token or because the system runs very low on memory.

     Deprecated: This error code currently is not used anywhere within this framework.
     It might be removed in a future version.


    **[-2011]**
    """
PROPHANDLING_INVALID_PROP_VALUE = lib_mvIMPACT_acquire.PROPHANDLING_INVALID_PROP_VALUE
r"""
     It has been tried to assign an invalid value to a property.
     This can either happen if the value lies above or below the
     min. or max. value for a property or when it has been tried to
     write a value to a property, which is not in the properties translation
     dictionary (if it defines one).

     To find out, which values are allowed for the property in question
     the user should

      check if the property defines a translation dictionary

      check the allowed values within a translation dictionary if one is defined

      check the min and max value for properties, that define limits



    **[-2012]**
    """
PROPHANDLING_PROP_TRANSLATION_TABLE_CORRUPTED = lib_mvIMPACT_acquire.PROPHANDLING_PROP_TRANSLATION_TABLE_CORRUPTED
r"""
     The properties translation table has been corrupted.
     The properties translation table has been corrupted for an unknown
     reason and can't be used anymore.


    **[-2013]**
    """
PROPHANDLING_PROP_VAL_ID_OUT_OF_BOUNDS = lib_mvIMPACT_acquire.PROPHANDLING_PROP_VAL_ID_OUT_OF_BOUNDS
r"""
     Invalid value index.
     The caller tried to read a value from an invalid index from a property.
     Most properties store one value only, thus the only valid positive value
     index will be 0 (some negative index values are reserved for special
     values like e.g. the min/max value of a property). However some properties
     might store more than one value, thus the max. allowed index might
     be higher. The highest index allowed will always be the value count
     of a property minus one for properties with the **mvIMPACT::acquire::cfFixedSize**
     flag set. Other properties will automatically adjust the size once the user
     writes to an index out of bounds.


    **[-2014]**
    """
PROPHANDLING_PROP_TRANSLATION_TABLE_NOT_DEFINED = lib_mvIMPACT_acquire.PROPHANDLING_PROP_TRANSLATION_TABLE_NOT_DEFINED
r"""
     This property doesn't define a translation table.
     The caller tried to modify a translation table, that hasn't been
     defined for this property.


    **[-2015]**
    """
PROPHANDLING_INVALID_PROP_VALUE_TYPE = lib_mvIMPACT_acquire.PROPHANDLING_INVALID_PROP_VALUE_TYPE
r"""
     An invalid value has been passed to the property.
     Although properties are quite tolerant regarding the allowed assignment
     for them some value types can't be used to write all properties.
     As an example assigning a float value to an integer property would
     result in this error.

     Another reason for this error might be when a user tried to access e.g. a
     float property with functions meant to be used for int properties.


    **[-2016]**
    """
PROPHANDLING_PROP_VAL_TOO_LARGE = lib_mvIMPACT_acquire.PROPHANDLING_PROP_VAL_TOO_LARGE
r"""
     A too large value has been passed.
     One or more of the values the caller tried to write to the
     property are larger than the max. allowed value for this property.


    **[-2017]**
    """
PROPHANDLING_PROP_VAL_TOO_SMALL = lib_mvIMPACT_acquire.PROPHANDLING_PROP_VAL_TOO_SMALL
r"""
     A too small value has been passed.
     One or more of the values the caller tried to write to the
     property are smaller than the min. allowed value for this property.


    **[-2018]**
    """
PROPHANDLING_COMPONENT_NOT_FOUND = lib_mvIMPACT_acquire.PROPHANDLING_COMPONENT_NOT_FOUND
r"""
     The specified component could not be found.

    **[-2019]**
    """
PROPHANDLING_LIST_ID_INVALID = lib_mvIMPACT_acquire.PROPHANDLING_LIST_ID_INVALID
r"""
     An invalid list has been referenced.

    **[-2020]**
    """
PROPHANDLING_COMPONENT_ID_INVALID = lib_mvIMPACT_acquire.PROPHANDLING_COMPONENT_ID_INVALID
r"""
     An invalid component within a list has been referenced.

    **[-2021]**
    """
PROPHANDLING_LIST_ENTRY_OCCUPIED = lib_mvIMPACT_acquire.PROPHANDLING_LIST_ENTRY_OCCUPIED
r"""
     The specified list index is occupied.
     During the creation of a new component the caller tried
     the insert the newly created component into a list at a position
     already used to store another component.


    **[-2022]**
    """
PROPHANDLING_COMPONENT_HAS_OWNER_ALREADY = lib_mvIMPACT_acquire.PROPHANDLING_COMPONENT_HAS_OWNER_ALREADY
r"""
     The specified component already has an owner.
     The caller tried to assign an owner to a component that
     already has an owner. An owner once defined can't be modified
     anymore.


    **[-2023]**
    """
PROPHANDLING_COMPONENT_ALREADY_REGISTERED = lib_mvIMPACT_acquire.PROPHANDLING_COMPONENT_ALREADY_REGISTERED
r"""
     It has been tried to register the same component at twice in the same list.

    **[-2024]**
    """
PROPHANDLING_LIST_CANT_ACCESS_DATA = lib_mvIMPACT_acquire.PROPHANDLING_LIST_CANT_ACCESS_DATA
r"""
     The desired data can't be accessed or found.
     During loading or saving data this error can occur e.g.
     if it has been tried to import a setting from a location where
     the desired setting couldn't be found. Another reason for this error might
     be that the current user is not allowed to perform a certain operation on the
     desired data (e.g. a user tries to delete a setting that is stored with
     global scope but does not have elevated access rights).


    **[-2025]**
    """
PROPHANDLING_METHOD_PTR_INVALID = lib_mvIMPACT_acquire.PROPHANDLING_METHOD_PTR_INVALID
r"""
     The function pointer of the referenced method object is invalid.

    **[-2026]**
    """
PROPHANDLING_METHOD_INVALID_PARAM_LIST = lib_mvIMPACT_acquire.PROPHANDLING_METHOD_INVALID_PARAM_LIST
r"""
     A method object has an invalid parameter list.

    **[-2027]**
    """
PROPHANDLING_SWIG_ERROR = lib_mvIMPACT_acquire.PROPHANDLING_SWIG_ERROR
r"""
     This indicates an internal error occurred within the SWIG generated wrapper code, when working under Python.

    **[-2028]**
    """
PROPHANDLING_INVALID_INPUT_PARAMETER = lib_mvIMPACT_acquire.PROPHANDLING_INVALID_INPUT_PARAMETER
r"""
     A invalid input parameter has been passed to a function of this module.
     In most cases this might be a unassigned pointer, where a valid pointer
     to a user defined storage location was expected.


    **[-2029]**
    """
PROPHANDLING_COMPONENT_NO_CALLBACK_REGISTERED = lib_mvIMPACT_acquire.PROPHANDLING_COMPONENT_NO_CALLBACK_REGISTERED
r"""
     The user tried to modify a registered callback, but no callback has been registered for this component.

    **[-2030]**
    """
PROPHANDLING_INPUT_BUFFER_TOO_SMALL = lib_mvIMPACT_acquire.PROPHANDLING_INPUT_BUFFER_TOO_SMALL
r"""
     The user tried to read data into a user supplied storage location, but the buffer was too small to accommodate the result.

    **[-2031]**
    """
PROPHANDLING_WRONG_PARAM_COUNT = lib_mvIMPACT_acquire.PROPHANDLING_WRONG_PARAM_COUNT
r"""
     The number of parameters is incorrect.
     This error might occur if the user called a function with a variable number of input or output
     parameters and the number of parameters passed to the function does not match the
     number of required parameters.


    **[-2032]**
    """
PROPHANDLING_UNSUPPORTED_OPERATION = lib_mvIMPACT_acquire.PROPHANDLING_UNSUPPORTED_OPERATION
r"""
     The user tried to execute an operation, which is not supported by the component he is referring to.

    **[-2033]**
    """
PROPHANDLING_CANT_SERIALIZE_DATA = lib_mvIMPACT_acquire.PROPHANDLING_CANT_SERIALIZE_DATA
r"""
     The user tried to save(serialize) a property list without having the right to do this.

    **[-2034]**
    """
PROPHANDLING_INVALID_FILE_CONTENT = lib_mvIMPACT_acquire.PROPHANDLING_INVALID_FILE_CONTENT
r"""
     The user tried to use a file to update or create a component list, that does not contain valid data for this operation.
     This e.g. might happen, if the file does not contain valid XML data or XML data that is not
     well formed.


    **[-2035]**
    """
PROPHANDLING_CANT_ALLOCATE_LIST = lib_mvIMPACT_acquire.PROPHANDLING_CANT_ALLOCATE_LIST
r"""
     This error will occur when the modules internal representation of the tree structure does not allow the allocation of a new list.
     In this case either new list can't be allocated. The only way to solve this problem is to delete
     another list.


    **[-2036]**
    """
PROPHANDLING_CANT_REGISTER_COMPONENT = lib_mvIMPACT_acquire.PROPHANDLING_CANT_REGISTER_COMPONENT
r"""
     The referenced list has no space left to register this component at the desired position.
     There might however be an empty space within the list where this element could be registered, but
     no more components can be registered at the end of this list.


    **[-2037]**
    """
PROPHANDLING_PROP_VALIDATION_FAILED = lib_mvIMPACT_acquire.PROPHANDLING_PROP_VALIDATION_FAILED
r"""
     The user tried to assign a value to a property, that is invalid.
     This will result in a detailed error message in the log-file. This error might
     arise e.g. when a string property doesn't allow the string to contain numbers. In this
     case trying to set the properties value to 'blabla7bla' would cause this error.


    **[-2038]**
    """
PROPHANDLING_LAST_VALID_ERROR_CODE = lib_mvIMPACT_acquire.PROPHANDLING_LAST_VALID_ERROR_CODE
r"""
     Defines the last valid error code value for the property module.

    **[-2099]**
    """
sfDefault = lib_mvIMPACT_acquire.sfDefault
r"""
    A dummy flag to specify the default behaviour.
    Store/load operations will done in XML format in this case.
    """
sfNative = lib_mvIMPACT_acquire.sfNative
r"""
    Stores/loads the setting in/from a platform dependent location
    Under Windows(C) the Registry will be used to as a platform dependent location, while under
    other platforms an XML file will be processed in the path specified as the settings name.

    Notes: 
    Please note, that using this flag will introduce platform dependency. E.g. specifying this flag
    under Linux will process XML data, while under Windows(C) the Registry will be used. This is why
    A call to a load function with this flag with the corresponding XML file in the applications directory
    might succeed under Linux while it fails under Windows(C).
    """
sfRaw = lib_mvIMPACT_acquire.sfRaw
r"""
    Stores/loads the setting in raw mode.
    Notes: 
    Under Windows(C) this mode only works in connection with the **mvIMPACT::acquire::sfNative** flag.
    In that case an arbitrary hive from the registry can be used to create a tree of lists and
    properties. This only makes sense for very special applications and therefore is not needed to
    write applications, that load and store current settings.
    """
sfVolatile = lib_mvIMPACT_acquire.sfVolatile
r"""
    Stores lists volatile.
    under Windows(C) when the **mvIMPACT::acquire::sfNative** flag is set this will store the
    component list as a volatile key in the Registry. This means that the data will remain in the
    Registry until the system is shut down.
    """
sfProcessPropTranslationDict = lib_mvIMPACT_acquire.sfProcessPropTranslationDict
r"""
    If set properties translation dictionaries will be processed for this import/export operation.
    This option forces the function to process the translation dictionaries, which might
    be assigned to properties.
    """
sfCreateMissingEntries = lib_mvIMPACT_acquire.sfCreateMissingEntries
r"""
    If set ALL entries in the store data will be created.
    When loading a setting not only the current lists data will be updated, but also
    properties, lists or data, which is found in the storage location but not in the setting
    to update will be added to the setting as well.
    """
sfProcessReadOnlyComponents = lib_mvIMPACT_acquire.sfProcessReadOnlyComponents
r"""
    If set read-only components will be processed for this import/export operation.
    When importing, exporting or updating a component list components with the
    **mvIMPACT::acquire::cfWriteAccess** not set will be ignored.
    """
sfIgnorePropData = lib_mvIMPACT_acquire.sfIgnorePropData
r"""
    If set data for properties will no be updated.
    If this flag is set the values stored by the property will be ignored for this import/export operation.
    Notes: 
    This flag is ignored, if **mvIMPACT::acquire::sfNative** is specified.
    """
sfProcessDocString = lib_mvIMPACT_acquire.sfProcessDocString
r"""
    If set the documentation string will be processed.
    If this flag is set the documentation string will be processed for this import/export operation.
    Notes: 
    This flag is ignored, if **mvIMPACT::acquire::sfNative** is specified.
    """
sfProcessPropConstantsDict = lib_mvIMPACT_acquire.sfProcessPropConstantsDict
r"""
    If set the defined constants for properties will be processed.
    If this flag is set the defined constants for properties will be processed
    for this import/export operation.
    """
sfProcessInheritance = lib_mvIMPACT_acquire.sfProcessInheritance
r"""
     If set the lists inheritance relationship will be processed.
     If this flag is set the inheritance relationship between lists will be
     processed for the current import/export operation.

     Notes: 
     Limitations:
     - derived lists must appear in a list after the parent list. So if a list is derived
     from another list, it has to be registered with a higher index either in the same list
     as the parent or in a list with a higher index then the list holding the parent in a top
     level list.


     **Example for a legal structure:**

    .. code-block:: c++

         A
         |-B
         | |-parent
         | |-child
         |-C
         | |-child
         |-child


     **Example for illegal structures:**

    .. code-block:: c++

         A
         |-child
         |-parent
     or

    .. code-block:: c++

         A
         |-B
         | |-child
         |-parent
     - this feature is not available when **mvIMPACT::acquire::sfNative** is specified.
    """
sfIgnoreBasicData = lib_mvIMPACT_acquire.sfIgnoreBasicData
r"""
    Specifies if basic data shall be processed.
    For e.g. settings it's not necessary to import/export information about the value
    type for properties or the size of lists etc. as this information is available internally
    anyway. So interface functions dealing with settings should specify this flag in any case.
    """
sfIgnoreInvisible = lib_mvIMPACT_acquire.sfIgnoreInvisible
r"""
    Specifies if invisible components shall be processed.
    When invisible data doesn't need to be processed this flag can be specified. Invisible
    components do not influence the current systems behaviour.

    Notes: 
    This feature is currently only supported for output operations and is ignored for input
    operations.
    """
sfFile = lib_mvIMPACT_acquire.sfFile
r"""
    Stores/loads the setting in/from an XML file.
    If this flag is specified the data will be imported/exported from/to an XML file.
    """
sfProcessDisplayName = lib_mvIMPACT_acquire.sfProcessDisplayName
r"""
    If set the display name will be processed.
    If this flag is set the display name will be processed for this import/export operation.
    Notes: 
    This flag is ignored, if **mvIMPACT::acquire::sfNative** is specified.
    """
sfRAM = lib_mvIMPACT_acquire.sfRAM
r"""
     Stores/loads the setting in/from RAM file.
     If this flag is specified the data will be imported/exported from/to RAM. Data stored this way should be
     freed when no longer needed to avoid a waste of memory. However when shutting down mvIMPACT Acquire completely
     (e.g. when unloading the mvPropHandling library from memory all memory allocated by settings stored this way will be
     freed automatically).

     Notes: This flag must not be combined with **mvIMPACT::acquire::sfNative** or **mvIMPACT::acquire::sfFile**.
    Since: 2.19.0
    """
sfDontProcessDefault = lib_mvIMPACT_acquire.sfDontProcessDefault
r"""
    Specifies if the 'is-default' flag for components shall be ignored during import/export operations.
    If this flag is set the 'is-default' flag will not be processed during this import/export operation.
    Notes: 
    This flag is ignored, if **mvIMPACT::acquire::sfNative** is specified.
    """
sfProcessGenICamSequencerData = lib_mvIMPACT_acquire.sfProcessGenICamSequencerData
r"""
     Processes GenICam sequencer set related data during a storage operation.
    Notes: This flag will affect devices operated in GenICam interface layout only!
    Warning: Settings stored this way cannot be loaded on systems running mvIMPACT Acquire versions smaller than 2.28.0.
    Since: 2.28.0
    """
sfProcessGenICamUserSetData = lib_mvIMPACT_acquire.sfProcessGenICamUserSetData
r"""
     Processes GenICam user set related data during a storage operation.
    Notes: This flag will affect devices operated in GenICam interface layout only!
    Warning: Settings stored this way cannot be loaded on systems running mvIMPACT Acquire versions smaller than 2.28.0.
    Since: 2.28.0
    """
slNative = lib_mvIMPACT_acquire.slNative
r"""
    Stores/loads the setting in/from a platform dependent location
    Under Windows(C) the Registry will be used to as a platform dependent location, while under
    other platforms an XML file will be processed in the path specified as the settings name.

    Notes: 
    Please note, that using this mode will introduce platform dependency. E.g. specifying this mode
    under Linux will process XML data, while under Windows(C) the Registry will be used. This is why
    A call to a load function with this mode with the corresponding XML file in the applications directory
    might succeed under Linux while it fails under Windows(C).
    """
slNative_Raw = lib_mvIMPACT_acquire.slNative_Raw
r"""
    Stores/loads the setting in/from a platform dependent location
    Under Windows(C) the Registry will be used to as a platform dependent location, while under
    other platforms an XML file will be processed in the path specified as the settings name.

    Notes: 
    Please note, that using this mode will introduce platform dependency. E.g. specifying this mode
    under Linux will process XML data, while under Windows(C) the Registry will be used. This is why
    A call to a load function with this mode with the corresponding XML file in the applications directory
    might succeed under Linux while it fails under Windows(C).


    Under Windows(C) with this mode an arbitrary hive from the registry can be used to create a tree of lists and
    properties. This only makes sense for very special applications and therefore is not needed to
    write applications, that load and store current settings.
    """
slFile = lib_mvIMPACT_acquire.slFile
r"""
    Stores/loads the setting in/from an XML file
    Setting data will be imported/exported from/to an XML file.
    """
slRAM = lib_mvIMPACT_acquire.slRAM
r"""
    Stores/loads the setting in/from RAM file
    Setting data will be stored in the RAM of the current process. Data stored this way should be
    freed when no longer needed to avoid a waste of memory. However when shutting down mvIMPACT Acquire completely
    (e.g. when unloading the mvPropHandling library from memory all memory allocated by settings stored this way will be
    freed automatically).
    """
sGlobal = lib_mvIMPACT_acquire.sGlobal
r""" Save the setting as global as possible."""
sUser = lib_mvIMPACT_acquire.sUser
r""" Save the setting in a user specific location."""
class ChannelData(object):
    r"""
    A structure for image buffer channel specific data
    Channel specific data in an image is data, that in e.g. and RGB image
    might differ for the color components red, green and blue.

    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iChannelOffset = property(lib_mvIMPACT_acquire.ChannelData_iChannelOffset_get, lib_mvIMPACT_acquire.ChannelData_iChannelOffset_set, doc=r""" The offset (in bytes) to the next channel.""")
    iLinePitch = property(lib_mvIMPACT_acquire.ChannelData_iLinePitch_get, lib_mvIMPACT_acquire.ChannelData_iLinePitch_set, doc=r""" The offset (in bytes) to the next line of this channel.""")
    iPixelPitch = property(lib_mvIMPACT_acquire.ChannelData_iPixelPitch_get, lib_mvIMPACT_acquire.ChannelData_iPixelPitch_set, doc=r""" The offset (in bytes) to the next pixel of this channel.""")
    szChannelDesc = property(lib_mvIMPACT_acquire.ChannelData_szChannelDesc_get, lib_mvIMPACT_acquire.ChannelData_szChannelDesc_set, doc=r"""
    The string descriptor for this channel.
    For an RGB image the string values of three **mvIMPACT::acquire::ChannelData**
    structures this might e.g. be "R", "G" and "B".
    """)

    def __init__(self):
        lib_mvIMPACT_acquire.ChannelData_swiginit(self, lib_mvIMPACT_acquire.new_ChannelData())
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_ChannelData

# Register ChannelData in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.ChannelData_swigregister(ChannelData)
cvar = lib_mvIMPACT_acquire.cvar
INVALID_ID = cvar.INVALID_ID
ROOT_LIST = cvar.ROOT_LIST
END_OF_LIST = cvar.END_OF_LIST
smIgnoreLists = cvar.smIgnoreLists
smIgnoreMethods = cvar.smIgnoreMethods
smIgnoreProperties = cvar.smIgnoreProperties

class ImageBuffer(object):
    r"""
    Fully describes a captured image.
    This class serves as a describing structure for captured images.

    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iBytesPerPixel = property(lib_mvIMPACT_acquire.ImageBuffer_iBytesPerPixel_get, lib_mvIMPACT_acquire.ImageBuffer_iBytesPerPixel_set, doc=r""" The number of bytes per pixel.""")
    iHeight = property(lib_mvIMPACT_acquire.ImageBuffer_iHeight_get, lib_mvIMPACT_acquire.ImageBuffer_iHeight_set, doc=r""" The height of the image in pixel or lines.""")
    iWidth = property(lib_mvIMPACT_acquire.ImageBuffer_iWidth_get, lib_mvIMPACT_acquire.ImageBuffer_iWidth_set, doc=r""" The width of the image in pixel.""")
    pixelFormat = property(lib_mvIMPACT_acquire.ImageBuffer_pixelFormat_get, lib_mvIMPACT_acquire.ImageBuffer_pixelFormat_set, doc=r"""
    The pixel format of this image.
    This might be important, when the image data needs to be processed or stored in
    a file or maybe even if the image shall be displayed.
    """)
    iSize = property(lib_mvIMPACT_acquire.ImageBuffer_iSize_get, lib_mvIMPACT_acquire.ImageBuffer_iSize_set, doc=r"""
    The size (in bytes) of the whole image.
    This value in connection with **mvIMPACT::acquire::ImageBuffer::vpData**
    is sufficient to copy the complete image without having any additional information about it.
    """)
    vpData = property(lib_mvIMPACT_acquire.ImageBuffer_vpData_get, lib_mvIMPACT_acquire.ImageBuffer_vpData_set, doc=r"""
     The starting address of the image.
     This address in connection with **mvIMPACT::acquire::ImageBuffer::iSize**
     is sufficient to copy the complete image without having any additional information about it.

    If: (DOXYGEN_CPP_DOCUMENTATION { || DOXYGEN_C_DOCUMENTATION)
     **EXAMPLE:**


    .. code-block:: c++

         const ImageBuffer* pib = getImageBufferFromSomewhere();
         unsigned char* pTempBuf = new unsigned char[ib.iSize];
         memcpy( pTempBuf, pib.vpData, pIB.iSize );
    }Else if: DOXYGEN_NET_DOCUMENTATION {
    To copy this data from within a .NET environment the appropriate marshaling functions must be used!
    }Else if: DOXYGEN_JAVA_DOCUMENTATION {
    Warning: Do **NOT** use this pointer in Java! It references native, unmanaged memory and cannot be copied directly into
    a piece of managed Java memory. Use **mvIMPACT::acquire::ImageBufferDesc::copy()** instead (see code below)!

    .. code-block:: c++

         byte[] data = new byte[pRequest.getImageSize().read()];
         pRequest.getImageBufferDesc().copy( data );
    }Else if: DOXYGEN_PYTHON_DOCUMENTATION {
    There are various ways to access the data captured into a request object. One way would be by using the ``ctypes`` module:

    .. code-block:: c++

         ib = getImageBufferFromSomewhere()
         cbuf = (ctypes.c_char * ib.iSize).from_address(int(ib.vpData))
    }

     Notes: 
     It's not always necessary to copy the image data! Each **mvIMPACT::acquire::ImageBuffer** is an
     integral part of the **mvIMPACT::acquire::Request** object returned to the user by a call to
     the corresponding 'waitFor' function offered by the interface.
     The data in this **mvIMPACT::acquire::ImageBuffer** remains valid until the user either
     unlocks the request buffer or closes the **mvIMPACT::acquire::Device** again.


     By unlocking the **mvIMPACT::acquire::Request** the user informs the driver, that this **mvIMPACT::acquire::Request**
     and the **mvIMPACT::acquire::ImageBuffer** belonging to that **mvIMPACT::acquire::Request** is not longer needed by the
     user. The driver then queues this **mvIMPACT::acquire::Request** for capturing image data into it once
     again. However once a **mvIMPACT::acquire::Request** has been returned to the user, its **mvIMPACT::acquire::ImageBuffer**
     can't be overwritten by the driver! Therefore the user can work with, modify, store or
     copy the data safely until he unlocks the **mvIMPACT::acquire::Request** again.
    """)
    iChannelCount = property(lib_mvIMPACT_acquire.ImageBuffer_iChannelCount_get, lib_mvIMPACT_acquire.ImageBuffer_iChannelCount_set, doc=r"""
    The number of channels this image consists of.
    For an RGB image this value e.g. would be 3. This value defines how many
    **mvIMPACT::acquire::ChannelData** structures **mvIMPACT::acquire::ImageBuffer::pChannels**
    is pointing to once this structure has been allocated and filled with valid data.
    """)
    pChannels = property(lib_mvIMPACT_acquire.ImageBuffer_pChannels_get, lib_mvIMPACT_acquire.ImageBuffer_pChannels_set, doc=r""" A pointer to an array of channel specific image data.""")

    def __init__(self):
        lib_mvIMPACT_acquire.ImageBuffer_swiginit(self, lib_mvIMPACT_acquire.new_ImageBuffer())
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_ImageBuffer

# Register ImageBuffer in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.ImageBuffer_swigregister(ImageBuffer)

irpPixelFormat = lib_mvIMPACT_acquire.irpPixelFormat
r""" The pixel format of an image request buffer."""
irpResult = lib_mvIMPACT_acquire.irpResult
r""" The Result associated with an image request."""
irpState = lib_mvIMPACT_acquire.irpState
r""" The current state of an image request."""
irpCameraOutputUsed = lib_mvIMPACT_acquire.irpCameraOutputUsed
r""" The camera output used to transmit the image from the imaging device to the capture device."""
ibfNone = lib_mvIMPACT_acquire.ibfNone
r"""
    A dummy constant to state that none of the flags shall be specified.
    This flag can be used instead of writing code like this: TImpactBufferFlag(0) or
    static_cast<TImpactBufferFlag>(0).
    """
ibfUseRequestMemory = lib_mvIMPACT_acquire.ibfUseRequestMemory
r"""
    If set no new memory will be allocated for the creation of the **mvIMPACT** buffer.
    This way of creating the images is fast, but modifying the image data with an image processing
    function will always modify the image data associated with the underlying request object.

    Notes: 
    Once the underlying request object has been unlocked, working with the image is no longer
    save when this flag was set during creation of the **mvIMPACT** buffer, as the memory might
    be freed by the driver. If you want to keep the created image do **NOT** specify this flag
    during creation.


    Whenever a new image is acquired from a device the device might be using the memory already associated
    with another image thus you might end up with to IMPACT images that internally reference the
    same buffer. However a large DMA memory will (at least twice the size of one image) will allow
    to work with a double buffering scheme.
    """
ibfRecycleBufHandle = lib_mvIMPACT_acquire.ibfRecycleBufHandle
r"""
    If an existing **IPL_BUFHANDLE** is passed to a function it will try to copy data in this buffer instead of freeing it.
    This flag can be used to allow the continuous usage of the same mvIMPACT buffer. If this
    flag is NOT specified whenever a valid mvIMPACT buffer handle is passed to a function
    accepting this type of flags it might free the existing buffer and create a new one.

    If this flag is specified and the new buffer doesn't match the existing one in terms of
    the number of bands, size, etc. the function will fail and return an error code. Thus this
    flag can be used to optimize performance if the buffer layout will remain constant during
    application runtime.
    """
lqDeviceManager = lib_mvIMPACT_acquire.lqDeviceManager
r""" Specifies the mvDeviceManager library."""
lqPropHandling = lib_mvIMPACT_acquire.lqPropHandling
r""" Specifies the mvPropHandling library."""
class ImpactAcquireException(Exception):
    r""" A base class for exceptions generated by mvIMPACT Acquire."""

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

    def __init__(self, errorString, errorOrigin, errorCode):
        r"""
         Constructs a new **mvIMPACT::acquire::ImpactAcquireException** object.
        :type errorString: string
        :param errorString: [in] The string representation of the error.
        :type errorOrigin: string
        :param errorOrigin: [in] The origin of the error (function name and line)
        :type errorCode: int
        :param errorCode: [in] The numerical representation of the error.
        """
        lib_mvIMPACT_acquire.ImpactAcquireException_swiginit(self, lib_mvIMPACT_acquire.new_ImpactAcquireException(errorString, errorOrigin, errorCode))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_ImpactAcquireException

    def getErrorString(self):
        r""" Returns an error string containing information about the reason for the error."""
        return lib_mvIMPACT_acquire.ImpactAcquireException_getErrorString(self)

    def getErrorCode(self):
        r""" Returns a unique numerical representation for this error."""
        return lib_mvIMPACT_acquire.ImpactAcquireException_getErrorCode(self)

    @staticmethod
    def getErrorCodeAsString(*args):
        r"""
        *Overload 1:*
         Returns a string representation of the error associated with the exception.
        This function will return the name of the enum of the error code.

        **EXAMPLE**

        In case of error **-2102** this function would return **mvIMPACT::acquire::DMR_DRV_ALREADY_IN_USE**, which
        is the error codes corresponding enum name.

        |

        *Overload 2:*
         Returns a string representation of a error.
        This function will return the name of the enum of the error code.

        **EXAMPLE**

        In case of error **-2102** this function would return **mvIMPACT::acquire::DMR_DRV_ALREADY_IN_USE**, which
        is the error codes corresponding enum name.

        :type errorCode: int
        :param errorCode: [in] The error code to query a string representation for.
        """
        return lib_mvIMPACT_acquire.ImpactAcquireException_getErrorCodeAsString(*args)

    def getErrorOrigin(self):
        r"""
         Returns information about the origin of the error.
        The string returned by this function will contain the name of the function
        and the line number where the exception was raised.
        """
        return lib_mvIMPACT_acquire.ImpactAcquireException_getErrorOrigin(self)

    def getArgs(self):
        return lib_mvIMPACT_acquire.ImpactAcquireException_getArgs(self)

    def __str__(self):
        return lib_mvIMPACT_acquire.ImpactAcquireException___str__(self)

    """ \brief Returns an error string containing information about the reason for the error."""
    errorString       = property (lib_mvIMPACT_acquire.ImpactAcquireException_getErrorString, None, None, None)
    r"""
      \brief Returns information about the origin of the error.

      The string returned by this function will contain the name of the function
      and the line number where the exception was raised.
    """
    errorOrigin       = property (lib_mvIMPACT_acquire.ImpactAcquireException_getErrorOrigin, None, None, None)
    """ \brief Returns a unique numerical representation for this error."""
    errorCode         = property (lib_mvIMPACT_acquire.ImpactAcquireException_getErrorCode, None, None, None)
    r"""
      \brief Returns a string representation of the error associated with the exception.

      This function will return the name of the enum of the error code.

      \b EXAMPLE
      In case of error \b -2102 this function would return \b mvIMPACT::acquire::DMR_DRV_ALREADY_IN_USE, which
      is the error codes corresponding enum name.
    """
    errorCodeAsString = property (lib_mvIMPACT_acquire.ImpactAcquireException_getErrorCodeAsString, None, None, None)
    args              = property (lib_mvIMPACT_acquire.ImpactAcquireException_getArgs, None, None, None)

    def __getitem__(self, index):
        return self.args[index]


# Register ImpactAcquireException in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.ImpactAcquireException_swigregister(ImpactAcquireException)

def ImpactAcquireException_getErrorCodeAsString(*args):
    r"""
    *Overload 1:*
     Returns a string representation of the error associated with the exception.
    This function will return the name of the enum of the error code.

    **EXAMPLE**

    In case of error **-2102** this function would return **mvIMPACT::acquire::DMR_DRV_ALREADY_IN_USE**, which
    is the error codes corresponding enum name.

    |

    *Overload 2:*
     Returns a string representation of a error.
    This function will return the name of the enum of the error code.

    **EXAMPLE**

    In case of error **-2102** this function would return **mvIMPACT::acquire::DMR_DRV_ALREADY_IN_USE**, which
    is the error codes corresponding enum name.

    :type errorCode: int
    :param errorCode: [in] The error code to query a string representation for.
    """
    return lib_mvIMPACT_acquire.ImpactAcquireException_getErrorCodeAsString(*args)

class EDeviceManager(ImpactAcquireException):
    r""" A base class for device manager related exceptions."""

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

    def __init__(self, errorString, errorOrigin, errorCode):
        r"""
         Creates a new **mvIMPACT::acquire::EDeviceManager** object.
        :type errorString: string
        :param errorString: [in] The error string.
        :type errorOrigin: string
        :param errorOrigin: [in] The error origin.
        :type errorCode: int
        :param errorCode: [in] The error code.
        """
        lib_mvIMPACT_acquire.EDeviceManager_swiginit(self, lib_mvIMPACT_acquire.new_EDeviceManager(errorString, errorOrigin, errorCode))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_EDeviceManager

# Register EDeviceManager in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.EDeviceManager_swigregister(EDeviceManager)

class EPropertyHandling(ImpactAcquireException):
    r"""
     A base class for exceptions related to the property module.
    This exception object will only be raised if an unknown error occurred.
    To check for errors related to the property module a catch block for
    **mvIMPACT::acquire::EPropertyHandling** objects can be written to catch all property module related
    exceptions.
    """

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

    def __init__(self, errorString, errorOrigin, errorCode):
        r"""
         Creates a new **mvIMPACT::acquire::EPropertyHandling** object.
        :type errorString: string
        :param errorString: [in] The error string.
        :type errorOrigin: string
        :param errorOrigin: [in] The error origin.
        :type errorCode: int
        :param errorCode: [in] The error code.
        """
        lib_mvIMPACT_acquire.EPropertyHandling_swiginit(self, lib_mvIMPACT_acquire.new_EPropertyHandling(errorString, errorOrigin, errorCode))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_EPropertyHandling

# Register EPropertyHandling in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.EPropertyHandling_swigregister(EPropertyHandling)

class EComponent(EPropertyHandling):
    r"""
     A base class for **mvIMPACT::acquire::Component** object related exceptions from the property module.
    This exception object will never be raised in the code. It can't be constructed
    directly but to check for **mvIMPACT::acquire::Component** related errors a catch block for
    **mvIMPACT::acquire::EComponent** objects can be written to catch all **mvIMPACT::acquire::Component** related
    exceptions.
    """

    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

# Register EComponent in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.EComponent_swigregister(EComponent)

class ENotAList(EComponent):
    r""" An exception thrown in case of a **mvIMPACT::acquire::PROPHANDLING_NOT_A_LIST** error."""

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

    def __init__(self, msg, errorOrigin, boMsgIsNameOnly=True):
        lib_mvIMPACT_acquire.ENotAList_swiginit(self, lib_mvIMPACT_acquire.new_ENotAList(msg, errorOrigin, boMsgIsNameOnly))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_ENotAList

# Register ENotAList in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.ENotAList_swigregister(ENotAList)

class ENotAProperty(EComponent):
    r""" An exception thrown in case of a **mvIMPACT::acquire::PROPHANDLING_NOT_A_PROPERTY** error."""

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

    def __init__(self, msg, errorOrigin, boMsgIsNameOnly=True):
        lib_mvIMPACT_acquire.ENotAProperty_swiginit(self, lib_mvIMPACT_acquire.new_ENotAProperty(msg, errorOrigin, boMsgIsNameOnly))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_ENotAProperty

# Register ENotAProperty in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.ENotAProperty_swigregister(ENotAProperty)

class ENotAMethod(EComponent):
    r""" An exception thrown in case of a **mvIMPACT::acquire::PROPHANDLING_NOT_A_METHOD** error."""

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

    def __init__(self, msg, errorOrigin, boMsgIsNameOnly=True):
        lib_mvIMPACT_acquire.ENotAMethod_swiginit(self, lib_mvIMPACT_acquire.new_ENotAMethod(msg, errorOrigin, boMsgIsNameOnly))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_ENotAMethod

# Register ENotAMethod in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.ENotAMethod_swigregister(ENotAMethod)

class ENoReadRights(EComponent):
    r""" An exception thrown in case of a **mvIMPACT::acquire::PROPHANDLING_NO_READ_RIGHTS** error."""

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

    def __init__(self, msg, errorOrigin, boMsgIsNameOnly=True):
        lib_mvIMPACT_acquire.ENoReadRights_swiginit(self, lib_mvIMPACT_acquire.new_ENoReadRights(msg, errorOrigin, boMsgIsNameOnly))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_ENoReadRights

# Register ENoReadRights in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.ENoReadRights_swigregister(ENoReadRights)

class ENoWriteRights(EComponent):
    r""" An exception thrown in case of a **mvIMPACT::acquire::PROPHANDLING_NO_WRITE_RIGHTS** error."""

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

    def __init__(self, msg, errorOrigin, boMsgIsNameOnly=True):
        lib_mvIMPACT_acquire.ENoWriteRights_swiginit(self, lib_mvIMPACT_acquire.new_ENoWriteRights(msg, errorOrigin, boMsgIsNameOnly))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_ENoWriteRights

# Register ENoWriteRights in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.ENoWriteRights_swigregister(ENoWriteRights)

class ENoModifySizeRights(EComponent):
    r""" An exception thrown in case of a **mvIMPACT::acquire::PROPHANDLING_NO_MODIFY_SIZE_RIGHTS** error."""

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

    def __init__(self, msg, errorOrigin, boMsgIsNameOnly=True):
        lib_mvIMPACT_acquire.ENoModifySizeRights_swiginit(self, lib_mvIMPACT_acquire.new_ENoModifySizeRights(msg, errorOrigin, boMsgIsNameOnly))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_ENoModifySizeRights

# Register ENoModifySizeRights in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.ENoModifySizeRights_swigregister(ENoModifySizeRights)

class EIncompatibleComponents(EComponent):
    r""" An exception thrown in case of a **mvIMPACT::acquire::PROPHANDLING_INCOMPATIBLE_COMPONENTS** error."""

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

    def __init__(self, msg, errorOrigin, boMsgIsNameOnly=True):
        lib_mvIMPACT_acquire.EIncompatibleComponents_swiginit(self, lib_mvIMPACT_acquire.new_EIncompatibleComponents(msg, errorOrigin, boMsgIsNameOnly))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_EIncompatibleComponents

# Register EIncompatibleComponents in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.EIncompatibleComponents_swigregister(EIncompatibleComponents)

class EProperty(EComponent):
    r"""
     A base class for **mvIMPACT::acquire::Property** related exceptions from the property module.
    This exception object will never be raised in the code. It can't be constructed
    directly but to check for **mvIMPACT::acquire::Property** related errors a catch block for
    **mvIMPACT::acquire::EProperty** objects can be written to catch all **mvIMPACT::acquire::Property** related
    exceptions.
    """

    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

# Register EProperty in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.EProperty_swigregister(EProperty)

class EInvalidValue(EProperty):
    r""" An exception thrown in case of a **mvIMPACT::acquire::PROPHANDLING_INVALID_PROP_VALUE** error."""

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

    def __init__(self, msg, errorOrigin, boMsgIsNameOnly=True):
        lib_mvIMPACT_acquire.EInvalidValue_swiginit(self, lib_mvIMPACT_acquire.new_EInvalidValue(msg, errorOrigin, boMsgIsNameOnly))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_EInvalidValue

# Register EInvalidValue in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.EInvalidValue_swigregister(EInvalidValue)

class EValIDOutOfBounds(EProperty):
    r""" An exception thrown in case of a **mvIMPACT::acquire::PROPHANDLING_PROP_VAL_ID_OUT_OF_BOUNDS** error."""

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

    def __init__(self, msg, errorOrigin, boMsgIsNameOnly=True):
        lib_mvIMPACT_acquire.EValIDOutOfBounds_swiginit(self, lib_mvIMPACT_acquire.new_EValIDOutOfBounds(msg, errorOrigin, boMsgIsNameOnly))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_EValIDOutOfBounds

# Register EValIDOutOfBounds in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.EValIDOutOfBounds_swigregister(EValIDOutOfBounds)

class ETranslationTableCorrupted(EProperty):
    r""" An exception thrown in case of a **mvIMPACT::acquire::PROPHANDLING_PROP_TRANSLATION_TABLE_CORRUPTED** error."""

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

    def __init__(self, msg, errorOrigin, boMsgIsNameOnly=True):
        lib_mvIMPACT_acquire.ETranslationTableCorrupted_swiginit(self, lib_mvIMPACT_acquire.new_ETranslationTableCorrupted(msg, errorOrigin, boMsgIsNameOnly))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_ETranslationTableCorrupted

# Register ETranslationTableCorrupted in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.ETranslationTableCorrupted_swigregister(ETranslationTableCorrupted)

class ETranslationTableNotDefined(EProperty):
    r""" An exception thrown in case of a **mvIMPACT::acquire::PROPHANDLING_PROP_TRANSLATION_TABLE_NOT_DEFINED** error."""

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

    def __init__(self, msg, errorOrigin, boMsgIsNameOnly=True):
        lib_mvIMPACT_acquire.ETranslationTableNotDefined_swiginit(self, lib_mvIMPACT_acquire.new_ETranslationTableNotDefined(msg, errorOrigin, boMsgIsNameOnly))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_ETranslationTableNotDefined

# Register ETranslationTableNotDefined in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.ETranslationTableNotDefined_swigregister(ETranslationTableNotDefined)

class EInvalidValueType(EProperty):
    r""" An exception thrown in case of a **mvIMPACT::acquire::PROPHANDLING_INVALID_PROP_VALUE_TYPE** error."""

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

    def __init__(self, msg, errorOrigin, boMsgIsNameOnly=True):
        lib_mvIMPACT_acquire.EInvalidValueType_swiginit(self, lib_mvIMPACT_acquire.new_EInvalidValueType(msg, errorOrigin, boMsgIsNameOnly))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_EInvalidValueType

# Register EInvalidValueType in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.EInvalidValueType_swigregister(EInvalidValueType)

class EValTooLarge(EProperty):
    r""" An exception thrown in case of a **mvIMPACT::acquire::PROPHANDLING_PROP_VAL_TOO_LARGE** error."""

    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):
        lib_mvIMPACT_acquire.EValTooLarge_swiginit(self, lib_mvIMPACT_acquire.new_EValTooLarge(*args))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_EValTooLarge

# Register EValTooLarge in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.EValTooLarge_swigregister(EValTooLarge)

class EValTooSmall(EProperty):
    r""" An exception thrown in case of a **mvIMPACT::acquire::PROPHANDLING_PROP_VAL_TOO_SMALL** error."""

    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):
        lib_mvIMPACT_acquire.EValTooSmall_swiginit(self, lib_mvIMPACT_acquire.new_EValTooSmall(*args))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_EValTooSmall

# Register EValTooSmall in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.EValTooSmall_swigregister(EValTooSmall)

class EValidationFailed(EProperty):
    r""" An exception thrown in case of a **mvIMPACT::acquire::PROPHANDLING_PROP_VALIDATION_FAILED** error."""

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

    def __init__(self, msg, errorOrigin, boMsgIsNameOnly=True):
        lib_mvIMPACT_acquire.EValidationFailed_swiginit(self, lib_mvIMPACT_acquire.new_EValidationFailed(msg, errorOrigin, boMsgIsNameOnly))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_EValidationFailed

# Register EValidationFailed in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.EValidationFailed_swigregister(EValidationFailed)

class EPropertyList(EComponent):
    r"""
     A base class for component list related exceptions from the property module.
    This exception object will never be raised in the code. It can't be constructed
    directly but to check for component list related errors a catch block for
    **mvIMPACT::acquire::EPropertyList** objects can be written to catch all exceptions related
    to lists and list operations.
    """

    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

# Register EPropertyList in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.EPropertyList_swigregister(EPropertyList)

class EComponentNotFound(EPropertyList):
    r""" An exception thrown in case of a **mvIMPACT::acquire::PROPHANDLING_COMPONENT_NOT_FOUND** error."""

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

    def __init__(self, msg, errorOrigin):
        lib_mvIMPACT_acquire.EComponentNotFound_swiginit(self, lib_mvIMPACT_acquire.new_EComponentNotFound(msg, errorOrigin))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_EComponentNotFound

# Register EComponentNotFound in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.EComponentNotFound_swigregister(EComponentNotFound)

class EListEntryOccupied(EPropertyList):
    r""" An exception thrown in case of a **mvIMPACT::acquire::PROPHANDLING_LIST_ENTRY_OCCUPIED** error."""

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

    def __init__(self, errorOrigin):
        lib_mvIMPACT_acquire.EListEntryOccupied_swiginit(self, lib_mvIMPACT_acquire.new_EListEntryOccupied(errorOrigin))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_EListEntryOccupied

# Register EListEntryOccupied in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.EListEntryOccupied_swigregister(EListEntryOccupied)

class EComponentIDInvalid(EPropertyList):
    r""" An exception thrown in case of a **mvIMPACT::acquire::PROPHANDLING_COMPONENT_ID_INVALID** error."""

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

    def __init__(self, errorOrigin):
        lib_mvIMPACT_acquire.EComponentIDInvalid_swiginit(self, lib_mvIMPACT_acquire.new_EComponentIDInvalid(errorOrigin))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_EComponentIDInvalid

# Register EComponentIDInvalid in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.EComponentIDInvalid_swigregister(EComponentIDInvalid)

class EInvalidListID(EPropertyList):
    r""" An exception thrown in case of a **mvIMPACT::acquire::PROPHANDLING_LIST_ID_INVALID** error."""

    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):
        lib_mvIMPACT_acquire.EInvalidListID_swiginit(self, lib_mvIMPACT_acquire.new_EInvalidListID(*args))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_EInvalidListID

# Register EInvalidListID in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.EInvalidListID_swigregister(EInvalidListID)

class ECantAccessData(EPropertyList):
    r""" An exception thrown in case of a **mvIMPACT::acquire::PROPHANDLING_LIST_CANT_ACCESS_DATA** error."""

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

    def __init__(self, msg, errorOrigin, boMsgIsPathOnly=True):
        lib_mvIMPACT_acquire.ECantAccessData_swiginit(self, lib_mvIMPACT_acquire.new_ECantAccessData(msg, errorOrigin, boMsgIsPathOnly))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_ECantAccessData

# Register ECantAccessData in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.ECantAccessData_swigregister(ECantAccessData)

class ECantRegisterComponent(EPropertyList):
    r""" An exception thrown in case of a **mvIMPACT::acquire::PROPHANDLING_CANT_REGISTER_COMPONENT** error."""

    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):
        lib_mvIMPACT_acquire.ECantRegisterComponent_swiginit(self, lib_mvIMPACT_acquire.new_ECantRegisterComponent(*args))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_ECantRegisterComponent

# Register ECantRegisterComponent in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.ECantRegisterComponent_swigregister(ECantRegisterComponent)

class EMethod(EComponent):
    r"""
     A base class for **mvIMPACT::acquire::Method** object related exceptions from the property module.
    This exception object will never be raised in the code. It can't be constructed
    directly but to check for **mvIMPACT::acquire::Method** object related errors a catch block for
    **mvIMPACT::acquire::EMethod** objects can be written to catch only **Method** related exceptions.
    """

    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

# Register EMethod in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.EMethod_swigregister(EMethod)

class EMethodPtrInvalid(EMethod):
    r""" An exception thrown in case of a **mvIMPACT::acquire::PROPHANDLING_METHOD_PTR_INVALID** error."""

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

    def __init__(self, msg, errorOrigin, boMsgIsNameOnly=True):
        lib_mvIMPACT_acquire.EMethodPtrInvalid_swiginit(self, lib_mvIMPACT_acquire.new_EMethodPtrInvalid(msg, errorOrigin, boMsgIsNameOnly))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_EMethodPtrInvalid

# Register EMethodPtrInvalid in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.EMethodPtrInvalid_swigregister(EMethodPtrInvalid)

class EInvalidParameterList(EMethod):
    r""" An exception thrown in case of a **mvIMPACT::acquire::PROPHANDLING_METHOD_INVALID_PARAM_LIST** error."""

    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):
        lib_mvIMPACT_acquire.EInvalidParameterList_swiginit(self, lib_mvIMPACT_acquire.new_EInvalidParameterList(*args))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_EInvalidParameterList

# Register EInvalidParameterList in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.EInvalidParameterList_swigregister(EInvalidParameterList)

class EUnsupportedParameter(EPropertyHandling):
    r""" An exception thrown in case of a **mvIMPACT::acquire::PROPHANDLING_UNSUPPORTED_PARAMETER** error."""

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

    def __init__(self, errorOrigin):
        lib_mvIMPACT_acquire.EUnsupportedParameter_swiginit(self, lib_mvIMPACT_acquire.new_EUnsupportedParameter(errorOrigin))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_EUnsupportedParameter

# Register EUnsupportedParameter in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.EUnsupportedParameter_swigregister(EUnsupportedParameter)

class ESizeMismatch(EPropertyHandling):
    r""" An exception thrown in case of a **mvIMPACT::acquire::PROPHANDLING_SIZE_MISMATCH** error."""

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

    def __init__(self, errorString, errorOrigin):
        lib_mvIMPACT_acquire.ESizeMismatch_swiginit(self, lib_mvIMPACT_acquire.new_ESizeMismatch(errorString, errorOrigin))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_ESizeMismatch

# Register ESizeMismatch in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.ESizeMismatch_swigregister(ESizeMismatch)

class EImplementationMissing(EPropertyHandling):
    r""" An exception thrown in case of a **mvIMPACT::acquire::PROPHANDLING_IMPLEMENTATION_MISSING** error."""

    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):
        lib_mvIMPACT_acquire.EImplementationMissing_swiginit(self, lib_mvIMPACT_acquire.new_EImplementationMissing(*args))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_EImplementationMissing

# Register EImplementationMissing in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.EImplementationMissing_swigregister(EImplementationMissing)

class EInvalidInputParameter(EPropertyHandling):
    r""" An exception thrown in case of a **mvIMPACT::acquire::PROPHANDLING_INVALID_INPUT_PARAMETER** error."""

    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):
        lib_mvIMPACT_acquire.EInvalidInputParameter_swiginit(self, lib_mvIMPACT_acquire.new_EInvalidInputParameter(*args))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_EInvalidInputParameter

# Register EInvalidInputParameter in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.EInvalidInputParameter_swigregister(EInvalidInputParameter)

class EInputBufferTooSmall(EPropertyHandling):
    r""" An exception thrown in case of a **mvIMPACT::acquire::PROPHANDLING_INPUT_BUFFER_TOO_SMALL** error."""

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

    def __init__(self, errorOrigin):
        lib_mvIMPACT_acquire.EInputBufferTooSmall_swiginit(self, lib_mvIMPACT_acquire.new_EInputBufferTooSmall(errorOrigin))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_EInputBufferTooSmall

# Register EInputBufferTooSmall in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.EInputBufferTooSmall_swigregister(EInputBufferTooSmall)

class EWrongParamCount(EPropertyHandling):
    r""" An exception thrown in case of a **mvIMPACT::acquire::PROPHANDLING_WRONG_PARAM_COUNT** error."""

    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):
        lib_mvIMPACT_acquire.EWrongParamCount_swiginit(self, lib_mvIMPACT_acquire.new_EWrongParamCount(*args))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_EWrongParamCount

# Register EWrongParamCount in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.EWrongParamCount_swigregister(EWrongParamCount)

class EUnsupportedOperation(EPropertyHandling):
    r""" An exception thrown in case of a **mvIMPACT::acquire::PROPHANDLING_UNSUPPORTED_OPERATION** error."""

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

    def __init__(self, errorOrigin):
        lib_mvIMPACT_acquire.EUnsupportedOperation_swiginit(self, lib_mvIMPACT_acquire.new_EUnsupportedOperation(errorOrigin))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_EUnsupportedOperation

# Register EUnsupportedOperation in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.EUnsupportedOperation_swigregister(EUnsupportedOperation)

class ECantSerializeData(EPropertyHandling):
    r""" An exception thrown in case of a **mvIMPACT::acquire::PROPHANDLING_CANT_SERIALIZE_DATA** error."""

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

    def __init__(self, msg, errorOrigin, boMsgIsNameOnly=True):
        lib_mvIMPACT_acquire.ECantSerializeData_swiginit(self, lib_mvIMPACT_acquire.new_ECantSerializeData(msg, errorOrigin, boMsgIsNameOnly))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_ECantSerializeData

# Register ECantSerializeData in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.ECantSerializeData_swigregister(ECantSerializeData)

class EInvalidFileContent(EPropertyHandling):
    r""" An exception thrown in case of a **mvIMPACT::acquire::PROPHANDLING_INVALID_FILE_CONTENT** error."""

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

    def __init__(self, msg, errorOrigin, boMsgIsNameOnly=True):
        lib_mvIMPACT_acquire.EInvalidFileContent_swiginit(self, lib_mvIMPACT_acquire.new_EInvalidFileContent(msg, errorOrigin, boMsgIsNameOnly))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_EInvalidFileContent

# Register EInvalidFileContent in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.EInvalidFileContent_swigregister(EInvalidFileContent)

class ECantAllocateNewList(EPropertyHandling):
    r""" An exception thrown in case of a **mvIMPACT::acquire::PROPHANDLING_CANT_ALLOCATE_LIST** error."""

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

    def __init__(self, errorOrigin):
        lib_mvIMPACT_acquire.ECantAllocateNewList_swiginit(self, lib_mvIMPACT_acquire.new_ECantAllocateNewList(errorOrigin))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_ECantAllocateNewList

# Register ECantAllocateNewList in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.ECantAllocateNewList_swigregister(ECantAllocateNewList)

class ExceptionFactory(object):
    r"""
     A factory class to raise mvIMPACT acquire related exceptions.
    This class contains a collection of static member functions that are used inside the
    interface to raise the appropriate exception in case of an error
    """

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

    @staticmethod
    def getLastErrorString():
        r"""
         Returns the last error string that did occur inside the framework within the current thread.
        :rtype: string
        :return: The last error string that did occur inside the framework within the current thread.
        """
        return lib_mvIMPACT_acquire.ExceptionFactory_getLastErrorString()

    @staticmethod
    def raiseException(*args):
        r"""
        *Overload 1:*
         Raises an exception from an error code, its origin in terms of the function name and the line number the error did occur and an optional component handle.
        :type pFunctionName: string
        :param pFunctionName: [in] The name of the function this exception was raised from.
        :type lineNumber: int
        :param lineNumber: [in] The line number in the source this exception was raised from.
        :type errorCode: int
        :param errorCode: [in] The error code.
        :type objectHandle: int
        :param objectHandle: [in] A handle to an object.

        |

        *Overload 2:*
         Raises an exception from an error code, its origin in terms of the function name and the line number the error did occur and an exception string.
        :type pFunctionName: string
        :param pFunctionName: [in] The name of the function this exception was raised from.
        :type lineNumber: int
        :param lineNumber: [in] The line number in the source this exception was raised from.
        :type errorCode: int
        :param errorCode: [in] The error code.
        :type msg: string
        :param msg: [in] The actual exception text.
        """
        return lib_mvIMPACT_acquire.ExceptionFactory_raiseException(*args)

    def __init__(self):
        lib_mvIMPACT_acquire.ExceptionFactory_swiginit(self, lib_mvIMPACT_acquire.new_ExceptionFactory())
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_ExceptionFactory

# Register ExceptionFactory in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.ExceptionFactory_swigregister(ExceptionFactory)

def ExceptionFactory_getLastErrorString():
    r"""
     Returns the last error string that did occur inside the framework within the current thread.
    :rtype: string
    :return: The last error string that did occur inside the framework within the current thread.
    """
    return lib_mvIMPACT_acquire.ExceptionFactory_getLastErrorString()

def ExceptionFactory_raiseException(*args):
    r"""
    *Overload 1:*
     Raises an exception from an error code, its origin in terms of the function name and the line number the error did occur and an optional component handle.
    :type pFunctionName: string
    :param pFunctionName: [in] The name of the function this exception was raised from.
    :type lineNumber: int
    :param lineNumber: [in] The line number in the source this exception was raised from.
    :type errorCode: int
    :param errorCode: [in] The error code.
    :type objectHandle: int
    :param objectHandle: [in] A handle to an object.

    |

    *Overload 2:*
     Raises an exception from an error code, its origin in terms of the function name and the line number the error did occur and an exception string.
    :type pFunctionName: string
    :param pFunctionName: [in] The name of the function this exception was raised from.
    :type lineNumber: int
    :param lineNumber: [in] The line number in the source this exception was raised from.
    :type errorCode: int
    :param errorCode: [in] The error code.
    :type msg: string
    :param msg: [in] The actual exception text.
    """
    return lib_mvIMPACT_acquire.ExceptionFactory_raiseException(*args)

class ComponentAccess(object):
    r"""
     A base class to implement access to internal driver objects.
    Instances of this class can't be constructed directly.
    """

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

    def __init__(self, src):
        r"""
         Constructs a new **mvIMPACT::acquire::ComponentAccess** from an existing one.
        :type src: :py:class:`ComponentAccess`
        :param src: [in] A constant reference to the **mvIMPACT::acquire::ComponentAccess** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.ComponentAccess_swiginit(self, lib_mvIMPACT_acquire.new_ComponentAccess(src))

    def changedCounter(self):
        r"""
         Returns the current changed counter for the component referenced by this object.
         This changed counter is incremented internally each time the component is modified.
         To check if this component has been modified since the last time, this check has been
         performed, keep track of the last return value of this function and compare
         it with the new value. This can be helpful e.g. to keep a GUI up to date. The value returned
         by this function will always be larger than or equal to the value returned by
         **mvIMPACT::acquire::ComponentAccess::changedCounterAttr** (except in case of a
         wrap around) when called at the same time for the same object as it's always incremented
         when the component has been modified in
         any way while the latter one will only be incremented if the attributes (e.g. the
         flags) but **NOT** if e.g. the value(s) of a property has been modified.

        If: DOXYGEN_CPP_DOCUMENTATION {

        .. code-block:: c++

             //-----------------------------------------------------------------------------
             struct ComponentRef
             //-----------------------------------------------------------------------------
             {
               mvIMPACT::acquire::Component c_;
               unsigned int lastChangedCount_;
               ComponentRef( mvIMPACT::acquire::Component c ) : c_( c ), lastChangedCount_( 0 ) {}
             };

             //-----------------------------------------------------------------------------
             void fn( ComponentRef cr )
             //-----------------------------------------------------------------------------
             {
               if( cr.c_.isValid() )
               {
                 const unsigned int currentChangedCount = cr.c_.changedCounter();
                 if( currentChangedCount != cr.lastChangedCount_ )
                 {
                   // something has happened since the last check!
                   doWhatNeedsToBeDone();
                   // and remember the current changed counter
                   cr.lastChangedCount_ = currentChangedCount;
                 }
               }
             }
        }Else if: DOXYGEN_JAVA_DOCUMENTATION {

        .. code-block:: c++

             import mvIMPACT.acquire.*;

             //-----------------------------------------------------------------------------
             public class ComponentRef
             //-----------------------------------------------------------------------------
             {
               private Component c_;
               private long lastChangedCount_;
               public ComponentRef( Component c ) : c_( c ), lastChangedCount_( 0 ) {}
               public Component getComponent()
               {
                 return c_;
               }
               public long getLastChangedCounter()
               {
                 return lastChangedCount_;
               }
               public void setLastChangedCounter( long changedCounter )
               {
                 lastChangedCount_ = lastChangedCount;
               }
             }

             // ...more code, class definition etc.

             //-----------------------------------------------------------------------------
             public static void fn( ComponentRef cr )
             //-----------------------------------------------------------------------------
             {
               if( cr.c_.isValid() )
               {
                 final long currentChangedCount = cr.getComponent().changedCounter();
                 if( currentChangedCount != cr.getLastChangedCounter() )
                 {
                   // something has happened since the last check!
                   doWhatNeedsToBeDone();
                   // and remember the current changed counter
                   cr.setLastChangedCounter( currentChangedCount );
                 }
               }
             }
        }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

        .. code-block:: c++

             class ComponentRef
               def __init__(self, c):
                 self.c_ = c
                 self.lastChangedCount_ = 0

             def fn(cr):
               if cr.c_.isValid:
                 currentChangedCount = cr.c_.changedCounter()
                 if currentChangedCount != cr.lastChangedCount_:
                   # something has happened since the last check!
                   doWhatNeedsToBeDone()
                   # and remember the current changed counter
                   cr.lastChangedCount_ = currentChangedCount
        }

        :rtype: int
        :return: The current changed counter of this object.
        """
        return lib_mvIMPACT_acquire.ComponentAccess_changedCounter(self)

    def changedCounterAttr(self):
        r"""
         Returns the current attribute changed counter for the component referenced by this object.
        This changed counter is incremented internally each time the components attributes have been modified.
        To check if this components attributes have been modified since the last time, this check has been
        performed, keep track of the last return value of this function and compare
        it with the new value. This can be helpful e.g. to keep a GUI up to date.

        Notes: 
        Attributes changes are e.g. a modification to a property's translation dictionary,
        but **NOT** a property's value. Because of this the value returned by this function
        will always be less or equal than the value returned by the function
        **mvIMPACT::acquire::ComponentAccess::changedCounter** (except in case of a
        wrap around) when called at the same time for the same object.
        See also: **mvIMPACT::acquire::ComponentAccess::changedCounter**
        :rtype: int
        :return: The current attributes changed counter of this object.
        """
        return lib_mvIMPACT_acquire.ComponentAccess_changedCounterAttr(self)

    def hObj(self):
        r"""
        Returns a unique identifier for the component referenced by this object.
        :rtype: int
        :return: A unique identifier for the component referenced by this object.
        """
        return lib_mvIMPACT_acquire.ComponentAccess_hObj(self)

    def name(self):
        r"""
        Returns the name of the component referenced by this object.
        :rtype: string
        :return: The name of the component referenced by this object.
        """
        return lib_mvIMPACT_acquire.ComponentAccess_name(self)

    def displayName(self):
        r"""
         Returns the display name of the component referenced by this object.

        Since: 1.11.20

         :rtype: string
         :return: The display name of the component referenced by this object. This might be an empty string if no display name has been specified.
        """
        return lib_mvIMPACT_acquire.ComponentAccess_displayName(self)

# Register ComponentAccess in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.ComponentAccess_swigregister(ComponentAccess)

class Component(ComponentAccess):
    r"""
     A base class to implement access to internal driver components.
     Objects of this class can be constructed directly even if nothing is known about the type
     of driver object we are referring to. This class acts as a base class to provide
     access to internal properties, methods and component lists offered by the driver.

     This object can be used to navigate through component lists of
     unknown content.

     Consider the following structure:

    .. code-block:: c++

         LA
         |-LB
         |-LC
         |  |-PE
         |  |-PF
         |  |-PG
         |-PD

     Where the prefix 'L' means this is a list, 'P' that this is a property.
     Assuming that we have and iterator referencing list 'C', calling **mvIMPACT::acquire::Component::firstChild**
     e.g. would return a new iterator referencing object 'PE', while calling **mvIMPACT::acquire::Component::nextSibling**
     would have returned a reference to 'PD' and **mvIMPACT::acquire::Component::parent** would have
     returned a reference to object 'LA'.

     **"EXAMPLE 1"**:

    A new **mvIMPACT::acquire::Component** is created with the *ID* of list 'C':

     If: DOXYGEN_CPP_DOCUMENTATION {

    .. code-block:: c++

         Component it(ID_of_list_C);
         it = it.firstChild();    // now we are referencing 'PE'
         it = it.lastSibling();   // moves to 'PG'
         it = it.firstSibling();  // moves back to PE'
         it = it.nextSibling();   // moves to 'PF'
         it = it.firstSibling();  // moves back to PE'
         it = it.parent();        // we are referencing 'LC' again
    }Else if: DOXYGEN_JAVA_DOCUMENTATION {

    .. code-block:: c++

         Component it = new Component(ID_of_list_C);
         it = it.firstChild();    // now we are referencing 'PE'
         it = it.lastSibling();   // moves to 'PG'
         it = it.firstSibling();  // moves back to PE'
         it = it.nextSibling();   // moves to 'PF'
         it = it.firstSibling();  // moves back to PE'
         it = it.parent();        // we are referencing 'LC' again
    }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

    .. code-block:: c++

         it = acquire.Component(ID_of_list_C);
         it = it.firstChild()    # now we are referencing 'PE'
         it = it.lastSibling()   # moves to 'PG'
         it = it.firstSibling()  # moves back to PE'
         it = it.nextSibling()   # moves to 'PF'
         it = it.firstSibling()  # moves back to PE'
         it = it.parent()        # we are referencing 'LC' again
    }

     **"EXAMPLE 2"**:

     Iterate over a complete list including sub lists. This will result in a list
     of all lists and properties that reside in the list the iterator currently
     is moving through to be written to the standard output. The name of the component
     and every parent component will be printed into the standard output:

    If: DOXYGEN_CPP_DOCUMENTATION {

    .. code-block:: c++

        //-----------------------------------------------------------------------------
         void ParseList( Component iter, const string path = "" )
         //-----------------------------------------------------------------------------
         {
           while( iter.isValid() )
           {
             if( iter.isVisible() )
             {
               if( iter.isList() )
               {
                 // do some list specific stuff
                 cout < "List     " < path < iter.name() < "/" < endl;
                 // move down into the list and append its name to the path
                 ParseList( iter.firstChild(), path + iter.name() + "/" );
               }
               else if( iter.isProp() )
               {
                 // do property specific stuff e.g. read the value
                 Property prop( iter );
                 cout < "Property " < path < prop.name() < "(value(s): ";
                 unsigned int valCount = prop.valCount();
                 for( unsigned int i=0; ivalCount; i++ )
                 {
                   cout < prop.readS();
                   if( i  valCount - 1 )
                   {
                     cout < ", ";
                   }
                 }
                 cout < ")" < endl;
               }
             }
             ++iter;
           }
         }

         //-----------------------------------------------------------------------------
         int main( int argc, char* argv[] )
         //-----------------------------------------------------------------------------
         {
           ComponentList baselist;
           // ....
           Component it( baselist );
           ParseList( it );
           // ....
           return 0;
        }
    }Else if: DOXYGEN_JAVA_DOCUMENTATION {

    .. code-block:: c++

        //-----------------------------------------------------------------------------
        public class FeatureListParser
        //-----------------------------------------------------------------------------
        {
          static
          {
            try
            {
              System.loadLibrary( "mvIMPACT_Acquire.java" );
            }
            catch( UnsatisfiedLinkError e )
            {
              System.err.println( "Native code library failed to load. Make sure the 'mvIMPACT_Acquire.java' library can be found in the systems search path.\n" + e );
              System.exit( 1 );
            }
         }

         //-----------------------------------------------------------------------------
         public static void ParseList( Component iter, final String path )
         //-----------------------------------------------------------------------------
         {
           while( iter.isValid() )
           {
             if( iter.isVisible() )
             {
               if( iter.isList() )
               {
                 // do some list specific stuff
                 System.out.println( String.format( "List     %s%s/", path, iter.name() ) );
                 // move down into the list and append its name to the path
                 ParseList( iter.firstChild(), path + iter.name() + "/" );
               }
               else if( iter.isProp() )
               {
                 // do property specific stuff e.g. read the value
                 Property prop = new Property(iter.hObj());
                 StringBuilder values = new StringBuilder();

                 final long valCount = prop.valCount();
                 for( long i=0; ivalCount; i++ )
                 {
                   values.append( prop.readS( ( int )i ) );
                   if( i  valCount - 1 )
                   {
                     values.append( ", " );
                   }
                 }
                 System.out.println( String.format( "Property %s%s(value(s): %s)", path, prop.name(), values.toString() ) );
               }
             }
             iter = iter.nextSibling();
           }
         }

         //-----------------------------------------------------------------------------
         public static void main( String[] args )
         //-----------------------------------------------------------------------------
         {
           // ....
           Component baselist( gethObjOfListToParse() );
           ParseList( it );
           // ....
         }
        }
    }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

    .. code-block:: c++

        def ParseList(iter, path = ""):
         while iter.isValid:
           if iter.isVisible:
             if iter.isList:
               # do some list specific stuff
               print("List     {0}{1}/".format(path, iter.name()))
               # move down into the list and append its name to the path
               ParseList(iter.firstChild(), path + iter.name() + "/")
             elif iter.isProp:
               # do property specific stuff e.g. read the value
               prop = acquire.Property(iter.hObj())
               values = []
               valCount = prop.valCount()
               for i in range(valCount):
                 values.append(prop.readS(i))
               print("Property {0}{1}(value(s): {2})".format(path, prop.name(), string.join(values, ",")))
           iter = iter.nextSibling()

        it = acquire.Component(gethObjOfListToParse())
        ParseList(it)
    }
    """

    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"""
        *Overload 1:*
         Constructs a new access object to a driver object.
        :type hObj: int
        :param hObj: [in] A valid handle to a component object

        |

        *Overload 2:*
         Constructs a new unbound access object.

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::Component** from an existing one.
        :type src: :py:class:`Component`
        :param src: [in] A constant reference to the **mvIMPACT::acquire::Component** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.Component_swiginit(self, lib_mvIMPACT_acquire.new_Component(*args))

    def firstSibling(self):
        r"""
        Moves to the first sibling(the first feature in the current list of features).
        :rtype: :py:class:`Component`
        :return: A new **mvIMPACT::acquire::Component** object
        """
        return lib_mvIMPACT_acquire.Component_firstSibling(self)

    def lastSibling(self):
        r"""
         Moves to the last sibling(the last feature in the current list of features).

        Since: 1.10.64

         :rtype: :py:class:`Component`
         :return: A new **mvIMPACT::acquire::Component** object
        """
        return lib_mvIMPACT_acquire.Component_lastSibling(self)

    def nextSibling(self):
        r"""
        Moves to the next sibling(the next feature in the current list of features).
        :rtype: :py:class:`Component`
        :return: A new **mvIMPACT::acquire::Component** object
        """
        return lib_mvIMPACT_acquire.Component_nextSibling(self)

    def firstChild(self):
        r"""
         Moves to the first child of this component(moves down one level).
        Calling this function will only succeed, if the current **mvIMPACT::acquire::Component**
        references a list.

        :rtype: :py:class:`Component`
        :return: A new **mvIMPACT::acquire::Component** object
        """
        return lib_mvIMPACT_acquire.Component_firstChild(self)

    def parent(self):
        r"""
        Moves to the parent of this component(moves up one level).
        :rtype: :py:class:`Component`
        :return: A new **mvIMPACT::acquire::Component** object
        """
        return lib_mvIMPACT_acquire.Component_parent(self)

    def docString(self):
        r"""
        Returns a string containing general information about the component referenced by this object.
        :rtype: string
        :return: A string containing general information about the component referenced by this object.
        """
        return lib_mvIMPACT_acquire.Component_docString(self)

    def flags(self):
        r"""
        Returns the flags associated with this component.
        :rtype: int
        :return: The flags associated with this component.
        """
        return lib_mvIMPACT_acquire.Component_flags(self)

    def flagsAsString(self, *args):
        r"""
         Returns the flags associated with this component as a string.
         :rtype: string
         :return: The flags associated with this component as a string.

        :type separator: string
        :param separator: [in] A user definable string to separate the individual flags. The default value is ' | ' resulting in the string to look e.g. like this: **'cfWriteAccess | cfReadAccess'**
        """
        return lib_mvIMPACT_acquire.Component_flagsAsString(self, *args)

    def getIsDefault(self):
        r"""
        Checks if this component is currently referencing the default for this component.
        This function will return true only for derived components that have not been modified.
        :rtype: boolean
        :return: 
            - true if the component is currently set to its default value
            - false otherwise.
        """
        return lib_mvIMPACT_acquire.Component_getIsDefault(self)

    def getIsList(self):
        r"""
        Checks if this component is of type **mvIMPACT::acquire::ComponentList**.
        :rtype: boolean
        :return: 
            - true if the component references a list
            - false otherwise
        """
        return lib_mvIMPACT_acquire.Component_getIsList(self)

    def getIsMeth(self):
        r"""
        Checks if this component is of type **mvIMPACT::acquire::Method**.
        :rtype: boolean
        :return: 
            - true if the component references a method
            - false otherwise
        """
        return lib_mvIMPACT_acquire.Component_getIsMeth(self)

    def getIsProp(self):
        r"""
        Checks if this component is of type **mvIMPACT::acquire::Property** or a derived type.
        :rtype: boolean
        :return: 
            - true if the component references a property
            - false otherwise
        """
        return lib_mvIMPACT_acquire.Component_getIsProp(self)

    def getIsValid(self):
        r"""
        Checks if the internal component referenced by this object is still valid.
        This function can be used to verify whether a referenced component
        is still valid or not. When e.g. referencing a driver property after
        **mvIMPACT::acquire::Device::close** has been called this function would return false.
        Calling any other function that tries to access the referenced component
        in that case would raise an exception.
        :rtype: boolean
        :return: 
            - true if this object currently references a valid component
            - false otherwise.
        """
        return lib_mvIMPACT_acquire.Component_getIsValid(self)

    def getIsVisible(self):
        r"""
         Checks if the component is currently shadowed due to a settings made elsewhere or not.
        Settings applied to certain components might affect the behaviour of others. For example
        an activated automatic gain control might shadow the value written to the
        gain property by the user as the gain is calculated internally. In order to
        check if modifying the actual component will affect the behaviour of the
        system this function may be used. When it returns *true*, the **mvIMPACT::acquire::Component**
        will have an impact on the system, if *false* is returned, the feature might be
        modified, but this will currently NOT influence the acquisition process or the overall behaviour
        of the device or driver.

        This is what is called visibility. The user still might modify or read the
        current **mvIMPACT::acquire::Component** when it's not visible however the actual data will
        be used only if the **Component** is visible (**mvIMPACT::acquire::cfInvisible**
        must **NOT** be set).

        The visibility of a **mvIMPACT::acquire::Component** object will change only if other
        **mvIMPACT::acquire::Component** objects are modified and **NEVER** when a program
        runs but does not change any **mvIMPACT::acquire::Component**.
        """
        return lib_mvIMPACT_acquire.Component_getIsVisible(self)

    def getIsWriteable(self):
        r"""
        Checks if the caller has write/modify access to the component.
        :rtype: boolean
        :return: 
            - true if the caller is allowed to call write/modify operation for this component.
            - false otherwise.
        """
        return lib_mvIMPACT_acquire.Component_getIsWriteable(self)

    def restoreDefault(self):
        r"""
         Restores the default for the referenced component.
        Calling this function will restore the default value for the
        component referenced by this object.

        If this function is called for an object of type **mvIMPACT::acquire::ComponentList**
        every component in that list is restored to the default value.

        Notes: The caller must have the right to modify the component. Otherwise
        an exception will be thrown.

        :rtype: :py:class:`Component`
        :return: A const reference to the component.
        """
        return lib_mvIMPACT_acquire.Component_restoreDefault(self)

    def type(self):
        r"""
        Returns the type of the referenced component.
        :rtype: int
        :return: The type of the referenced component.
        """
        return lib_mvIMPACT_acquire.Component_type(self)

    @staticmethod
    def getType(hObj):
        r"""
         Returns the type of the component referenced by *hObj*.
         :rtype: int
         :return: The type of the component referenced by *hObj*.

        :type hObj: int
        :param hObj: [in] The component the type shall be retrieved for
        """
        return lib_mvIMPACT_acquire.Component_getType(hObj)

    def typeAsString(self):
        r"""
        Returns the type of the referenced component as a string.
        :rtype: string
        :return: The type of the referenced component as a string.
        """
        return lib_mvIMPACT_acquire.Component_typeAsString(self)

    def visibility(self):
        r"""
         Returns the recommended visibility for this component.
        The visibility can be used e.g. to develop a GUI that displays a
        crucial subset of features only.

        Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TComponentVisibility**.
        :rtype: int
        :return: The recommended visibility for this component.
        """
        return lib_mvIMPACT_acquire.Component_visibility(self)

    def visibilityAsString(self):
        r"""
        Returns the recommended visibility of the referenced component as a string.
        :rtype: string
        :return: The recommended visibility of the referenced component as a string.
        """
        return lib_mvIMPACT_acquire.Component_visibilityAsString(self)

    @staticmethod
    def getVisibilityAsString(visibility):
        r"""
         Returns the recommended visibility converted to a string.
         :rtype: string
         :return: The recommended visibility converted to a string.

        :type visibility: int
        :param visibility: [in] The visibility to query the string representation for
        """
        return lib_mvIMPACT_acquire.Component_getVisibilityAsString(visibility)

    def representation(self):
        r"""
         Returns the recommended representation for this component.
        The representation can be used e.g. to develop a GUI that creates convenient controls
         for certain features.

        Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TComponentRepresentation**.

         Since: 2.14.0

        :rtype: int
        :return: The recommended representation for this component.
        """
        return lib_mvIMPACT_acquire.Component_representation(self)

    def representationAsString(self):
        r"""
        Returns the recommended representation of the referenced component as a string.

        Since: 2.14.0

        :rtype: string
        :return: The recommended representation of the referenced component as a string.
        """
        return lib_mvIMPACT_acquire.Component_representationAsString(self)

    @staticmethod
    def getRepresentationAsString(representation):
        r"""
         Returns the recommended representation converted to a string.

         Since: 2.14.0

         :rtype: string
         :return: The recommended representation converted to a string.

        :type representation: int
        :param representation: [in] The representation to query the string representation for
        """
        return lib_mvIMPACT_acquire.Component_getRepresentationAsString(representation)

    def selectedFeatureCount(self):
        r"""
         Returns the number of features selected by the current one.
        See also: 
        **mvIMPACT::acquire::Component::selectedFeatures**,

        **mvIMPACT::acquire::Component::selectedFeature**

        Since: 1.11.20

        :rtype: int
        :return: The number of features selected by the current one.
        """
        return lib_mvIMPACT_acquire.Component_selectedFeatureCount(self)

    def selectingFeatureCount(self):
        r"""
         Returns the number of features selecting the current one.
        See also: 
        **mvIMPACT::acquire::Component::selectingFeatures**,

        **mvIMPACT::acquire::Component::selectingFeature**

        Since: 1.11.20

        :rtype: int
        :return: The number of features selecting the current one.
        """
        return lib_mvIMPACT_acquire.Component_selectingFeatureCount(self)

    def selectedFeatures(self, v):
        r"""
         Retrieves the list of components that are selected by the current one.
        This function retrieves the list of components that are selected by
        the current one. This information is mainly useful for GUI applications that want to arrange
        features in a way that dependencies between features can easily been spotted.

        When a component 'selects' other components, this indicates that selected components may change whenever
        the selecting component changes. An example for a selector might be a property defining the index within
        a LUT while the value of a particular LUT entry could be a selected feature. Assuming 2 properties
        *LUTIndex* and *LUTValue* then changing *LUTIndex* will invalidate and possibly change *LUTValue*.

        See also: 
        **mvIMPACT::acquire::Component::selectedFeatureCount**,

        **mvIMPACT::acquire::Component::selectedFeature**

        Since: 1.11.20

        :rtype: int
        :return: The number of features selected by the current one.

        :type v: std::vector< mvIMPACT::acquire::Component,std::allocator< mvIMPACT::acquire::Component > >
        :param v: [out] An array that will retrieve the list of components that are selected by the current one.
        """
        return lib_mvIMPACT_acquire.Component_selectedFeatures(self, v)

    def selectingFeatures(self, v):
        r"""
         Retrieves the list of components that are selecting the current one.
        This function retrieves the list of components that are selecting
        the current one. This information is mainly useful for GUI applications that want to arrange
        features in a way that dependencies between features can easily been spotted.

        When a component 'selects' other components, this indicates that selected components may change whenever
        the selecting component changes. An example for a selector might be a property defining the index within
        a LUT while the value of a particular LUT entry could be a selected feature. Assuming 2 properties
        *LUTIndex* and *LUTValue* then changing *LUTIndex* will invalidate and possibly change *LUTValue*.

        See also: 
        **mvIMPACT::acquire::Component::selectingFeatureCount**,

        **mvIMPACT::acquire::Component::selectingFeature**

        Since: 1.11.20

        :rtype: int
        :return: The number of features selecting the current one.

        :type v: std::vector< mvIMPACT::acquire::Component,std::allocator< mvIMPACT::acquire::Component > >
        :param v: [out] An array that will retrieve the list of components that are selecting the current one.
        """
        return lib_mvIMPACT_acquire.Component_selectingFeatures(self, v)

    def selectedFeature(self, index):
        r"""
         Retrieves a component that is selected by the current one.
        This function retrieves a component that is selected by the current one.
        This information is mainly useful for GUI applications that want to arrange
        features in a way that dependencies between features can easily been spotted.

        When a component 'selects' other components, this indicates that selected components may change whenever
        the selecting component changes. An example for a selector might be a property defining the index within
        a LUT while the value of a particular LUT entry could be a selected feature. Assuming 2 properties
        *LUTIndex* and *LUTValue* then changing *LUTIndex* will invalidate and possibly change *LUTValue*.

        If: DOXYGEN_CPP_DOCUMENTATION {
        C++ offers the more efficient function **mvIMPACT::acquire::Component::selectedFeatures** to obtain this
        information.
        }

        To find out how many **mvIMPACT::acquire::Component** objects are selected by the current one call
        **mvIMPACT::acquire::Component::selectedFeatureCount**. This value minus 1 will also be the
        max. value for *index*.
        See also: 
        **mvIMPACT::acquire::Component::selectedFeatureCount**,

        **mvIMPACT::acquire::Component::selectedFeatures**

        Since: 1.11.20

        :rtype: :py:class:`Component`
        :return: A **mvIMPACT::acquire::Component** that is selected by the current one.

        :type index: int
        :param index: [in] The index for the component to query.
        """
        return lib_mvIMPACT_acquire.Component_selectedFeature(self, index)

    def selectingFeature(self, index):
        r"""
         Retrieves a component that is selecting the current one.
        This function retrieves a component that is selecting the current one.
        This information is mainly useful for GUI applications that want to arrange
        features in a way that dependencies between features can easily been spotted.

        When a component 'selects' other components, this indicates that selected components may change whenever
        the selecting component changes. An example for a selector might be a property defining the index within
        a LUT while the value of a particular LUT entry could be a selected feature. Assuming 2 properties
        *LUTIndex* and *LUTValue* then changing *LUTIndex* will invalidate and possibly change *LUTValue*.

        If: DOXYGEN_CPP_DOCUMENTATION {
        C++ offers the more efficient function **mvIMPACT::acquire::Component::selectingFeatures** to obtain this
        information.
        }

        To find out how many **mvIMPACT::acquire::Component** objects are selecting the current one call
        **mvIMPACT::acquire::Component::selectingFeatureCount**. This value minus 1 will also be the
        max. value for *index*.
        See also: 
        **mvIMPACT::acquire::Component::selectingFeatureCount**,

        **mvIMPACT::acquire::Component::selectingFeatures**

        Since: 1.11.20

        :rtype: :py:class:`Component`
        :return: A **mvIMPACT::acquire::Component** that is selecting the current one.

        :type index: int
        :param index: [in] The index for the component to query.
        """
        return lib_mvIMPACT_acquire.Component_selectingFeature(self, index)

    r""" \brief A bool property \b (read-only) which checks if this component is currently referencing the default for this component. See mvIMPACT.acquire.Component.getIsDefault() """
    isDefault = property (getIsDefault, None, None, None)
    r""" \brief A bool property \b (read-only) which checks if this component is of type mvIMPACT.acquire.ComponentList. See mvIMPACT.acquire.Component.getIsList() """
    isList = property (getIsList, None, None, None)
    r""" \brief A bool property \b (read-only) which checks if this component is of type mvIMPACT.acquire.Method. See mvIMPACT.acquire.Component.getIsMeth() """
    isMeth = property (getIsMeth, None, None, None)
    r""" \brief A bool property \b (read-only) which checks if this component is of type mvIMPACT.acquire.Property or a derived type. See mvIMPACT.acquire.Component.getIsProp() """
    isProp = property (getIsProp, None, None, None)
    r""" \brief A bool property \b (read-only) which checks if the internal component referenced by this object is still valid. See mvIMPACT.acquire.Component.getIsValid() """
    isValid = property (getIsValid, None, None, None)
    r""" \brief A bool property \b (read-only) which checks if the component is currently shadowed due to settings made elsewhere or not. See mvIMPACT.acquire.Component.getIsVisible() """
    isVisible = property (getIsVisible, None, None, None)
    r""" \brief A bool property \b (read-only) which checks if the caller has write/modify access to the component. See mvIMPACT.acquire.Component.getIsWriteable() """
    isWriteable = property (getIsWriteable, None, None, None)

    __swig_destroy__ = lib_mvIMPACT_acquire.delete_Component

# Register Component in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.Component_swigregister(Component)

def Component_getType(hObj):
    r"""
     Returns the type of the component referenced by *hObj*.
     :rtype: int
     :return: The type of the component referenced by *hObj*.

    :type hObj: int
    :param hObj: [in] The component the type shall be retrieved for
    """
    return lib_mvIMPACT_acquire.Component_getType(hObj)

def Component_getVisibilityAsString(visibility):
    r"""
     Returns the recommended visibility converted to a string.
     :rtype: string
     :return: The recommended visibility converted to a string.

    :type visibility: int
    :param visibility: [in] The visibility to query the string representation for
    """
    return lib_mvIMPACT_acquire.Component_getVisibilityAsString(visibility)

def Component_getRepresentationAsString(representation):
    r"""
     Returns the recommended representation converted to a string.

     Since: 2.14.0

     :rtype: string
     :return: The recommended representation converted to a string.

    :type representation: int
    :param representation: [in] The representation to query the string representation for
    """
    return lib_mvIMPACT_acquire.Component_getRepresentationAsString(representation)

class ComponentCallback(object):
    r"""
     A simple helper class to wrap the creation of a callback object.
    Applications need to derive from this class and must re-implement the function
    **mvIMPACT::acquire::ComponentCallback::execute**.

    Since: 1.12.18
    """

    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"""
        *Overload 1:*
         Creates a new **mvIMPACT::acquire::ComponentCallback** instance.
        :type pUserData: void
        :param pUserData: [in] A pointer to user specific data bound to this callback. This data will be passed back to the user whenever the callback function gets executed and can be used to attach custom data to the callback function.

        |

        *Overload 2:*
         Copy constructor.
        Creates a new object from an existing device object. Keep in mind that this new object
        will provide access to the very same objects. This constructor
        is only provided for internal reference counting to guarantee correct operation of the
        objects of this class under all platforms and languages.
        """
        if self.__class__ == ComponentCallback:
            _self = None
        else:
            _self = self
        lib_mvIMPACT_acquire.ComponentCallback_swiginit(self, lib_mvIMPACT_acquire.new_ComponentCallback(_self, *args))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_ComponentCallback

    def isComponentRegistered(self, c):
        r"""
         Checks if a component is currently registered for this callback or not.
        :rtype: boolean
        :return: 
             - true if the component currently is registered for this callback
             - false otherwise

        :type c: :py:class:`Component`
        :param c: [in] The component that shall be tested against this callback
        """
        return lib_mvIMPACT_acquire.ComponentCallback_isComponentRegistered(self, c)

    def registerComponent(self, c):
        r"""
         Registers a component for this callback.
        :rtype: boolean
        :return: 
             - true if the component could be registered successfully for this callback.
             - false otherwise

        :type c: :py:class:`Component`
        :param c: [in] The component to register for this callback
        """
        return lib_mvIMPACT_acquire.ComponentCallback_registerComponent(self, c)

    def unregisterComponent(self, c):
        r"""
         Unregisters a component for this callback.
        :rtype: boolean
        :return: 
             - true if the component could be unregistered successfully for this callback.
             - false otherwise

        :type c: :py:class:`Component`
        :param c: [in] The component to unregister from this callback
        """
        return lib_mvIMPACT_acquire.ComponentCallback_unregisterComponent(self, c)

    def execute(self, c, pUserData):
        r"""
         The callback function.
        Re-implement this function in a derived class in order to get the desired behaviour.

        Notes: 
        Please note that this function might be executed from **ANY** thread context, which is
        most likely not the same as the one used by the application thus appropriate mechanisms to ensure
        correct execution must be implemented by an application(e.g. GUI applications might send an
        event to the main thread instead of directly accessing GUI elements).


        Doing lengthy processing within the callback context is **NOT** recommended as whichever thread firing this
        callback will stop until the callback returns!

        :type c: :py:class:`Component`
        :param c: [in] The component that did cause the callback to be executed
        :type pUserData: void
        :param pUserData: [in] A pointer to user specific data that was bound to this callback instance upon construction
        """
        return lib_mvIMPACT_acquire.ComponentCallback_execute(self, c, pUserData)
    def __disown__(self):
        self.this.disown()
        lib_mvIMPACT_acquire.disown_ComponentCallback(self)
        return weakref.proxy(self)

# Register ComponentCallback in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.ComponentCallback_swigregister(ComponentCallback)

class ComponentLocatorBase(ComponentAccess):
    r"""
     A base class to locate components within the driver.
    Every driver will offer a set of properties, methods and component lists.
    **mvIMPACT::acquire::Property** objects contain data such as the current gain in dB, the state of a
    digital input, etc.. **mvIMPACT::acquire::Method** objects can be executed like a normal function and
    **mvIMPACT::acquire::ComponentList** objects are used to group certain
    objects together to form a logical unit.

    When it's necessary to locate one or more of these objects without knowing
    exactly where to look for them this locator class can be used to look for the component.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound locator.

        |

        *Overload 2:*
         Constructs a new bound to the specified base list locator.
        :type baselist: int
        :param baselist: [in] A unique identifier to the base list from where to start to search for the search base.

        |

        *Overload 3:*
         Constructs a new locator and searches the search base list.
        :type baselist: int
        :param baselist: [in] A unique identifier to the base list from where to start to search for the search base.
        :type pathToSearchBase: string
        :param pathToSearchBase: [in] The name or path ('/' separated) to the search base.

        |

        *Overload 4:*
         Constructs a new **mvIMPACT::acquire::ComponentLocatorBase** from an existing one.
        :type src: :py:class:`ComponentLocatorBase`
        :param src: [in] A constant reference to the **mvIMPACT::acquire::ComponentLocatorBase** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.ComponentLocatorBase_swiginit(self, lib_mvIMPACT_acquire.new_ComponentLocatorBase(*args))

    def bindComponent(self, *args):
        r"""
         Binds an access object to an internal driver object.
        :rtype: boolean
        :return: 
            - true if successful
            - false otherwise. In case false is returned by this function the component could not
            be bound, which means subsequent calls using *access* will fail or throw an exception.

        :type access: :py:class:`Component`
        :param access: [in,out] The access object to bind to the driver object.
        :type name: string
        :param name: [in] The path and/or name of the object to be located.
        :type searchMode: int
        :param searchMode: [in] Specifies how and what to search for. Valid flags(these flags can be combined using the '|' operator) for this parameter are: - smIgnoreLists - smIgnoreMethods - smIgnoreProperties
        :type maxSearchDepth: int
        :param maxSearchDepth: [in] The maximum depth (in lists) where to search for the component. By e.g. setting this value to 2, the current list and all its sub lists will be searched for the object, but no sublists of sub lists. -1 will search in ALL sub lists.
        """
        return lib_mvIMPACT_acquire.ComponentLocatorBase_bindComponent(self, *args)

    def bindSearchBase(self, *args):
        r"""
         Assign a new search base to the locator.
         This new search base will be searched starting from the base list specified.
         :rtype: int
         :return: The unique identifier of the new search base.

        :type baselist: int
        :param baselist: [in] A unique identifier for the base list used to start searching the search base.
        :type pathToSearchBase: string
        :param pathToSearchBase: [in] The name or path to the search base.
        """
        return lib_mvIMPACT_acquire.ComponentLocatorBase_bindSearchBase(self, *args)

    def findComponent(self, *args):
        r"""
         Tries to locate a certain component in a hierarchy of components.
         :rtype: int
         :return: A unique identifier to the component if found or **mvIMPACT::acquire::INVALID_ID** if the component couldn't
             be found.

        :type name: string
        :param name: [in] The path and/or name of the object to be located.
        :type searchMode: int
        :param searchMode: [in] Specifies how and what to search for. Valid flags(these flags can be combined using the '|' operator) for this parameter are: - smIgnoreLists - smIgnoreMethods - smIgnoreProperties
        :type maxSearchDepth: int
        :param maxSearchDepth: [in] The maximum depth (in lists) where to search for the component. By e.g. setting this value to 2, the current list and all its sub lists will be searched for the object, but no sublists of sub lists. -1 will search in ALL sub lists.
        """
        return lib_mvIMPACT_acquire.ComponentLocatorBase_findComponent(self, *args)

    def searchbase_id(self):
        r"""
        Returns the unique identifier of the base list from where to start searching for a component.
        :rtype: int
        :return: The unique identifier of the base list from where searching for a component will start currently.
        """
        return lib_mvIMPACT_acquire.ComponentLocatorBase_searchbase_id(self)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_ComponentLocatorBase

# Register ComponentLocatorBase in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.ComponentLocatorBase_swigregister(ComponentLocatorBase)

class ComponentLocator(ComponentLocatorBase):
    r"""
     A class to locate components within the driver.
    Every driver will offer a set of properties, methods and component lists.
    **mvIMPACT::acquire::Property** objects contain data such as the current gain in dB, the state of a
    digital input, etc.. **mvIMPACT::acquire::Method** objects can be executed like a normal function and
    **mvIMPACT::acquire::ComponentList** objects are used to group certain
    objects together to form a logical unit.

    When it's necessary to locate one or more of these objects without knowing
    exactly where to look for them this locator class can be used to look for the component.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound locator.

        |

        *Overload 2:*
         Constructs a new bound to the specified base list locator.
        :type baselist: int
        :param baselist: [in] A unique identifier to the base list from where to start to search for the search base.

        |

        *Overload 3:*
         Constructs a new locator and searches the search base list.
        :type baselist: int
        :param baselist: [in] A unique identifier to the base list from where to start to search for the search base.
        :type pathToSearchBase: string
        :param pathToSearchBase: [in] The name or path ('/' separated) to the search base.

        |

        *Overload 4:*
         Constructs a new **mvIMPACT::acquire::ComponentLocator** from an existing one.
        :type src: :py:class:`ComponentLocator`
        :param src: [in] A constant reference to the **mvIMPACT::acquire::ComponentLocator** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.ComponentLocator_swiginit(self, lib_mvIMPACT_acquire.new_ComponentLocator(*args))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_ComponentLocator

# Register ComponentLocator in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.ComponentLocator_swigregister(ComponentLocator)

class ComponentList(Component):
    r"""
    A class to provide access to component lists.
    This class provides access to internal component lists of the driver.
    """

    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"""
        *Overload 1:*
         Constructs a new **mvIMPACT::acquire::ComponentList** object.
        :type hList: int
        :param hList: [in] A valid handle to a list object

        |

        *Overload 2:*
         Constructs a new unbound **mvIMPACT::acquire::ComponentList** object.

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::ComponentList** from an existing one.
        :type src: :py:class:`ComponentList`
        :param src: [in] A constant reference to the **mvIMPACT::acquire::ComponentList** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.ComponentList_swiginit(self, lib_mvIMPACT_acquire.new_ComponentList(*args))

    def size(self):
        r"""
        Returns The number of valid component entries in the referenced list.
        :rtype: int
        :return: The number of valid component entries in the referenced list.
        """
        return lib_mvIMPACT_acquire.ComponentList_size(self)

    def contentDescriptor(self):
        r"""
        Returns a string containing information about what's in this list.
        This string might not be defined by every list but in any case this function
        will return a valid string. However this string might be empty.
        """
        return lib_mvIMPACT_acquire.ComponentList_contentDescriptor(self)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_ComponentList

# Register ComponentList in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.ComponentList_swigregister(ComponentList)

class Method(Component):
    r"""
    A class to call arbitrary driver functions.
    Normally all functions needed by the user and offered by the driver will be
    provided as a normal function somewhere within this interface. In rare cases
    however it might be necessary to call a function, which hasn't been implemented
    in this interface. In that case this class will serve as a backdoor.
    """

    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"""
        *Overload 1:*
         Constructs a new **mvIMPACT::acquire::Method** object.
        :type hMeth: int
        :param hMeth: [in] A valid handle to method object

        |

        *Overload 2:*
         Constructs a new unbound **mvIMPACT::acquire::Method** object.

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::Method** from an existing one.
        :type src: :py:class:`Method`
        :param src: [in] A constant reference to the **mvIMPACT::acquire::Method** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.Method_swiginit(self, lib_mvIMPACT_acquire.new_Method(*args))

    def call(self, *args):
        r"""
        *Overload 1:*
         Calls an underlying driver function.
        This function can be used to call any driver function which is registered
        for the device it is called for. To call a function successfully the parameters
        passed to the function must match the parameters expected by the function.

        The parameters are passed as a list of strings.

        To find out what kind of parameters are expected by the function use
        the function **mvIMPACT::acquire::Method::paramList()**.

        floating point values can be passed either with a '.' or a ',' acting as the
        decimal point.

        'empty' strings can be passed as a single underline('_').rs.

        If: DOXYGEN_CPP_DOCUMENTATION {

        .. code-block:: c++

            // call a function expecting a string and a float
            vectorstring params;
            params.push_back( "stringParam" );
            params.push_back( "3.14" );
            meth.call( params );
        }Else if: DOXYGEN_JAVA_DOCUMENTATION {

        .. code-block:: c++

            // call a function expecting a string and a float
            ArrayListString list = new ArrayListString();
            list.add( "stringParam" );
            list.add( "3.14" );
            StringVector params = new StringVector( list );
            meth.call( params );
        }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

        .. code-block:: c++

            # call a function expecting a string and a float
            params = []
            params.append("stringParam")
            params.append("3.14")
            meth.call(params)
        }
        :rtype: int
        :return: An integer value. For a typical function that is part of the driver SDK this integer value will be
             - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
             - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.

        :type params: std::vector< std::string,std::allocator< std::string > >
        :param params: [in] The parameters to be passed to the function as a list of strings

        |

        *Overload 2:*
         Calls an underlying driver function.
        This function can be used to call any driver function which is registered
        for the device it is called for. To call a function successfully the parameters
        passed to the function must match the parameters expected by the function.

        All parameters are passed as a single string, which is parsed with respect to the
        given delimiter characters internally.

        To find out what kind of parameters are expected by the function use
        the function **mvIMPACT::acquire::Method::paramList()**.

        floating point values can be passed either with a '.' or a ',' acting as the
        decimal point.

        'empty' strings can be passed as a single underline('_').

        Warning: 
        The characters '.', ',' and '_' can't be used as delimiters.

        If: (DOXYGEN_CPP_DOCUMENTATION { || DOXYGEN_JAVA_DOCUMENTATION)

        .. code-block:: c++

            // call a function expecting a string and a float
            // value parameters separated by spaces
            meth.call( "stringParam 3,14" );
            // call of a function expecting 2 integers an a string
            // where an empty string shall be passed
            // parameters are separated by '%'
            meth.call( "1000%666%_", "%" );
        }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

        .. code-block:: c++

            # call a function expecting a string and a float
            # value parameters separated by spaces
            meth.call("stringParam 3,14")
            # call of a function expecting 2 integers an a string
            # where an empty string shall be passed
            # parameters are separated by '%'
            meth.call("1000%666%_", "%")
        }
        :rtype: int
        :return: An integer value. For a typical function that is part of the driver SDK this integer value will be
             - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
             - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.

        :type params: string
        :param params: [in] The parameters to be passed to the function as a single string
        :type delimiters: string
        :param delimiters: [in] A string containing valid delimiter characters for the parameter string

        |

        *Overload 3:*
         Calls an underlying driver function.
        This function can be used to call any driver function which is registered
        for the device it is called for. To call a function successfully the parameters
        passed to the function must match the parameters expected by the function.

        All parameters are passed as a single string, which is parsed with respect to the
        given delimiter characters internally.

        To find out what kind of parameters are expected by the function use
        the function **mvIMPACT::acquire::Method::paramList()**.

        floating point values can be passed either with a '.' or a ',' acting as the
        decimal point.

        'empty' strings can be passed as a single underline('_').

        Warning: 
        The characters '.', ',' and '_' can't be used as delimiters.

        If: (DOXYGEN_CPP_DOCUMENTATION { || DOXYGEN_JAVA_DOCUMENTATION)

        .. code-block:: c++

            // call a function expecting a string and a float
            // value parameters separated by spaces
            meth.call( "stringParam 3,14" );
            // call of a function expecting 2 integers an a string
            // where an empty string shall be passed
            // parameters are separated by '%'
            meth.call( "1000%666%_", "%" );
        }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

        .. code-block:: c++

            # call a function expecting a string and a float
            # value parameters separated by spaces
            meth.call("stringParam 3,14")
            # call of a function expecting 2 integers an a string
            # where an empty string shall be passed
            # parameters are separated by '%'
            meth.call("1000%666%_", "%")
        }
        :rtype: int
        :return: An integer value. For a typical function that is part of the driver SDK this integer value will be
             - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
             - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.

        :type params: string
        :param params: [in] The parameters to be passed to the function as a single string
        :param delimiters: [in] A string containing valid delimiter characters for the parameter string

        |

        *Overload 4:*
         Calls an underlying driver function expecting no parameters.
        This function can be used to call any driver function which is registered
        for the device it is called for that does **NOT** expect any parameters

        To find out what kind of parameters are expected by the function use
        the function **mvIMPACT::acquire::Method::paramList()**.

        :rtype: int
        :return: An integer value. For a typical function that is part of the driver SDK this integer value will be
             - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
             - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.
        """
        return lib_mvIMPACT_acquire.Method_call(self, *args)

    def paramList(self):
        r"""
        Returns the parameter list of the methods as a string.
        This function returns a string containing one character for each parameter this **mvIMPACT::acquire::Method**
        object expects and one for the return type of the function call.

        The first character is the return type of the function all others are parameters. void functions
        don't specify parameters.

        The characters have the following meaning:
        - i specifies a 32-bit integer value
        - I specifies a 64-bit integer value
        - s specifies a pointer to a C-string
        - f specifies a double precision float value
        - p specifies a pointer value
        - v specifies a void return value

        **EXAMPLES**:

        - 'v': This is a function returning nothing (void). It expects no parameters.
        - 'viis': This is a function returning nothing (void). It expects 2 integer values
        and one pointer to a C-string.
        - 'if': This function returns an integer value and expects a float value.
        :rtype: string
        :return: The parameter list of the method as a string.
        """
        return lib_mvIMPACT_acquire.Method_paramList(self)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_Method

# Register Method in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.Method_swigregister(Method)

plMaxValue = lib_mvIMPACT_acquire.plMaxValue
r"""
    Set/Get the maximum value for this **mvIMPACT::acquire::Property**.
    Pass this as the index to set or get the maximum number of values this property
    can store with a call to the **mvIMPACT::acquire::Property** object's corresponding
    **read** or **write** method.
    """
plMinValue = lib_mvIMPACT_acquire.plMinValue
r"""
    Set/Get the minimum value for this **mvIMPACT::acquire::Property**.
    Pass this as the index to set or get the maximum number of values this property
    can store with a call to the **mvIMPACT::acquire::Property** object's corresponding
    **read** or **write** method.
    """
plStepWidth = lib_mvIMPACT_acquire.plStepWidth
r"""
    Set/Get the step width value for this **mvIMPACT::acquire::Property**.
    Pass this as the index to set or get the maximum number of values this property
    can store with a call to the **mvIMPACT::acquire::Property** object's corresponding
    **read** or **write** method.
    """
class Property(Component):
    r"""
     A base class for properties.
     A property can be used to represent certain values like e.g. the input channel
     of a device. Depending on the way the property has been created it is either
     possible to read and write data to it or ( when the **mvIMPACT::acquire::cfWriteAccess** flag is **NOT** set )
     just to read the data. In rare cases it might also be possible that the user is
     is not allowed to read the data of a property. To find out what you are allowed
     to do with a property or any other component the function **mvIMPACT::acquire::Component::flags()**
     can be called.

     A property can contain either a single value or an array of values of the same
     type (e.g. 4 integer values could be used to represent a property call 'Rectangle'.
     It can even (if the **mvIMPACT::acquire::cfFixedSize** flag is not set) contain
     a different number of values all the time its data is queried. E.g. for a property
     'searchresults' each time some function is called which writes its results to this
     property the property could contain a different number of integer values afterwards.

     Every properties value can be read and written either as string or by it actual value type.
     So you can either assign the value of an integer property by using the standard 'write' function
     that accepts the value to be the type of the property or the function **mvIMPACT::acquire::Property::writeS**
     can be used to set the property via a string containing the new value.
    If: DOXYGEN_CPP_DOCUMENTATION {

    .. code-block:: c++

         PropertyI prop(hObj);
         prop.writeS("5"); // string assignment
         prop.write(5); // integer assignment
    }Else if: DOXYGEN_JAVA_DOCUMENTATION {

    .. code-block:: c++

         PropertyI prop = new PropertyI(hObj);
         prop.writeS("5"); // string assignment
         prop.write(5); // integer assignment
    }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

    .. code-block:: c++

         prop = acquire.PropertyI(hObj)
         prop.writeS("5") # string assignment
         prop.write(5) # integer assignment
    }

     In addition to that *float* and *int* Properties might define a translation dictionary. This cannot be
     done by the user, but the user can work with the dictionary afterwards. A translation
     dictionary is a table which maps strings to certain values (e.g. integers).

     The translation dictionary serves two purposes: Once it has been defined this property can only be
     assigned values ( which can either be passed as a string or as the actual value )
     which are contained in the translation table. Thus this makes it very easy to restrict
     a certain property to a fixed number of values, which can be assigned to it.
     Properties that have a translation dictionary will typically be defined by declaring
     a template instance with the type of the enumeration.

     The second benefit of a translation dictionary is that certain values can be assigned
     a meaningful description via its translation.
     When a translation table has been defined either the string translation can be used to
     assign its value or its actual data type. A float property e.g. might define a translation
     table like this: 'Auto -> 0', 'auto -> 1', 'OnLowLevel -> 2'. Now to set this property
     to use the 'on low level' trigger mode this can be done by calling one of the 'write' functions.
    If: DOXYGEN_CPP_DOCUMENTATION {

    .. code-block:: c++

         PropertyICameraTriggerMode prop = getPropertyFromSomewhere();
         prop.writeS("OnLowLevel"); // set value via the translation string
         prop.write(ctmOnLowLevel); // set value via enum type
    }Else if: DOXYGEN_JAVA_DOCUMENTATION {

    .. code-block:: c++

         PropertyI prop = getPropertyFromSomewhere();
         prop.writeS("OnLowLevel"); // set value via the translation string
         prop.write(TCameraTriggerMode.ctmOnLowLevel); // set value via enum type
    }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

    .. code-block:: c++

         prop = getPropertyFromSomewhere() # assuming this function will return a 'PropertyICameraTriggerMode' instance!
         prop.writeS("OnLowLevel") # set value via the translation string
         prop.write(acquire.ctmOnLowLevel) # set value via enum type
    }

     This can also be extremely useful to populate combo boxes for GUI applications.

     Float and int properties can also define certain constants like a max. value or
     a min. value. If a property does define such values it can't be assigned values
     which do not lie within the defined range. To find out if constants are defined
     The user can call the functions **mvIMPACT::acquire::Property::hasMaxValue**,
     **mvIMPACT::acquire::Property::hasMinValue** and **mvIMPACT::acquire::Property::hasStepWidth**.
     To query to actual value of the max, min or step width the functions
     **getMaxValue**, **getMinValue** and **getStepWidth** of the classes
     **mvIMPACT::acquire::EnumPropertyF**, **mvIMPACT::acquire::EnumPropertyI** and
     **mvIMPACT::acquire::EnumPropertyI64** can be called.

     When reading the value of a property as a string the user can define a format string
     telling the property module how to format the returned string. This works pretty much
     like when working e.g. with the *printf* function.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::Property** object.
         Properties constructed this way can't be used for anything unless they
         are bound to a internal driver property with a **mvIMPACT::acquire::ComponentLocator** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::Property** object.
         Properties successfully constructed this way can be worked with directly.
         If *hObj* does not reference an internal driver property a **mvIMPACT::acquire::ENotAProperty**
         exception will be thrown.

        :type hProp: int
        :param hProp: [in] A valid handle to a property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::Property** from an existing one.
        :type src: :py:class:`Property`
        :param src: [in] A constant reference to the **mvIMPACT::acquire::Property** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.Property_swiginit(self, lib_mvIMPACT_acquire.new_Property(*args))

    def getAllowsValueCombinations(self):
        r"""
         Checks if this enumerated property allows the combination of enum values.
         If this function returns true, the enum constants can be 'ored' together. This works
         for the enum constants as well as for the string representations returned in the
         properties translation dictionary.

         if a property e.g. defines a dictionary (('1', "one"), ('2', "two")) the following
         write operations will be valid:

        .. code-block:: c++

             prop = getPropFromSomewhere()
             prop.write( 1 | 2 )
             prop.write( "one | two" )

         If this function returns true code like this will be valid:

         If: DOXYGEN_CPP_DOCUMENTATION {

        .. code-block:: c++

             enum TEnum
             {
               eA,
               eB
             };

             typedef EnumPropertyITEnum PropertyIEnum;
             PropertyIEnum p = getPropFromSomewhere();
             p.write( TEnum(eA | eB) );
        }Else if: DOXYGEN_JAVA_DOCUMENTATION {

        .. code-block:: c++

             ImageProcessing ip = new ImageProcessing( pDev );
             ip.getMirrorMode().write( TMirrorMode.mmTopDown | TMirrorMode.mmLeftRight );
        }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

        .. code-block:: c++

             prop = getPropFromSomewhere()
             prop.write(1 | 2)
             prop.write("one | two")
         }
         :rtype: boolean
         :return: 
             - true if this property allows the combination of enum values.
             - false otherwise.
        """
        return lib_mvIMPACT_acquire.Property_getAllowsValueCombinations(self)

    def dictSize(self):
        r"""
        Returns the size of the properties translation dictionary.
        If the property does define a translation dictionary this function returns
        the number of elements contained in this dictionary.
        :rtype: int
        :return: 
            - The size of the properties translation dictionary.
            - 0 If this property does not define a translation dictionary.
        """
        return lib_mvIMPACT_acquire.Property_dictSize(self)

    def getHasDict(self):
        r"""
        Returns whether this property defines a translation dictionary or not.
        :rtype: boolean
        :return: 
            - true if this property defines a translation table
            - false otherwise
        """
        return lib_mvIMPACT_acquire.Property_getHasDict(self)

    def getHasMaxValue(self):
        r"""
        Checks if a maximum value is defined for this property.
        Since: 1.12.63

        :rtype: boolean
        :return: 
            - true if this property defines a maximum value
            - false otherwise
        """
        return lib_mvIMPACT_acquire.Property_getHasMaxValue(self)

    def getHasMinValue(self):
        r"""
        Checks if a minimum value is defined for this property.
        Since: 1.12.63

        :rtype: boolean
        :return: 
            - true if this property defines a minimum value
            - false otherwise
        """
        return lib_mvIMPACT_acquire.Property_getHasMinValue(self)

    def getHasStepWidth(self):
        r"""
        Checks if a step width is defined for this property.
        Since: 1.12.63

        :rtype: boolean
        :return: 
            - true if this property defines a step width
            - false otherwise
        """
        return lib_mvIMPACT_acquire.Property_getHasStepWidth(self)

    def readS(self, *args):
        r"""
         Reads data from this property as a string.
         Notes: If the caller does not have the needed rights this function might throw an
         exception of the type **mvIMPACT::acquire::ImpactAcquireException**.

         :rtype: string
         :return: A string containing the data questioned.

        :type index: int
        :param index: [in] The index of the desired value(only necessary for properties containing more than one value)
        :type format: string
        :param format: [in] The format string telling the function how to format the result. If left empty the property uses its standard way of converting its data into a string
        """
        return lib_mvIMPACT_acquire.Property_readS(self, *args)

    def readSArray(self, *args):
        r"""
         Reads data from this property as a string.
         This function can be used to query a set of values if this property stores more
         than a single value which might be useful for GUI applications.

        If: DOXYGEN_CPP_DOCUMENTATION {

        .. code-block:: c++

             PropertyI p = getPropFromSomewhere();
             p.write( 1 );
             p.write( 2, 1 );
             p.write( 666, 2 );
             std::string s = p.readSArray( "%d", "&&:", 1 );
             // now s should contain '2:666'
             s = p.readSArray( "%4d", " ", 0, 1 );
             // now s should contain '   1,   2'
        }Else if: DOXYGEN_JAVA_DOCUMENTATION {

        .. code-block:: c++

             PropertyI p = getPropFromSomewhere();
             p.write( 1 );
             p.write( 2, 1 );
             p.write( 666, 2 );
             String s = p.readSArray( "%d", "&&:", 1 );
             // now s should contain '2:666'
             s = p.readSArray( "%4d", " ", 0, 1 );
             // now s should contain '   1,   2'
        }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

        .. code-block:: c++

             PropertyI p = getPropFromSomewhere()
             p.write(1)
             p.write(2, 1)
             p.write(666, 2)
             s = p.readSArray("%d", "&&:", 1)
             # now s should contain '2:666'
             s = p.readSArray("%4d", " ", 0, 1)
             # now s should contain '   1,   2'
        }

         Notes: If the caller does not have the needed rights this function might throw an
         exception of the type **mvIMPACT::acquire::ImpactAcquireException**.

         :rtype: string
         :return: A string containing the data questioned.

        :type format: string
        :param format: [in] The format string telling the function how to format the result. If left empty the property uses its standard way of converting its data into a string
        :type delimiter: string
        :param delimiter: [in] This string is used to separate the individual values from one another. If left empty, a single blank will separate the data.
        :type startIndex: int
        :param startIndex: [in] The index of the first of the desired values
        :type endIndex: int
        :param endIndex: [in] The index of the last of the desired values. If **INT_MAX** is passed, every from *startIndex* to the last value stored by the property will be returned.
        :type mode: int
        :param mode: [in] Specifies the mode this function operates in. Currently only the LSB affects the behaviour of this function. When the LSB is set, the translation dictionary (if defined) will be ignored for this call.
        """
        return lib_mvIMPACT_acquire.Property_readSArray(self, *args)

    def removeValue(self, index=0):
        r"""
         Removes a certain value from the property's data.
         :rtype: :py:class:`Property`
         :return: A const reference to the calling property.

        :type index: int
        :param index: [in] The index of the value to be removed
        """
        return lib_mvIMPACT_acquire.Property_removeValue(self, index)

    def resizeValArray(self, newSize):
        r"""
         Resizes the property's data array.
         This function resizes the internal data array of this property. The size of
         this array represents the number of values, which can be stored within the
         property. This function will only succeed, if the **mvIMPACT::acquire::cfFixedSize**
         is **NOT** set for this property and the user has **"write rights"** for this property.
         Otherwise an exception will be thrown. Whenever the user successfully writes an
         array of values to a property and this array contains more elements than the current
         internal data array can accommodate at the desired offset the internal data array
         will be increased automatically.

         Notes: If the caller does not have the needed rights this function might throw an
         exception of the type **mvIMPACT::acquire::ImpactAcquireException**.

         In order to be allowed to modify the number of values a property
         can store, the **mvIMPACT::acquire::cfFixedSize** flag
         must **NOT** be set.
         See also: 
         **mvIMPACT::acquire::Component::isWriteable**

         :rtype: :py:class:`Property`
         :return: A const reference to the calling property.

        :type newSize: int
        :param newSize: [in] The new number of values this property shall be allowed to store
        """
        return lib_mvIMPACT_acquire.Property_resizeValArray(self, newSize)

    def stringFormatString(self):
        r"""
        Returns the internal format string this property uses to convert data to strings.
        :rtype: string
        :return: A string containing the format string internally used by the property
            whenever the user reads a value as a string without specifying a format string and
            the property is not a string type one.
        """
        return lib_mvIMPACT_acquire.Property_stringFormatString(self)

    def valCount(self):
        r"""
        Returns the current number of values managed by this property.
        For the majority of properties this function will return '1', but as properties
        might manage more than a single value, this value might be interesting from time
        to time.
        :rtype: int
        :return: the current number of values managed by this property.
        """
        return lib_mvIMPACT_acquire.Property_valCount(self)

    def maxValCount(self):
        r"""
        Returns maximum number of values that can be managed by this property.
        For the majority of properties this function will return '1', but as properties
        might manage more than a single value, this value might be interesting from time
        to time.
        :rtype: int
        :return: the maximum number of values that can be managed by this property.
        """
        return lib_mvIMPACT_acquire.Property_maxValCount(self)

    def writeS(self, *args):
        r"""
        *Overload 1:*
         Assigns a new value to this property.
         The user caller have **"write rights"** for this property in order to be able to
         modify its value. Also if *index* is greater than the current internal data array
         size of this property the user must be allowed to change to size of the properties
         internal data array (the **mvIMPACT::acquire::cfFixedSize** flag must **NOT** be set).

         Notes: If the caller does not have the needed rights this function might throw an
         exception of the type **mvIMPACT::acquire::ImpactAcquireException**.

         See also: 
         **mvIMPACT::acquire::Component::isWriteable**,
        **mvIMPACT::acquire::Component::flags**,

         **mvIMPACT::acquire::Property::writeS**

         :rtype: :py:class:`Property`
         :return: A const reference to the calling property.

        :type value: string
        :param value: [in] The new value for this property at the given *index*
        :type index: int
        :param index: [in] The index of the value to modify

        |

        *Overload 2:*
         Assigns new values to this property.
         The user must have **"write rights"** for this property in order to be able to
         modify its values. Also if *index* is greater than the current internal data array
         size of this property the user must be allowed to change to size of the properties
         internal data array (the **mvIMPACT::acquire::cfFixedSize** flag must **NOT** be set). This
         function behaves exactly like **mvIMPACT::acquire::Property::writeS**
         except that is can be used to assign more than one value at the same time. The parameter
         *index* here serves as an offset. If for example a property holds 3 values 'one', 'two'
         and 'three' before this call and the function is then called with an array containing the
         string 'orange' and 'blue' and *index* = 2 then after a successful call to this function
         the property will hold the data 'one', 'two', 'orange' and 'blue'.

         Notes: If the caller does not have the needed rights this function might throw an
         exception of the type **mvIMPACT::acquire::ImpactAcquireException**.

         See also: 
         **mvIMPACT::acquire::Component::isWriteable**,
        **mvIMPACT::acquire::Component::flags**,

         **mvIMPACT::acquire::Property::writeS**

         :rtype: :py:class:`Property`
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [in] A constant reference to an array containing the strings to be assigned to the property
        :type index: int
        :param index: [in] The offset from where to start to assign the values

        |

        *Overload 3:*
         Assigns new values to this property.
         The user must have **"write rights"** for this property in order to be able to
         modify its values. Also if *index* is greater than the current internal data array
         size of this property the user must be allowed to change to size of the properties
         internal data array (the **mvIMPACT::acquire::cfFixedSize** flag must **NOT** be set). This
         function behaves exactly like **mvIMPACT::acquire::Property::writeS**
         except that is can be used to assign more than one value at the same time. The parameter
         *index* here serves as an offset. If for example a property holds 3 values 'one', 'two'
         and 'three' before this call and the function is then called with an array containing the
         string 'orange' and 'blue' and *index* = 2 then after a successful call to this function
         the property will hold the data 'one', 'two', 'orange' and 'blue'.

         Notes: If the caller does not have the needed rights this function might throw an
         exception of the type **mvIMPACT::acquire::ImpactAcquireException**.

         See also: 
         **mvIMPACT::acquire::Component::isWriteable**,
        **mvIMPACT::acquire::Component::flags**,

         **mvIMPACT::acquire::Property::writeS**

         :rtype: :py:class:`Property`
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [in] A constant reference to an array containing the strings to be assigned to the property
        :param index: [in] The offset from where to start to assign the values
        """
        return lib_mvIMPACT_acquire.Property_writeS(self, *args)

    r""" \brief A bool property \b (read-only) which checks if this enumerated property allows the combination of enum values. See mvIMPACT.acquire.Property.getAllowsValueCombinations() """
    allowsValueCombinations = property (getAllowsValueCombinations, None, None, None)
    r""" \brief A bool property \b (read-only) which checks whether this property defines a translation dictionary or not. See mvIMPACT.acquire.Property.getHasDict() """
    hasDict = property (getHasDict, None, None, None)
    r""" \brief A bool property \b (read-only) which checks if a maximum value is defined for this property. See mvIMPACT.acquire.Property.getHasMaxValue() """
    hasMaxValue = property (getHasMaxValue, None, None, None)
    r""" \brief A bool property \b (read-only) which checks if a minimum value is defined for this property. See mvIMPACT.acquire.Property.getHasMinValue() """
    hasMinValue = property (getHasMinValue, None, None, None)
    r""" \brief A bool property \b (read-only) which checks if a step width is defined for this property. See mvIMPACT.acquire.Property.getHasStepWidth() """
    hasStepWidth = property (getHasStepWidth, None, None, None)

    __swig_destroy__ = lib_mvIMPACT_acquire.delete_Property

# Register Property in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.Property_swigregister(Property)

class PropertyPtr(Property):
    r""" A class to represent pointer properties."""

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::PropertyPtr** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::PropertyPtr** object.
        :type hProp: int
        :param hProp: [in] A valid handle to a pointer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::PropertyPtr** from an existing one.
        :type src: :py:class:`PropertyPtr`
        :param src: [in] A constant reference to the **mvIMPACT::acquire::PropertyPtr** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyPtr_swiginit(self, lib_mvIMPACT_acquire.new_PropertyPtr(*args))

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: void
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< void *,std::allocator< void * > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< void *,std::allocator< void * > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< void *,std::allocator< void * > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyPtr_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.
         :rtype: :py:class:`PropertyPtr`
         :return: A const 'self' reference.

        :type value: void
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.
         :rtype: :py:class:`PropertyPtr`
         :return: A const 'self' reference.

        :type sequence: std::vector< void *,std::allocator< void * > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.
         :rtype: :py:class:`PropertyPtr`
         :return: A const 'self' reference.

        :type sequence: std::vector< void *,std::allocator< void * > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyPtr_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyPtr

# Register PropertyPtr in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyPtr_swigregister(PropertyPtr)

class PropertyS(Property):
    r""" A class to represent string properties."""

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::PropertyS** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::PropertyS** object.
        :type hProp: int
        :param hProp: [in] A valid handle to the string property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::PropertyS** from an existing one.
        :type src: :py:class:`PropertyS`
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyS** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyS_swiginit(self, lib_mvIMPACT_acquire.new_PropertyS(*args))

    def binaryDataBufferSize(self, index=0):
        r"""
         Returns the size(in bytes) needed for the binary representation of the string buffer.
         When binary data has been stored in a string property it has been stored in [Base64](https://en.wikipedia.org/wiki/Base64) format
         internally. If the user wants to know the length of the binary data in decoded format,
         this function can be called.

         See also: **mvIMPACT::acquire::PropertyS::readBinary**,

             **mvIMPACT::acquire::PropertyS::writeBinary**,

             **mvIMPACT::acquire::PropertyS::binaryDataBufferMaxSize**

         :rtype: int
         :return: The size(in bytes) needed for the binary representation of the string buffer.

        :type index: int
        :param index: [in] The index of the value for which to query the buffer size(if this property holds more than one value).
        """
        return lib_mvIMPACT_acquire.PropertyS_binaryDataBufferSize(self, index)

    def binaryDataBufferMaxSize(self):
        r"""
        Reads the max size(in bytes) of binary data this property can store.
        When binary data shall be stored in a string property, the user will need to allocate memory
        when this data shall be written to the property. To find out how much binary data can be stored
        by a property before calling the function **mvIMPACT::acquire::PropertyS::writeBinary** this function can be used.

        See also: **mvIMPACT::acquire::PropertyS::readBinary**,

            **mvIMPACT::acquire::PropertyS::writeBinary**,

            **mvIMPACT::acquire::PropertyS::binaryDataBufferMaxSize**

        :rtype: int
        :return: The size(in bytes) needed for the binary representation of the string buffer.
        """
        return lib_mvIMPACT_acquire.PropertyS_binaryDataBufferMaxSize(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: string
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyS_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: :py:class:`PropertyS`
         :return: A const 'self' reference.

        :type value: string
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: :py:class:`PropertyS`
         :return: A const 'self' reference.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: :py:class:`PropertyS`
         :return: A const 'self' reference.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyS_write(self, *args)

    def readBinary(self, *args):
        r"""
        *Overload 1:*
         Reads a value stored in the property as binary data.
         Binary data can only be stored in string properties. When writing binary data to a string
         property it's stored in [Base64](https://en.wikipedia.org/wiki/Base64) format internally. The Base64 algorithm converts arbitrary data
         into a read and printable string representation. As a result of this 3 bytes of arbitrary binary
         data will occupy 4 bytes of memory.

         Reading binary data with this function obviously only makes sense if the property has been assigned
         the value by a previous call to **mvIMPACT::acquire::PropertyS::writeBinary** (here you find a small code example as well).
         However using this method any kind of data can be stored by a string property.
         This can e.g. be interesting when certain data shall be stored in the
         user accessible part of the devices non-volatile memory.

         See also: **mvIMPACT::acquire::PropertyS::writeBinary**,

             **mvIMPACT::acquire::PropertyS::binaryDataBufferSize**,

             **mvIMPACT::acquire::PropertyS::binaryDataBufferMaxSize**
         :rtype: string
         :return: The binary data representation of the specified property value as a new std::string object.

        :type index: int
        :param index: [in] The index of the value to get(if this property holds more than one value).
        :type boLegacyMode: boolean
        :param boLegacyMode: [in] If set to *true* this allows applications compiled with mvIMPACT Acquire 2.32.0 or greater using this function to run on systems with mvIMPACT Acquire smaller than 2.32.0. The legacy version of this function runs slower!

        |

        *Overload 2:*
         Reads a value stored in the property as binary data.
         Binary data can only be stored in string properties. When writing binary data to a string
         property it's stored in [Base64](https://en.wikipedia.org/wiki/Base64) format internally. The Base64 algorithm converts arbitrary data
         into a read and printable string representation. As a result of this 3 bytes of arbitrary binary
         data will occupy 4 bytes of memory.

         Reading binary data with this function obviously only makes sense if the property has been assigned
         the value by a previous call to **mvIMPACT::acquire::PropertyS::writeBinary** (here you find a small code example as well).
         However using this method any kind of data can be stored by a string property.
         This can e.g. be interesting when certain data shall be stored in the
         user accessible part of the devices non-volatile memory.

         See also: **mvIMPACT::acquire::PropertyS::writeBinary**,

             **mvIMPACT::acquire::PropertyS::binaryDataBufferSize**,

             **mvIMPACT::acquire::PropertyS::binaryDataBufferMaxSize**

        :type pBuf: string
        :param pBuf: [in] A pointer to a piece of memory that shall receive bhe binary data stored by the this property.
        :type bufSize: int
        :param bufSize: [in] The size of the buffer pointed to by ``pBuf`` in bytes.
        :type index: int
        :param index: [in] The index of the value to get(if this property holds more than one value).
        :type boLegacyMode: boolean
        :param boLegacyMode: [in] If set to *true* this allows applications compiled with mvIMPACT Acquire 2.32.0 or greater using this function to run on systems with mvIMPACT Acquire smaller than 2.32.0. The legacy version of this function runs slower!

        |

        *Overload 3:*
         Reads a value stored in the property as binary data.
         Binary data can only be stored in string properties. When writing binary data to a string
         property it's stored in [Base64](https://en.wikipedia.org/wiki/Base64) format internally. The Base64 algorithm converts arbitrary data
         into a read and printable string representation. As a result of this 3 bytes of arbitrary binary
         data will occupy 4 bytes of memory.

         Reading binary data with this function obviously only makes sense if the property has been assigned
         the value by a previous call to **mvIMPACT::acquire::PropertyS::writeBinary** (here you find a small code example as well).
         However using this method any kind of data can be stored by a string property.
         This can e.g. be interesting when certain data shall be stored in the
         user accessible part of the devices non-volatile memory.

         See also: **mvIMPACT::acquire::PropertyS::writeBinary**,

             **mvIMPACT::acquire::PropertyS::binaryDataBufferSize**,

             **mvIMPACT::acquire::PropertyS::binaryDataBufferMaxSize**

        :type pBuf: string
        :param pBuf: [in] A pointer to a piece of memory that shall receive bhe binary data stored by the this property.
        :type bufSize: int
        :param bufSize: [in] The size of the buffer pointed to by ``pBuf`` in bytes.
        :type index: int
        :param index: [in] The index of the value to get(if this property holds more than one value).
        :param boLegacyMode: [in] If set to *true* this allows applications compiled with mvIMPACT Acquire 2.32.0 or greater using this function to run on systems with mvIMPACT Acquire smaller than 2.32.0. The legacy version of this function runs slower!

        |

        *Overload 4:*
         Reads a value stored in the property as binary data.
         Binary data can only be stored in string properties. When writing binary data to a string
         property it's stored in [Base64](https://en.wikipedia.org/wiki/Base64) format internally. The Base64 algorithm converts arbitrary data
         into a read and printable string representation. As a result of this 3 bytes of arbitrary binary
         data will occupy 4 bytes of memory.

         Reading binary data with this function obviously only makes sense if the property has been assigned
         the value by a previous call to **mvIMPACT::acquire::PropertyS::writeBinary** (here you find a small code example as well).
         However using this method any kind of data can be stored by a string property.
         This can e.g. be interesting when certain data shall be stored in the
         user accessible part of the devices non-volatile memory.

         See also: **mvIMPACT::acquire::PropertyS::writeBinary**,

             **mvIMPACT::acquire::PropertyS::binaryDataBufferSize**,

             **mvIMPACT::acquire::PropertyS::binaryDataBufferMaxSize**

        :type pBuf: string
        :param pBuf: [in] A pointer to a piece of memory that shall receive bhe binary data stored by the this property.
        :type bufSize: int
        :param bufSize: [in] The size of the buffer pointed to by ``pBuf`` in bytes.
        :param index: [in] The index of the value to get(if this property holds more than one value).
        :param boLegacyMode: [in] If set to *true* this allows applications compiled with mvIMPACT Acquire 2.32.0 or greater using this function to run on systems with mvIMPACT Acquire smaller than 2.32.0. The legacy version of this function runs slower!
        """
        return lib_mvIMPACT_acquire.PropertyS_readBinary(self, *args)

    def writeBinary(self, *args):
        r"""
        *Overload 1:*
         Writes a block of binary data to one entry of the property.
         Binary data can only be stored in string properties. When writing binary data to a string
         property it's stored in [Base64](https://en.wikipedia.org/wiki/Base64) format internally. The Base64 algorithm converts arbitrary data
         into a read and printable string representation. As a result of this 3 bytes of arbitrary binary
         data will occupy 4 bytes of memory.

         By writing binary data with this function arbitrary data can be stored by a string property.
         This can e.g. be interesting when certain data shall be stored in the
         user accessible part of the devices non-volatile memory.

        If: DOXYGEN_CPP_DOCUMENTATION {

        .. code-block:: c++

             char binData [6] = { 'A', 'B', 0x00, -128, 'E', 'F' };
             const string value( binData, sizeof( binData ) / sizeof( binData[0] ) );
             PropertyS prop( getHandleFromSomewhere() );
             prop.writeBinary( value );
        }Else if: DOXYGEN_JAVA_DOCUMENTATION {

        .. code-block:: c++

             final int BUF_SIZE = 6;
             byte[] data_bytes = new byte[BUF_SIZE];
             data_bytes[0] = 0x00;
             data_bytes[1] = -1;
             data_bytes[2] = -128;
             data_bytes[3] = 0x33;
             ByteBuffer data = ByteBuffer.allocateDirect( BUF_SIZE );
             data.put( data_bytes );
             binaryProp = acquire.PropertyS( getHandleFromSomewhere() )
             binaryProp.writeBinary( data );
        }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

        .. code-block:: c++

             binData = ''
             binaryProp = acquire.PropertyS(getHandleFromSomewhere())
             binaryProp.writeBinary(binData)
        }

         To find out if a property contains binary data check if **mvIMPACT::acquire::cfContainsBinaryData** is set e.g. by calling

        If: DOXYGEN_CPP_DOCUMENTATION {

        .. code-block:: c++

             PropertyS prop( getHandleFromSomewhere() );
             if( prop.flags()  cfContainsBinaryData )
             {
               // Yes!! Binary data
             }
        }Else if: DOXYGEN_JAVA_DOCUMENTATION {

        .. code-block:: c++

             PropertyS prop = new PropertyS( getHandleFromSomewhere() );
             if( ( prop.flags()  TComponentFlag.cfContainsBinaryData ) == TComponentFlag.cfContainsBinaryData )
             {
               // Yes!! Binary data
             }
        }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

        .. code-block:: c++

             binaryProp = acquire.PropertyS(getHandleFromSomewhere())
             if pseudoBinaryProp.flags()  acquire.cfContainsBinaryData:
                 # Yes!! Binary data!
         }

        Performance considerations:

        mvIMPACT Acquire 2.15.0 and newer:

        - Base64 encoding/decoding only is performed when read string data previously written as binary data and vice versa.
        - encoding/decoding only is performed if the 2 internal caches are out of sync. so only on the first read access using the other format.
        - this version is more efficient compared to previous implementations.



        mvIMPACT Acquire versions smaller than 2.15.0

        - Base64 encoding/decoding always is performed when reading/writing data in binary format.



        Notes: 
        When a property stores binary data that came from a GenICam chunk buffer additional copy operations from the GenApi runtime will take place. This can be
        considered as an additional copy operation into the application binary buffer. So binary chunk data should be avoided if possible!

         See also: **mvIMPACT::acquire::PropertyS::readBinary**,

             **mvIMPACT::acquire::PropertyS::binaryDataBufferSize**,

             **mvIMPACT::acquire::PropertyS::binaryDataBufferMaxSize**

         :rtype: :py:class:`PropertyS`
         :return: A const 'self' reference.

        :type value: string
        :param value: [in] A const reference to the string holding the binary data that shall be stored by the this property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a block of binary data to one entry of the property.
         Binary data can only be stored in string properties. When writing binary data to a string
         property it's stored in [Base64](https://en.wikipedia.org/wiki/Base64) format internally. The Base64 algorithm converts arbitrary data
         into a read and printable string representation. As a result of this 3 bytes of arbitrary binary
         data will occupy 4 bytes of memory.

         By writing binary data with this function arbitrary data can be stored by a string property.
         This can e.g. be interesting when certain data shall be stored in the
         user accessible part of the devices non-volatile memory.

         If: DOXYGEN_CPP_DOCUMENTATION {

        .. code-block:: c++

             char binData [6] = { 'A', 'B', 0x00, -128, 'E', 'F' };
             const string value(binData, sizeof(binData) / sizeof(binData[0] ));
             PropertyS prop(getHandleFromSomewhere());
             prop.writeBinary( value );
         }

         To find out if a property contains binary data check if **mvIMPACT::acquire::cfContainsBinaryData** is set e.g. by calling

         If: DOXYGEN_CPP_DOCUMENTATION {

        .. code-block:: c++

             PropertyS prop(getHandleFromSomewhere());
             if( prop.flags()  cfContainsBinaryData )
             {
               // Yes!! Binary data
             }
         }

        Performance considerations:

        mvIMPACT Acquire 2.15.0 and newer:

        - Base64 encoding/decoding only is performed when read string data previously written as binary data and vice versa.
        - encoding/decoding only is performed if the 2 internal caches are out of sync. so only on the first read access using the other format.
        - this version is more efficient compared to previous implementations.



        mvIMPACT Acquire versions smaller than 2.15.0

        - Base64 encoding/decoding always is performed when reading/writing data in binary format.



        Notes: 
        When a property stores binary data that came from a GenICam chunk buffer additional copy operations from the GenApi runtime will take place. This can be
        considered as an additional copy operation into the application binary buffer. So binary chunk data should be avoided if possible!

         See also: **mvIMPACT::acquire::PropertyS::readBinary**,

             **mvIMPACT::acquire::PropertyS::binaryDataBufferSize**,

             **mvIMPACT::acquire::PropertyS::binaryDataBufferMaxSize**

         :rtype: void
         :return: A const 'self' reference.

        :type pBuf: string
        :param pBuf: [in] A const pointer to a piece of memory holding the binary data that shall be stored by the this property.
        :type bufSize: int
        :param bufSize: [in] The size of the buffer pointed to by ``pBuf`` in bytes.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 3:*
         Writes a block of binary data to one entry of the property.
         Binary data can only be stored in string properties. When writing binary data to a string
         property it's stored in [Base64](https://en.wikipedia.org/wiki/Base64) format internally. The Base64 algorithm converts arbitrary data
         into a read and printable string representation. As a result of this 3 bytes of arbitrary binary
         data will occupy 4 bytes of memory.

         By writing binary data with this function arbitrary data can be stored by a string property.
         This can e.g. be interesting when certain data shall be stored in the
         user accessible part of the devices non-volatile memory.

         If: DOXYGEN_CPP_DOCUMENTATION {

        .. code-block:: c++

             char binData [6] = { 'A', 'B', 0x00, -128, 'E', 'F' };
             const string value(binData, sizeof(binData) / sizeof(binData[0] ));
             PropertyS prop(getHandleFromSomewhere());
             prop.writeBinary( value );
         }

         To find out if a property contains binary data check if **mvIMPACT::acquire::cfContainsBinaryData** is set e.g. by calling

         If: DOXYGEN_CPP_DOCUMENTATION {

        .. code-block:: c++

             PropertyS prop(getHandleFromSomewhere());
             if( prop.flags()  cfContainsBinaryData )
             {
               // Yes!! Binary data
             }
         }

        Performance considerations:

        mvIMPACT Acquire 2.15.0 and newer:

        - Base64 encoding/decoding only is performed when read string data previously written as binary data and vice versa.
        - encoding/decoding only is performed if the 2 internal caches are out of sync. so only on the first read access using the other format.
        - this version is more efficient compared to previous implementations.



        mvIMPACT Acquire versions smaller than 2.15.0

        - Base64 encoding/decoding always is performed when reading/writing data in binary format.



        Notes: 
        When a property stores binary data that came from a GenICam chunk buffer additional copy operations from the GenApi runtime will take place. This can be
        considered as an additional copy operation into the application binary buffer. So binary chunk data should be avoided if possible!

         See also: **mvIMPACT::acquire::PropertyS::readBinary**,

             **mvIMPACT::acquire::PropertyS::binaryDataBufferSize**,

             **mvIMPACT::acquire::PropertyS::binaryDataBufferMaxSize**

         :rtype: void
         :return: A const 'self' reference.

        :type pBuf: string
        :param pBuf: [in] A const pointer to a piece of memory holding the binary data that shall be stored by the this property.
        :type bufSize: int
        :param bufSize: [in] The size of the buffer pointed to by ``pBuf`` in bytes.
        :param index: [in] The index defining at which position to write the value.
        """
        return lib_mvIMPACT_acquire.PropertyS_writeBinary(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyS

# Register PropertyS in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyS_swigregister(PropertyS)

class UserDataEntry(object):
    r"""
     A helper class that represents one entry in the devices non-volatile memory (if available).

     Each entry of user and device specific data consists of a name, data a property
     defining the access rights for this entry and an optional password.

     The name can be any string, but currently is limited to 255 characters.

     The **mvIMPACT::acquire::UserDataEntry::data** property can hold any type of user data that shall be
     stored in the device's non-volatile memory. This can either be a string or binary
     data. To store binary data the function
     **mvIMPACT::acquire::PropertyS::writeBinary**
     can be used. Internally however binary data will be stored as a [Base64](https://en.wikipedia.org/wiki/Base64) encoded string.
     To read binary data from the property again the function
     **mvIMPACT::acquire::PropertyS::readBinary**
     must be called. The theoretical limit for the amount of data per entry is 2^16 (64KB) bytes,
     however the real limit might be below this value because the device does not offer
     that much memory.

     The **mvIMPACT::acquire::UserDataEntry::access** property defines the access rights the user has when
     working with the entry. **AFTER** creation but **BEFORE** storing the entry into the device
     this property can be modified. At this point the creator of the entry can choose between 2 options:
     **mvIMPACT::acquire::udarFull** and **mvIMPACT::acquire::udarRW**.
     After storing the entry into the device by calling
     **mvIMPACT::acquire::UserData::writeToHardware** this property will become **read-only** and
     will remain **read-only** until the complete entry is deleted.

     When the user creates a new entry for the user accessible device non-volatile memory
     he can either create a read/write data set, which means that every user can modify
     the *data* and the *name* property. In that case the property *password* is ignored.
     Apart from that an entry that can only be modified when the correct password has been
     written to the *password* property. To read a value is always allowed.

     The *password* property will hold the user input and **NOT** the actual password needed
     to unlock the data set. However when an entry has been created the creator afterwards can
     write to the password. When the creator then calls the function **mvIMPACT::acquire::UserData::writeToHardware**
     the value of the *password* property is used as the 'real' password from that
     moment onwards.

     The maximum length for the password currently is 255 characters. This does not
     provide total security of cause, but the idea of the password only is to hinder
     the user from deleting an import entry by accident.

     The memory consumed by a single **mvIMPACT::acquire::UserDataEntry** can vary from device
     to device and depends on the way the data is stored internally. In any case when an entry
     is created it will consume more memory than the amount of bytes written to the
     **mvIMPACT::acquire::UserDataEntry::data**. After data has been written to an entry
     it is therefore important to check the **mvIMPACT::acquire::UserData::memoryAvailable_bytes**
     property if there is still enough memory available.

     Notes: 
     There might be entries that can't be modified by the user. These entries contain
     important data that have been written to the memory during production. An attempt
     to delete this data will fail.

    If: DOXYGEN_CPP_DOCUMENTATION {

    .. code-block:: c++

         //-----------------------------------------------------------------------------
         int storeUserData( Device* pDev, char* pData, size_t dataSize, const std::string entryName )
         //-----------------------------------------------------------------------------
         {
           UserData userData = pDev-getUserData();
           if( !userData.isAvailable() )
           {
             cout < "This device does not support user data" < endl;
             return -1;
           }

           cout < "Available user memory(bytes): " < userData.memoryAvailable_bytes.read() < endl;
           cout < "Memory consumed already(bytes): " < userData.memoryConsumed_bytes.read() < endl;

           // create a new entry
           UserDataEntry entry = userData.createEntry();
           if( !entry.isValid() )
           {
             cout < "Failed to create new entry" < endl;
             return -2;
           }

           string value( pData, dataSize );
           entry.data.writeBinary( value );
           entry.name.write( entryName );

           // write to non-volatile memory (therefore the device MUST be closed)
           if( pDev-isOpen() )
           {
             cout < "Can't store data as the device is already in use" < endl;
             return -3;
           }

           userData.writeToHardware();
           if( pDev-HWUpdateResult.read() != urSetUserDataWriteOK )
           {
             cout < "Failed to store data in device non-volatile memory" < endl;
             return -4;
           }

           // now this data is stored in the devices permanent memory
           return 0;
         }
    }Else if: DOXYGEN_JAVA_DOCUMENTATION {

    .. code-block:: c++

         //-----------------------------------------------------------------------------
         public static int storeUserData( Device pDev, byte[] data_bytes, final String entryName )
         //-----------------------------------------------------------------------------
         {
           UserData userData = pDev.getUserData();
           if( !userData.isAvailable() )
           {
             System.out.println( "This device does not support user data" );
             return -1;
           }

           System.out.println( String.format( "Available user memory(bytes): %d", userData.getMemoryAvailable_bytes().read() ) );
           System.out.println( String.format( "Memory consumed already(bytes): %d", userData.getMemoryConsumed_bytes().read() ) );

           // create a new entry
           UserDataEntry entry = userData.createEntry();
           if( !entry.isValid() )
           {
             System.out.println( "Failed to create new entry" );
             return -2;
           }

           ByteBuffer data = ByteBuffer.allocateDirect( data_bytes.length );
           data.put( data_bytes );
           entry.getData().writeBinary( data );
           entry.getName().write( entryName );

           // write to non-volatile memory (therefore the device MUST be closed)
           if( pDev.isOpen() )
           {
             System.out.println( "Can't store data as the device is already in use" );
             return -3;
           }

           userData.writeToHardware();
           if( pDev.getHWUpdateResult().read() != THWUpdateResult.urSetUserDataWriteOK )
           {
             System.out.println( "Failed to store data in device non-volatile memory" );
             return -4;
           }

           // now this data is stored in the devices permanent memory
           return 0;
         }
    }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

    .. code-block:: c++


         def storeUserData(pDev, pData, entryName):
            userData = pDev.getUserData()
            if not userData.isAvailable:
              print("This device does not support user data")
              return -1

            print("Available user memory(bytes): " + str(userData.memoryAvailable_bytes.read()))
            print("Memory consumed already(bytes): " + str(userData.memoryConsumed_bytes.read()))

            # create a new entry
            entry = userData.createEntry();
            if not entry.isValid:
              print("Failed to create new entry")
              return -2;

            entry.data.writeBinary(pData)
            entry.name.write(entryName)

            # write to non-volatile memory (therefore the device MUST be closed)
            if pDev.isOpen:
                print("Can't store data as the device is already in use")
                return -3

            userData.writeToHardware();
            if pDev.HWUpdateResult.read() != acquire.urSetUserDataWriteOK:
                print("Failed to store data in device non-volatile memory")
                return -4

            # now this data is stored in the devices permanent memory
            return 0
    }


     Instances of this class can only be created by the class **UserData**.
    """

    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

    def getUDEIsValid(self):
        r"""
        Call this function to check if this object references an existing entry.
        :rtype: boolean
        :return: 
            - true if this object references an existing entry
            - false otherwise
        """
        return lib_mvIMPACT_acquire.UserDataEntry_getUDEIsValid(self)
    name = property(lib_mvIMPACT_acquire.UserDataEntry_name_get, doc=r"""
    The name of the entry.
    The maximum length for the name currently is 255 characters.
    """)
    data = property(lib_mvIMPACT_acquire.UserDataEntry_data_get, doc=r"""
    The data stored in this entry.
    The theoretical limit for the amount of data per entry is 2^16 (64KB) bytes,
    however the real limit might be below this value because the device does not offer
    that much memory.

    This property can either store string or binary data. See **mvIMPACT::acquire::PropertyS** to find
    out how to work with binary data.
    """)
    access = property(lib_mvIMPACT_acquire.UserDataEntry_access_get, doc=r"""
    The access rights for this entry.
    After this entry has been written to the devices non-volatile memory, this property
    will become **read-only**.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TUserDataAccessRight**.
    """)
    password = property(lib_mvIMPACT_acquire.UserDataEntry_password_get, doc=r"""
    The password needed to modify this entry.
    The maximum length for the password is 255 characters currently. When the
    **mvIMPACT::acquire::udarPassword** is not specified
    by the *access* property, this property will be ignored. Otherwise this
    property must have been assigned the correct password (case sensitive) before
    the *name* and *data* properties can be modified.
    """)

    r""" \brief A bool property \b (read-only) which checks if this object references an existing entry. See mvIMPACT.acquire.UserDataEntry.getUDEIsValid() """
    isValid = property (getUDEIsValid, None, None, None)

    __swig_destroy__ = lib_mvIMPACT_acquire.delete_UserDataEntry

# Register UserDataEntry in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.UserDataEntry_swigregister(UserDataEntry)

class UserData(object):
    r"""
    A helper class to work with the device specific non-volatile memory(if available).
    A device might have a certain amount of non-volatile memory which can be accessed and modified by
    the user. This data can e.g. be used to store certain parameters or custom data permanently into the
    device. Thus this property e.g. can be used to store configuration data in the device before shipping it
    to the end user.

    In theory the number of entries that can be stored in the device is not limited. However no device
    will provide an unlimited amount of memory.

    Writing data to any property of a **mvIMPACT::acquire::UserDataEntry** as well as creating a new entry by calling
    **mvIMPACT::acquire::UserData::createEntry** or deleting an entry with the function
    **mvIMPACT::acquire::UserData::deleteEntry** will **NOT** automatically result in
    the complete data to be updated in the device specific memory. As writing to the device memory takes
    a long (in terms of ms) time depending on the device architecture the modifications will only become.
    permanent when calling **mvIMPACT::acquire::UserData::writeToHardware**.

    If data at the end of the list of entries doesn't fit in the memory it will be discarded and therefore
    will not be visible the next time the device is enumerated/accessed after the running process has
    terminated or the device has been disconnected.

    Notes: 
    Entries that contain no data will not be stored in hardware. If e.g. 5 user data entries have been created,
    but only entry 0, 1, 2 and 4 contain data the write operation will pack the data in a way that when the user data
    is read from the device again (when the driver for that device is loaded the next time) the list of entries
    will contain elements at position 0, 1, 2 and 3 but **NOT** a index number 4. Deleting an entry from the middle
    of the list of user data however will **NOT** move all remaining entries one step towards the front of the
    list. Therefore during one session the entry indexes will **NOT** change. They can either become invalid (when
    the corresponding entry has been deleted), can get valid (newly created entries will always appear at the next
    free entry, thus deleting and entry and creating a new directly afterwards will create that entry at exactly the
    same index) or new entries can appear (when a new entry has been created and no free list position in the
    middle of the list of entries has been available).


    The device must be closed in order to write the user data. Check the property **mvIMPACT::acquire::Device::HWUpdateResult**
    afterwards in order to make sure the data transfer was successful.


    If a device does not offer user accessible data **mvIMPACT::acquire::UserDataEntry** objects will still be returned by certain
    functions. To check if this feature is available call **mvIMPACT::acquire::UserData::isAvailable**.


    If the user accessible data currently can't be modified an exception of type **mvIMPACT::acquire::ENoWriteRights**
    will be thrown.


    Instances of this class cannot be constructed directly. To get access the function **mvIMPACT::acquire::Device::getUserData**.
    must be used.
    """

    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

    def createEntry(self):
        r"""
        Creates and returns a new entry to store user specific data.
        Notes: 
        The data handled by this object will not be stored permanently in the devices non-volatile
        memory until **mvIMPACT::acquire::UserData::writeToHardware** has been called successfully.

        See also: 
        **mvIMPACT::acquire::UserData::deleteEntry**,

           mvIMPACT::acquire::UserData::writeToHardware
        :rtype: :py:class:`UserDataEntry`
        :return: A new **mvIMPACT::acquire::UserDataEntry** instance that can be used to store user specific data
            in the devices non-volatile memory.
        """
        return lib_mvIMPACT_acquire.UserData_createEntry(self)

    def deleteEntry(self, userDataEntry):
        r"""
         Deletes an entry of user specific data.
         If the entry has been stored to the non-volatile memory already and has been assigned
         the **mvIMPACT::acquire::udarPassword** flag, this call will fail, when
         **mvIMPACT::acquire::UserDataEntry::password** does not contain the correct password.
         Notes: 
         The data handled by this object will not be removed permanently from the devices non-volatile
         memory until **mvIMPACT::acquire::UserData::writeToHardware(** void ) const has been called successfully.
         See also: 
         **mvIMPACT::acquire::UserData::createEntry**,

             mvIMPACT::acquire::UserData::writeToHardware

        :type userDataEntry: :py:class:`UserDataEntry`
        :param userDataEntry: [in] A reference to the entry to delete
        """
        return lib_mvIMPACT_acquire.UserData_deleteEntry(self, userDataEntry)

    def getFreeMemory(self):
        r"""
        Returns the number of bytes of user accessible, non-volatile memory that is still available.

        Since: 1.12.64
        """
        return lib_mvIMPACT_acquire.UserData_getFreeMemory(self)

    def getUserDataEntry(self, nr):
        r"""
         Returns An object to work with an existing entry of user specific data.
         Notes: 
         If an invalid number has been passed as *nr* an object will be returned as well. Therefore
         always check if the entry is valid by calling **mvIMPACT::acquire::UserDataEntry::isValid** before
         working with the object.

         :rtype: :py:class:`UserDataEntry`
         :return: An object to work with an existing entry of user specific data.

        :type nr: int
        :param nr: [in] The number of the entry to return
        """
        return lib_mvIMPACT_acquire.UserData_getUserDataEntry(self, nr)

    def validUserDataEntryIndexes(self, sequence):
        r"""
         Fills an array with all currently valid user data entry indexes.
         This function can be used to obtain a list of valid parameters for calls to the function **mvIMPACT::acquire::UserData::getUserDataEntry**.
         Every value in the returned array will (when passed to the function **mvIMPACT::acquire::UserData::getUserDataEntry)** result in a
         valid **mvIMPACT::acquire::UserDataEntry** object.

        :type sequence: std::vector< int,std::allocator< int > >
        :param sequence: [out] A reference to the array receiving the list of valid indexes
        """
        return lib_mvIMPACT_acquire.UserData_validUserDataEntryIndexes(self, sequence)

    def getIsAvailable(self):
        r"""
        This function should be called to check if this device offers non-volatile memory that can be accessed by the user.
        :rtype: boolean
        :return: 
            - true if the device offers non-volatile memory that can be accessed by the user
            - false otherwise
        """
        return lib_mvIMPACT_acquire.UserData_getIsAvailable(self)

    def writeToHardware(self):
        r"""
        Writes the current set of user data into the devices non-volatile memory.
        This function might take a while. Depending on the device architecture and the amount of
        memory up to some hundred ms. Therefore make sure this function is not called more often
        than necessary to let your application perform efficiently.
        See also: 
        **mvIMPACT::acquire::UserData::createEntry**,

        **mvIMPACT::acquire::UserData::deleteEntry**
        """
        return lib_mvIMPACT_acquire.UserData_writeToHardware(self)
    reconnectBehaviour = property(lib_mvIMPACT_acquire.UserData_reconnectBehaviour_get, doc=r"""
    An enumerated integer property that can be used to configure how the user data should be treated in case of a device that has been unplugged is plugged back in again.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TUserDataReconnectBehaviour**.

    If a device does not support hot-plugging, this property will be invisible (**mvIMPACT::acquire::Component::isVisible())**,
    """)
    memoryAvailable_bytes = property(lib_mvIMPACT_acquire.UserData_memoryAvailable_bytes_get, doc=r""" An integer property **(read-only)** containing the number of bytes of user accessible, non-volatile memory this device has available.""")
    memoryConsumed_bytes = property(lib_mvIMPACT_acquire.UserData_memoryConsumed_bytes_get, doc=r"""
    An integer property **(read-only)** containing the number of bytes of user accessible, non-volatile memory currently consumed by user data.
    This doesn't indicate that all the data has already been stored in the non-volatile memory,
    but is the number of bytes needed to store the current user data permanently. No check for
    overflows will be performed. If the user defined data exceeds the size of the available memory,
    this data will be lost when disconnecting or switching of the supply voltage for this device.

    To write data permanently into the device call the function **mvIMPACT::acquire::UserData::writeToHardware**
    But even after calling this function data that exceeds the available memory will be lost when the
    device looses supply voltage and/or the process terminates.
    """)

    r""" \brief A bool property \b (read-only) which checks if this device offers non-volatile memory that can be accessed by the user. See mvIMPACT.acquire.UserData.getIsAvailable() """
    isAvailable = property (getIsAvailable, None, None, None)

    __swig_destroy__ = lib_mvIMPACT_acquire.delete_UserData

# Register UserData in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.UserData_swigregister(UserData)

class Device(object):
    r"""
    This class and its functions represent an actual device detected by this interface in the current system.

    Instances of it can only be created by instances of the **mvIMPACT::acquire::DeviceManager** class
    as only the **mvIMPACT::acquire::DeviceManager** has the precise knowledge to do that anyway.
    As a result from this fact pointers to instances of **mvIMPACT::acquire::Device** can be obtained
    via a **mvIMPACT::acquire::DeviceManager** object only.


    **NEVER** try to explicitly delete an instance of **mvIMPACT::acquire::Device!** You did not allocate it
    and the result will be a crash! The **mvIMPACT::acquire::DeviceManager** will take care of all resources
    for you.

    A valid pointer to a **mvIMPACT::acquire::Device** object is needed to construct most of the
    other objects available in this interface.

    Almost every object requiering a valid pointer to a **mvIMPACT::acquire::Device** object will
    need to device in an initialized state as the properties provided e.g. by the
    class **mvIMPACT::acquire::CameraSettingsBase** will be constructed when the device is initialized.
    To initialize a device this class provides the function **Device::open**.
    However every object which needs an initialized device to be constructed
    successfully will try to open the device when it hasn't been opened before, so
    the user does not need to call this function explicitly.


    Whenever a device is closed via a call to **mvIMPACT::acquire::Device::close**
    all other objects constructed with a pointer to that device(e.g. **mvIMPACT::acquire::CameraSettingsBase**
    before will become invalid and need to be reconstructed afterwards, so don't close a device needlessly.


    Whenever the last instance to a **DeviceManager** object gets
    destroyed within the current process every remaining device that was opened in this process before will
    be closed automatically!
    Thus every instance to **mvIMPACT::acquire::Device** objects or objects created with a pointer to a
    **mvIMPACT::acquire::Device** object will become invalid automatically.
    Therefore the user has to make sure there is always at least one instance to a
    **mvIMPACT::acquire::DeviceManager** object within the current process unless no more
    device access functions shall be called!
    """

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

    def __init__(self, src):
        r"""
        Copy constructor.
        Creates a new object from an existing device object. Keep in mind that this new object
        will provide access to the very same hardware and therefore you might as well use the original
        reference returned from the **mvIMPACT::acquire::DeviceManager**. This constructor
        is only provided for internal reference counting to guarantee correct operation of the
        objects of this class under all platforms and languages.
        """
        lib_mvIMPACT_acquire.Device_swiginit(self, lib_mvIMPACT_acquire.new_Device(src))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_Device

    def close(self):
        r"""
         Closes an opened device.
         This function closes a device previously opened again.


         Whenever a device is closed via a call to **mvIMPACT::acquire::Device::close**
         all other objects constructed with a pointer to that device(e.g. **mvIMPACT::acquire::CameraSettingsBase**
         before will become invalid and need to be reconstructed afterwards, so don't close a device needlessly.

         See also: 
         **Device::open**,
        **Device::isOpen**
        """
        return lib_mvIMPACT_acquire.Device_close(self)

    def hasCapability(self, capability):
        r"""
         Checks whether this device has a certain capability.
         Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDeviceCapability**.

         :rtype: boolean
         :return: 
             - true if the device has the capability in question
             - false otherwise.

        :type capability: int
        :param capability: [in] The capability who's presence shall be checked.
        """
        return lib_mvIMPACT_acquire.Device_hasCapability(self, capability)

    def hDev(self):
        r"""
        A unique identifier for this device.
        Notes: 
        This handle is **NOT** to be confused with the id stored in the devices EEPROM
        The latter one represents a number stored somewhere in the physical device's EEPROM, while
        this handle can be assumed as a handle from a software based point of view.
        """
        return lib_mvIMPACT_acquire.Device_hDev(self)

    def hDrv(self):
        r"""
        A unique identifier for the functionality offered by this device.

        Notes: 
        This identifier is only valid, if the device has been initialized
        before by a call to **Device::open**
        """
        return lib_mvIMPACT_acquire.Device_hDrv(self)

    def deviceDriverFeatureList(self):
        r"""
        Returns a list providing access to driver library specific features.
        This list does exist only once per device driver library. Changes in this list will affect all
        devices that are operated using this device driver library.

        Since: 2.17.0
        """
        return lib_mvIMPACT_acquire.Device_deviceDriverFeatureList(self)

    def getIsOpen(self):
        r"""
         Returns the current initialisation status in this process.
         If this function returns *true*, this only states that the current
         process has not opened the device in question already. A call to **mvIMPACT::acquire::Device::open()**
         can still fail because of some other process using this device.

         See also: 
         **Device::open**,
        **Device::close**
         :rtype: boolean
         :return: 
             - true if the device is initialized(opened) in the current process.
             - false otherwise.
        """
        return lib_mvIMPACT_acquire.Device_getIsOpen(self)

    def getIsInUse(self):
        r"""
         Returns the current usage status of this device.
         If this function returns *true*, this device was not in use at the time of calling this function.
         A call to **mvIMPACT::acquire::Device::open()** can still fail afterwards if some other process on the system
         claimed the device in the time between this call and the call to **mvIMPACT::acquire::Device::open()**.

         See also: 
         **Device::open**,
        **Device::close**

         Since: 2.0.11
         :rtype: boolean
         :return: 
             - true if the device is in use by at least one process(this includes the calling process).
             - false otherwise.
        """
        return lib_mvIMPACT_acquire.Device_getIsInUse(self)

    def open(self):
        r"""
        Opens a device.
        This function will try to open the device represented by this instance of
        **mvIMPACT::acquire::Device**. If this fails for any reason an exception will be thrown. The exception
        object will contain additional information about the reason for the error.

        Calling this function is not really necessary, as each object for accessing
        other settings of the device or even the function interface need the device to
        be opened in order to be constructed. Therefore all the constructors for these
        objects check if the device is open by calling **mvIMPACT::acquire::Device::isOpen** and open
        the device if necessary.

        Notes: 
        Keep in mind that the first object trying to open the device might therefore
        throw an exception as well if opening the device fails for some reason.

        Whenever a device is opened, the driver executes the following procedure:

         align="center"Image: src="./Device_Setting_Start_Procedure.png" alt="Device_Setting_Start_Procedure.png"
        Device setting start procedure

        Please have a look here ("el" href="../GUI_page_mvPropView.html") for more information about automatic loading of
        settings when a device is opened.
        """
        return lib_mvIMPACT_acquire.Device_open(self)

    def setID(self, newID):
        r"""
         Assigns a new ID to this device.
         To allow any application to distinguish between different devices of the same
         type the user can assign an unique ID to each device using this function. This ID
         currently is limited to values between 0 and 250 and is stored in the devices
         internal memory. This ID is **NOT** volatile. It will remain stored even if
         the device is unplugged.

         Notes: 
         **REMARKS**:

         - The device must be **closed** to assign a new ID.
         - This ID is not to be confused with the handle returned by the function **mvIMPACT::acquire::Device::hDev**.
         The latter one represents something which can be assumed as a handle from a software based point
         of view, while the ID represented by the property **mvIMPACT::acquire::Device::deviceID** is an ID stored in the physical
         devices EEPROM.
         - Not every device will offer this feature! When calling this function for a device that does not
         offer this feature, the function will return **mvIMPACT::acquire::DMR_FEATURE_NOT_AVAILABLE**.

         See also: 
         **mvIMPACT::acquire::Device::open**,
        **mvIMPACT::acquire::Device::close**
         :rtype: int
         :return: 
             - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
             - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.

        :type newID: int
        :param newID: [in] The new *ID* that shall be assigned to the device.
        """
        return lib_mvIMPACT_acquire.Device_setID(self, newID)

    def updateFirmware(self):
        r"""
         Updates the firmware of the device.
         Calling this function will cause the driver to download a firmware version compiled
         into the driver library into the devices non-volatile internal memory.

         Notes: 
         - This feature currently is only available for **mvBlueFOX** devices. To update the firmware of other devices please refer to the tool ``mvDeviceConfigure(this`` tool also offers a command line interface)
         - Be sure you know what you are doing **before** calling this function. Under normal circumstances
         it won't be necessary to update a devices firmware.
         - The download will take some time (depending on the device up to 30 seconds). During this time
         the device and the thread calling this function will **NOT** respond.
         - Do **NOT** interrupt this download.
         - After a successful download a USB device needs to be unplugged and plugged in again.
         Otherwise the new firmware version will not be activated.
         - To download a new firmware version the device must be **closed**.
         - Not every device will offer this feature! When calling this function for a device that does not
         offer this feature, the function will return **mvIMPACT::acquire::DMR_FEATURE_NOT_AVAILABLE**.

         See also: 
         **mvIMPACT::acquire::Device::open**,
        **mvIMPACT::acquire::Device::close**
         :rtype: int
         :return: 
             - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
             - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.
        """
        return lib_mvIMPACT_acquire.Device_updateFirmware(self)

    def getUserData(self):
        r"""
        Returns a reference to a helper class to handle user specific data stored in the devices non-volatile memory(if available).
        :rtype: :py:class:`UserData`
        :return: A reference to a helper class to handle user specific data stored in the devices
            non-volatile memory(if available).
        """
        return lib_mvIMPACT_acquire.Device_getUserData(self)

    def validateInterfaceLayout(self, requiredInterfaceLayout):
        r"""
        A convenience function mostly used internally. Raises an exception if the current value of **mvIMPACT::acquire::Device::interfaceLayout** does not match the value passed to the function.
        If a driver does not support the interface layout property this function does nothing!
        """
        return lib_mvIMPACT_acquire.Device_validateInterfaceLayout(self, requiredInterfaceLayout)
    deviceClass = property(lib_mvIMPACT_acquire.Device_deviceClass_get, doc=r"""
    An enumerated integer property **(read-only)** defining the device class this device belongs to.
    Notes: 
    This property has been added to the device driver in version 1.8.3 thus might not be available when
    working with old device drivers. Therefore always call the function **mvIMPACT::acquire::Component::isValid**
    to check if this property is available or not.
    """)
    family = property(lib_mvIMPACT_acquire.Device_family_get, doc=r""" A string property **(read-only)** containing the family name of this device.""")
    product = property(lib_mvIMPACT_acquire.Device_product_get, doc=r""" A string property **(read-only)** containing the product name of this device.""")
    capabilities = property(lib_mvIMPACT_acquire.Device_capabilities_get, doc=r"""
    An enumerated integer property **(read-only)** defining special device capabilities.
    This property stores certain device capabilities that can be read without opening the device.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDeviceCapability**.
    """)
    serial = property(lib_mvIMPACT_acquire.Device_serial_get, doc=r""" A string property **(read-only)** containing the serial number of this device.""")
    state = property(lib_mvIMPACT_acquire.Device_state_get, doc=r"""
    An enumerated integer property **(read-only)** containing the current state of this device.
    This property e.g. provides information about the current state of the device. For USB devices this can e.g. indicate whether
    a device is currently plugged into the system or not.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDeviceState**.

    **GenICam/GenTL** **device** **specific**:
    In order to reduce the amount of network traffic to a minimum, this property will only be updated automatically
    for network devices if the property **mvIMPACT::acquire::Device::registerErrorEvent** is set to
    **mvIMPACT::acquire::bTrue** (which is the default behaviour). If the IP addresses stay the same the
    connection is automatically re-established then once the device is detected by the driver again.
    However if the IP address of the device and/or the network adapter of the system it is used from changes
    **mvIMPACT::acquire::DeviceManager::updateDeviceList()**
    must be called regardless of the value of **mvIMPACT::acquire::Device::registerErrorEvent** before a device
    that was lost can re-establish a connection to the capture driver.
    Apart from that **ALL** **GenICam/GenTL** will only update this property automatically if the device is
    currently in use **BY** **THIS** **PROCESS**, so when the device has been opened. This is also to save
    bandwidth and resources!
    """)
    deviceID = property(lib_mvIMPACT_acquire.Device_deviceID_get, doc=r"""
    An integer property **(read-only)** containing the device ID associated with this device.
    A device ID can be used to identify a certain device in the system. The ID is an 8 bit unsigned
    integer value stored in the device's EEPROM. In order to allow the
    distinct detection of a device via its device ID, the user has to make sure that two devices
    belonging to the same product family never share the same ID.

    Notes: 
    **REMARKS**:

    - To modify the device ID a separate tool will be provided. To modify the device
    ID without that tool the function **mvIMPACT::acquire::Device::setID** can be called.
    - This ID is not to be confused with the handle returned by the function **mvIMPACT::acquire::Device::hDev**.
    The latter one represents something which can be assumed as a handle from a software based point
    of view, while the ID represented by the property *deviceID* is an ID stored in the physical
    devices EEPROM.
    """)
    deviceVersion = property(lib_mvIMPACT_acquire.Device_deviceVersion_get, doc=r"""
    A string property **(read-only)** containing the version(e.g. the hard ware revision) of this device.
    Notes: 
    This feature is supported by every device driver. If a device does not seem to support this feature (calling **mvIMPACT::acquire::Component::isValid** returns false)
    a driver update will fix this.
    """)
    firmwareVersion = property(lib_mvIMPACT_acquire.Device_firmwareVersion_get, doc=r"""
    An integer property **(read-only)** containing the firmware version of this device.
    A firmware is considered to be something that is stored in non volatile device memory, thus when a device
    is disconnected from the power supply and plugged into a different target system the same code will be executed
    on the device.

    Some devices however may not support non volatile memory to accommodate a firmware. Typically the device driver then will download
    a firmware into the devices RAM at startup. Such devices will be considered as not supporting a firmware as in this
    case only the driver version present on the target system has impact on the devices behaviour.

    When a device does not support a non volatile firmware, reading this property will always return 0.
    """)
    loadSettings = property(lib_mvIMPACT_acquire.Device_loadSettings_get, doc=r"""
    An enumerated integer property which can be used to define which previously stored setting to load when the device is opened.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDeviceLoadSettings**.

    Notes: 
    Once the device is in use (has been initialized) this property will become **(read-only)**.
    """)
    autoLoadSettingOrder = property(lib_mvIMPACT_acquire.Device_autoLoadSettingOrder_get, doc=r"""
    A string property **(read-only)** containing the auto load order of feature settings that is executed during initialisation of the device.
    The first setting detected on the system will be used.
    """)
    interfaceLayout = property(lib_mvIMPACT_acquire.Device_interfaceLayout_get, doc=r"""
    An enumerated integer property which can be used to define which interface layout shall be used when the device is opened.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDeviceInterfaceLayout**.

    Notes: 
    Once the device is in use (has been initialized) this property will become **(read-only)**.


    This feature is available for every device. A device not offering this feature requires a driver update. Always check
    for the availability of this feature by calling **mvIMPACT::acquire::Component::isValid**.

    Not every device will offer the same options.
    Check for valid modes by reading the properties translation dictionary with
    the functions **mvIMPACT::acquire::PropertyIDeviceInterfaceLayout::getTranslationDictString** and
    **mvIMPACT::acquire::PropertyIDeviceInterfaceLayout::getTranslationDictValue**.
    If: DOXYGEN_CPP_DOCUMENTATION {
    C++ offers the more efficient function **mvIMPACT::acquire::PropertyIDeviceInterfaceLayout::getTranslationDict**
    in addition to the functions mentioned above.
    }
    """)
    customDataDirectory = property(lib_mvIMPACT_acquire.Device_customDataDirectory_get, doc=r"""
     A string property **(read-only** once the device is open) containing a path to a custom directory for the location of camera description files, etc.
     When a custom path is assigned to this property this path will be used to locate certain driver specific files
     and folders. Under this folder the following structure must be created:

    .. code-block:: c++

         customDataDirectory
             |- CameraFiles  // this folder will be searched by frame grabbers for camera description files
             |- GenICam      // this folder will be searched by GenICam compliant devices that refer to a local GenICam description file

     If this property is left empty

    .. code-block:: c++

         %ALL USERS%/Documents/MATRIX VISION/mvIMPACT acquire
     will be used by default on Windows TM platforms and

    .. code-block:: c++

         /etc/matrix-vision/mvimpact-acquire
     on Linux platforms.
    """)
    defaultRequestCount = property(lib_mvIMPACT_acquire.Device_defaultRequestCount_get, doc=r"""
    An integer property that defines the number of **mvIMPACT::acquire::Request** objects to be created when the device is opened.
    By writing to this property an application can define the default number of **mvIMPACT::acquire::Request**
    objects that will be allocated when opening the device.

    Notes: 
    This property will become read-only while the device is open.

    See also: 
    **mvIMPACT::acquire::SystemSettings::requestCount** to change the number of request objects later and to find out why this parameter is important
    """)
    resultQueueCount = property(lib_mvIMPACT_acquire.Device_resultQueueCount_get, doc=r"""
     An integer property that defines the number of result queues to be created when the device is opened.
     By writing to this property an application can define the number of result queues that will be allocated
     when opening the device. When requesting buffers the user can define in which result queue a processed request shall
     end up by writing to the property **mvIMPACT::acquire::ImageRequestControl::resultQueue**. When waiting for a request to become ready by calling **mvIMPACT::acquire::FunctionInterface::imageRequestWaitFor**
     the application can specify on which queue to wait.

    If: DOXYGEN_CPP_DOCUMENTATION {

    .. code-block:: c++

        Device* pDev = getDevicePointerFromSomewhere();
        pDev-resultQueueCount.write( 2 );
        ImageRequestControl irc( pDev );
        FunctionInterface fi( pDev );
        irc.resultQueue.write( 0 );
        fi.imageRequestSingle( irc ); // request a buffer that will be stored in queue 0 when ready
        irc.resultQueue.write( 1 );
        fi.imageRequestSingle( irc ); // request a buffer that will be stored in queue 1 when ready
        fi.imageRequestWaitFor( 500, 0 ); // wait on queue 0
        fi.imageRequestWaitFor( 500, 1 ); // wait on queue 1
    }Else if: DOXYGEN_JAVA_DOCUMENTATION {

    .. code-block:: c++

        Device pDev = getDevicePointerFromSomewhere();
        pDev.getResultQueueCount().write( 2 );
        ImageRequestControl irc = new ImageRequestControl( pDev );
        FunctionInterface fi = new FunctionInterface( pDev );
        irc.getResultQueue().write( 0 );
        fi.imageRequestSingle( irc ); // request a buffer that will be stored in queue 0 when ready
        irc.getResultQueue().write( 1 );
        fi.imageRequestSingle( irc ); // request a buffer that will be stored in queue 1 when ready
        fi.imageRequestWaitFor( 500, 0 ); // wait on queue 0
        fi.imageRequestWaitFor( 500, 1 ); // wait on queue 1
    }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

    .. code-block:: c++

        pDev = getDeviceFromSomewhere()
        pDev.resultQueueCount.write(2)
        irc = ImageRequestControl(pDev)
        fi = FunctionInterface(pDev)
        irc.resultQueue.write(0)
        fi.imageRequestSingle(irc) # request a buffer that will be stored in queue 0 when ready
        irc.resultQueue.write(1)
        fi.imageRequestSingle(irc) # request a buffer that will be stored in queue 1 when ready
        fi.imageRequestWaitFor(500, 0) # wait on queue 0
        fi.imageRequestWaitFor(500, 1) # wait on queue 1
    }

    This can be useful e.g. when working with 2 different settings to sort all buffer capture with setting 0 into one queue
    and all the others into another queue.
     Notes: 
     This property will become read-only while the device is open.

    See also: 
    **mvIMPACT::acquire::ImageRequestControl::resultQueue**,

    **mvIMPACT::acquire::FunctionInterface::imageRequestWaitFor**
    """)
    userControlledImageProcessingEnable = property(lib_mvIMPACT_acquire.Device_userControlledImageProcessingEnable_get, doc=r"""
     An enumerated integer property defining whether user controlled image processing related features shall be created under 'System Settings' or not.
     Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.

     Setting this feature to **mvIMPACT::acquire::bTrue** will result in a separate thread being created when opening the
     device driver instance. The thread will decouple the host based image processing from the acquisition engine. Apart
     from that it will also create additional properties in the ``ImageProcessingControl`` list under ``SystemSettings`` that
     can be used to control the behaviour of this thread. This might be useful e.g. to make sure images can be acquired faster
     than they can be processed and it is not needed to processed each image.

     Notes: 
     This property will become read-only while the device is open.

    See also: 
    **mvIMPACT::acquire::SystemSettings::imageProcessingMode**

    **mvIMPACT::acquire::Request::hasProcessingBeenSkipped**

     Since: 2.14.0
    """)
    allowUnrecommendedFeatures = property(lib_mvIMPACT_acquire.Device_allowUnrecommendedFeatures_get, doc=r"""
    An enumerated integer property which can be used to unlock certain features, that are available but not recommended by the device manufacturer.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.

    This property will be invisible by default. As the name indicates its use requires special
    knowledge that can be provided by the device manufacturer on request.

    Notes: 
    Once the device is in use (has been initialized) this property will become **(read-only)**.


    Unlocking certain unrecommended features might result in the appearance of new translation
    dictionary entries for certain properties. Some of these translation strings might contain
    an exclamation mark ('!') in its name. **NEVER** rely on that! These exclamation marks
    or even the complete entry might disappear with a new driver release without further notice!
    """)
    acquisitionStartStopBehaviour = property(lib_mvIMPACT_acquire.Device_acquisitionStartStopBehaviour_get, doc=r"""
     An enumerated integer property defining the start/stop behaviour during acquisition of this driver instance.
     Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TAcquisitionStartStopBehaviour**.

     Notes: 
     This property will become read-only while the device is open.

     This property is not supported by every device.
     Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.

     Not every device will offer the same options.
     Check for valid modes by reading the properties translation dictionary with
     the functions **mvIMPACT::acquire::PropertyIAcquisitionStartStopBehaviour::getTranslationDictString** and
     **mvIMPACT::acquire::PropertyIAcquisitionStartStopBehaviour::getTranslationDictValue**.
     If: DOXYGEN_CPP_DOCUMENTATION {
     C++ offers the more efficient function **mvIMPACT::acquire::PropertyIAcquisitionStartStopBehaviour::getTranslationDict**
     in addition to the functions mentioned above.
     }

    Since: 1.12.11
    """)
    HWUpdateResult = property(lib_mvIMPACT_acquire.Device_HWUpdateResult_get, doc=r"""
    An enumerated integer property **(read-only)** defining user executed hardware update results.
    This property e.g. might contain the result of a user executed firmware update.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::THWUpdateResult**.
    """)
    manufacturer = property(lib_mvIMPACT_acquire.Device_manufacturer_get, doc=r"""
    A string property **(read-only)** containing the name of the manufacturer of this device.
    Notes: This property is not supported by every device.
    Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.

    Since: 2.11.3
    """)
    manufacturerSpecificInformation = property(lib_mvIMPACT_acquire.Device_manufacturerSpecificInformation_get, doc=r"""
    A string property **(read-only)** containing manufacturer specific information of this device.
    Notes: This property is not supported by every device.
    Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.

    Since: 2.18.3
    """)
    desiredAccess = property(lib_mvIMPACT_acquire.Device_desiredAccess_get, doc=r"""
    An enumerated integer property that can be used to define the desired access to the device when opening it.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDeviceAccessMode**.

    Notes: 
    This property will become read-only while the device is open.

    This property is not supported by every device.
    Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.
    """)
    grantedAccess = property(lib_mvIMPACT_acquire.Device_grantedAccess_get, doc=r"""
    An enumerated integer property **(read-only)** that can be used to query the granted access to the device after an attempt to open it.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDeviceAccessMode**.

    Notes: This property is not supported by every device.
    Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.
    """)
    autoNegotiatePacketSize = property(lib_mvIMPACT_acquire.Device_autoNegotiatePacketSize_get, doc=r"""
     An enumerated integer property which can be used to enable or disable the MTU auto negotiation of a GigE Vision device when opening it.
    If set to true, the driver will try to determine the max. possible packet size during init, which if successful will result in optimal performance.
     Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.

     Notes: Once the device is in use (has been initialized) this property will become **(read-only)**. If this feature is disabled even before the device has been opened a
     firmware update is needed to use it when accessed via the ``mvGenTLProducer-lib``. When using a 3rd party GenTL producer to access the GigE Vision device this
     feature will not be available.

     This property might not supported by every device. Therefore always call the function
     **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.
    """)
    autoNegotiatePacketSizeMode = property(lib_mvIMPACT_acquire.Device_autoNegotiatePacketSizeMode_get, doc=r"""
    An enumerated integer property **(read-only)** that can be used to define how the auto packet size negotiation for a GigE Vision device is handled.
    If set to **mvIMPACT::acquire::danpsmHighToLow** the MTU is automatically negotiated starting from the NICs current MTU down to a value supported by all components belonging to the network path
    (device, network interface card, switches, ...), if set to **mvIMPACT::acquire::danpsmLowToHigh** the negotiation starts with the small value tries larger values with each iteration until the
    optimal value has been found.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDeviceAutoNegotiatePacketSizeMode**.

    Notes: Once the device is in use (has been initialized) this property will become **(read-only)**. When using a 3rd party GenTL producer to access the GigE Vision device this
    feature will not be available.

    This property might not supported by every device. Therefore always call the function
    **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.
    """)

    r""" \brief A bool property \b (read-only) which checks the current initialisation status in this process. See mvIMPACT.acquire.Device.getIsOpen() """
    isOpen = property (getIsOpen, None, None, None)
    r""" \brief A bool property \b (read-only) which checks the current usage status of this device. See mvIMPACT.acquire.Device.getIsInUse() """
    isInUse = property (getIsInUse, None, None, None)
    r""" \brief An integer property \b which assigns a new ID to this device. See mvIMPACT.acquire.Device.setID() """
    ID = property (None, setID, None, None)
    r""" \brief A property \b (read-only) which returns a reference to a helper class to handle user specific data stored in the devices non-volatile memory(if available). See mvIMPACT.acquire.Device.getUserData() """
    userData = property (getUserData, None, None, None)


# Register Device in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.Device_swigregister(Device)

class DeviceManager(object):
    r"""
     Grants access to devices that can be operated by this software interface.
     This class will grant access to any device installed on/in the
     current system. Whenever somewhere in the code a **mvIMPACT::acquire::DeviceManager** instance is
     created it can be used to access any device currently
     supported and available.

    This is the only class which is allowed to
     create instances of the class **mvIMPACT::acquire::Device**, which are needed to access a certain
     device.

     Notes: 
     **There always has to be at least one instance of the mvIMPACT::acquire::DeviceManager when
     the user still works with **mvIMPACT::acquire::Device** objects!** When the last instance to
     this object is destroyed all remaining **mvIMPACT::acquire::Device** objects will be closed
     automatically and every device driver will be unloaded from the current process memory!

     If a device is installed in the system but an appropriate driver has not been installed, this class
     will **NOT** list these devices.

     As a result of this every program written by the use of this interface
     will create an instance of **mvIMPACT::acquire::DeviceManager** before performing any other
     operations which uses objects or functions from this interface.

     During the construction of a **mvIMPACT::acquire::DeviceManager** object the system will be scanned
     for supported devices and once the instance has been created the object will
     provide an up to date list of devices whenever the user asks for it. Some devices when plugged into
     the system after the device manager has been created might require an explicit update of the device
     list. This can be triggered by an application by calling **mvIMPACT::acquire::DeviceManager::updateDeviceList()**.
     When there is currently no **mvIMPACT::acquire::DeviceManager** instance within the process creating
     the first one will result in all supported driver stacks to be loaded dynamically. See remarks below for
     consequences that result from this.

     This class also provides various functions to find a particular device in the system.
     Devices can e.g. be found by family or by serial number.


     **NEVER** try to explicitly delete an instance of **mvIMPACT::acquire::Device!** You did not allocate it
     and the result will be a crash! The **mvIMPACT::acquire::DeviceManager** will take care of all resources
     for you.


     A **mvIMPACT::acquire::DeviceManager** object will initially return pointers to **mvIMPACT::acquire::Device** objects,
     which all seem to be closed. However one or more of the devices might have been opened
     by another instance of the device manager running in a different
     process. In that case the attempt to open a device, which seems to be closed will raise
     an exception with the error code **mvIMPACT::acquire::DMR_DRV_ALREADY_IN_USE**, which MUST
     be handled by the user.


     **NEVER** declare a global instance of this class within a dynamic library(*.dll, *.so, *.ocx, ...), as creating
     this instance will result in other shared libraries to be loaded dynamically by the framework. If you do, applications
     using your library might lock up because global objects might be constructed from (Windows) the ``DllMain`` context
     and loading other libraries from within ``DllMain`` is discouraged (see ``DllMain`` ``Best`` ``Practices`` in MSDN for
     example). Instead either attach your instance of the device manager to a singleton, declare a global pointer that gets
     initialised/destroyed by custom library init/close functions or use any other approach that suits your needs.

     **EXAMPLE** CODE:

     If: DOXYGEN_CPP_DOCUMENTATION {

     .. code-block:: c++

         //-----------------------------------------------------------------------------
         void obtainDevicePointers( void )
         //-----------------------------------------------------------------------------
         {
           // Create an instance of the device manager to get access
           // to supported devices.
           DeviceManager devMgr;

           // show all devices
           for( unsigned int i=0; idevMgr.deviceCount(); i++ )
           {
             cout < "Dev " < i < ": " < *(devMgr[i]) < endl;
           }

           // try to find a device using a special criteria
           // ( some of these calls will fail!!! )
           // will fail as the string is not complete and does
           // NOT terminate with a wildcard.
           Device* pDev = devMgr.getDeviceBySerial( "SD0*0" );
           // might work if there are at least two devices with
           // a matching serial number in the system.
           pDev = devMgr.getDeviceByFamily( "SD0*0*", 1 );
           // might work if there is at least one device whose type
           // specifying string starts with 'SampleDevi'.
           pDev = devMgr.getDeviceByProduct( "SampleDevi*" );
           // will fail as the string is not complete and does NOT
           // terminate with the user defined wildcard.
           pDev = devMgr.getDeviceByProduct( "SampleD*", 0, '$' );
           // will work if there is a device whose product name
           // starts with 'SamplePro' and which has
           // been assigned the specified device ID.
           pDev = devMgr.getDeviceByProductAndID( "SamplePro*", 66, '*' );
           // will work if there is a device whose product name
           // starts with 'SamplePro' and which has
           // been assigned the specified string device ID.
           pDev = devMgr.getDeviceByProductAndID( "SamplePro*","sampleID", '*' );
           // will work if there is at least one device with a serial
           // number starting with 'SD00' in the system.
           pDev = devMgr.getDeviceBySerial( "SD00*" );
           // will return a pointer to the first device detected thus
           // this call will work if there is at least one device in the
           // current system that is supported by this interface
           pDev = devMgr.getDeviceBySerial( "*" );
           if( !pDev )
           {
             cout < "Error! No valid device found" < endl;
             return 0;
           }

           // from here it will be save to work with the pointer returned
           // by device manager.
           // THE NEXT LINE WILL TRY TO OPEN THE DEVICE! This can fail if the device
           // is already running in a different process!
           try
           {
             FunctionInterface func(pDev);
             // do some work
           }
           catch( const ImpactAcquireException e )
           {
             // failed to open the device...
           }
         }

         //-----------------------------------------------------------------------------
         void showDeviceManagerOperation( void )
         //-----------------------------------------------------------------------------
         {
           Device* pDev = 0;
           {
             DeviceManager devMgr1;
             // will return a pointer to the first device detected thus
             // this call will work if there is at least one device in the
             // current system that is supported by this interface
             pDev = devMgr.getDeviceBySerial( "*" );
             if( !pDev )
             {
               cout < "Error! No valid device found" < endl;
               return;
             }
             // from here it will be save to work with the pointer returned
             // by device manager.
             // THE NEXT LINE WILL TRY TO OPEN THE DEVICE! This can fail if the device
             // is already running in a different process!
             try
             {
               FunctionInterface func( pDev );
               // do some work
             }
             catch( const ImpactAcquireException e )
             {
               // failed to open the device...
             }
             {
               DeviceManager devMgr2;
               // This will return the same device as pDev
               Device* pDev2 = devMgr2.getDeviceBySerial( "*" );
             } // here the device manager devMgr2 will be destroyed, but it will NOT close pDev2, as devMgr1 holds a reference to it
             Statistics s( pDev ); // this will still work
           } // here the last device manager will be destroyed, thus from here onwards pDev will be invalid!
           Info i( pDev ); // this will crash
           DeviceManager devMgr3;
           Info i2( devMgr3.getDevice( 0 ) ); // this will work again
         }
     }Else if: DOXYGEN_JAVA_DOCUMENTATION {

     .. code-block:: c++

         //-----------------------------------------------------------------------------
         public static void showDeviceManagerOperation()
         //-----------------------------------------------------------------------------
         {
           Device pDev = null;
           {
             DeviceManager devMgr = new DeviceManager();
             // will return a pointer to the first device detected thus
             // this call will work if there is at least one device in the
             // current system that is supported by this interface
             pDev = devMgr.getDeviceBySerial( "*" );
             if( pDev == null )
             {
               System.out.print( "No valid device found!" );
               mvIMPACT.acquire.examples.helper.DeviceAccess.waitForENTER();
               System.exit( 1 );
             }

             // from here it will be save to work with the pointer returned
             // by device manager.
             // THE NEXT LINE WILL TRY TO OPEN THE DEVICE! This can fail if the device
             // is already running in a different process!
             try
             {
               FunctionInterface fi = new FunctionInterface( pDev );
               // do some work
             }
             catch( ImpactAcquireException e )
             {
               // this e.g. might happen if the same device is already opened in another process...
               System.out.println( "An error occurred while opening device " + pDev.getSerial().read() +
                                   "(error code: " + e.getMessage() + ")." );
               System.exit( 1 );
             }
             {
               DeviceManager devMgr2 = new DeviceManager();
               // This will return the same device as pDev
               Device pDev2 = devMgr.getDeviceBySerial( "*" );
             }
             // after the next line the device manager devMgr2 will be destroyed, but it will NOT close pDev2, as devMgr holds a reference to it
             System.gc();
             Statistics s = new Statistics( pDev ); // this will still work
           }
         }
     }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

     .. code-block:: c++

         def obtainDeviceReferences():
             # Create an instance of the device manager to get access
             # to supported devices.
             devMgr = acquire.DeviceManager()

             # show all devices
             for i in range(devMgr.deviceCount()):
                 print("Dev " + str(i) + ": " + str(devMgr[i]))

             # try to find a device using a special criteria
             # ( some of these calls will fail!!! )
             # will fail as the string is not complete and does
             # NOT terminate with a wildcard.
             pDev = devMgr.getDeviceBySerial("SD0*0")
             # might work if there are at least two devices with
             # a matching serial number in the system.
             pDev = devMgr.getDeviceByFamily("SD0*0*", 1)
             # might work if there is at least one device whose type
             # specifying string starts with 'SampleDevi'.
             pDev = devMgr.getDeviceByProduct("SampleDevi*")
             # will fail as the string is not complete and does NOT
             # terminate with the user defined wildcard.
             pDev = devMgr.getDeviceByProduct("SampleD*", 0, '$')
             # will work if there is a device whose product name
             # starts with 'SamplePro' and which has
             # been assigned the specified device ID.
             pDev = devMgr.getDeviceByProductAndID("SamplePro*", 66, '*')
             # will work if there is a device whose product name
             # starts with 'SamplePro' and which has
             # been assigned the specified string device ID.
             pDev = devMgr.getDeviceByProductAndID("SamplePro*","sampleID", '*')
             # will work if there is at least one device with a serial
             # number starting with 'SD00' in the system.
             pDev = devMgr.getDeviceBySerial("SD00*")
             # will return a pointer to the first device detected thus
             # this call will work if there is at least one device in the
             # current system that is supported by this interface
             pDev = devMgr.getDeviceBySerial("*")
             if not pDev:
                 print("Error! No valid device found")

             # from here it will be save to work with the pointer returned
             # by device manager.
             # THE NEXT LINE WILL TRY TO OPEN THE DEVICE! This can fail if the device
             # is already running in a different process!
             try:
                 func = acquire.FunctionInterface(pDev);
                 # do some work
             except Exception as e:
                 # failed to open the device...
                 print("failed to open the device...")
     }
    """

    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"""
        *Overload 1:*
        Constructs a new **mvIMPACT::acquire::DeviceManager** object.
        If the construction of this object fails for some reason this constructor
        might throw an exception of type **mvIMPACT::acquire::ImpactAcquireException** or a type
        derived from this class.

        |

        *Overload 2:*
        Constructs a new **mvIMPACT::acquire::DeviceManager** object from an existing one.
        If the construction of this object fails for some reason this constructor
        might throw an exception of type **mvIMPACT::acquire::ImpactAcquireException** or a type
        derived from this class.
        """
        lib_mvIMPACT_acquire.DeviceManager_swiginit(self, lib_mvIMPACT_acquire.new_DeviceManager(*args))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_DeviceManager

    @staticmethod
    def getVersionAsString(libraryQuery):
        r"""
         Returns a string containing the version number of the specified library.
         This function returns a string containing the version number of the specified library.

         The format of the string will be MAJOR.MINOR.RELEASE.BUILD.
         Since: 2.1.2
         :rtype: string
         :return: A pointer to an internal version string.

        :type libraryQuery: int
        :param libraryQuery: [in] Specifies the library to query information from.
        """
        return lib_mvIMPACT_acquire.DeviceManager_getVersionAsString(libraryQuery)

    def getInternalHandle(self):
        r""" Returns the internal handle to the device manager created via **DMR_Init()**."""
        return lib_mvIMPACT_acquire.DeviceManager_getInternalHandle(self)

    def changedCount(self):
        r"""
        Returns the current changed counter for the device list.
        This is a useful function to find out if the device list has been changed in any
        way. Such a change might be the appearance of a new USB device or a state change
        of any other device (e.g. when a USB device has been unplugged). Thus this function
        can be called periodically in order to maintain lists in GUI application for example.
        To find out the actual number of devices call **mvIMPACT::acquire::DeviceManager::deviceCount**.
        :rtype: int
        :return: The current changed counter for the device list.
        """
        return lib_mvIMPACT_acquire.DeviceManager_changedCount(self)

    def deviceCount(self):
        r"""
        Returns the number of devices currently present in the system.
        This function returns the number of devices currently detected in the system. A
        device once connected to the system while the device manager was running will remain
        in its list even if it's unplugged (then only its state will change). To detect
        changes in the **mvIMPACT::acquire::DeviceManager** objects list call the function
        **mvIMPACT::acquire::DeviceManager::changedCount**.
        :rtype: int
        :return: The number of devices detected in the current system.
        """
        return lib_mvIMPACT_acquire.DeviceManager_deviceCount(self)

    def updateDeviceList(self):
        r"""
        Updates the internal device list.
        Most devices can't appear out of nowhere. For example a PCI device is
        either connected to the current system when the device manager is initialized
        or not but it will never appear at runtime after this instance of **mvIMPACT::acquire::DeviceManager**
        has been created.

        However certain device classes (e.g. network devices) might be connected to
        the system **AFTER** the device manager has been initialized. Some will announce themselves
        like e.g. USB devices, which will send a message to every application interested while others
        like e.g. network devices wont. In order not to
        pollute the network or bus with constant rescan messages no polling is done inside the driver.
        the user should call this function instead when looking for new devices. This can either be done in reasonable intervals or after
        it is known that a new device has been connected to the system.

        If new devices have been detected a subsequent call to **mvIMPACT::acquire::DeviceManager::deviceCount**
        will result in a higher value when compared to a previous call and **mvIMPACT::acquire::DeviceManager::changedCount**
        will contain a different value as well then (however this could also happen because a certain device related property did change
        its state).

        Notes: 
        As long as a certain instance of a device manager is active, the devices once detected will **NOT**
        disappear from the list of devices even if they have been unplugged from the system. So the list
        of devices can only grow, but never gets shorter again until either the process terminates or the
        last instance of this class went out of scope. If a device has been unplugged, its **mvIMPACT::acquire::Device::state**
        property will change. If the application is interested in getting an instant notification when a
        device has been disconnected a callback can be registered on this property. How to do this is explained
        here: 'Callback.cpp'
        """
        return lib_mvIMPACT_acquire.DeviceManager_updateDeviceList(self)

    def getDevice(self, index):
        r"""
         Returns a pointer to a **mvIMPACT::acquire::Device** object.
         Returns a pointer to a **mvIMPACT::acquire::Device** object specifying the device found at the given
         index in the device managers internal list.
         If: DOXYGEN_CPP_DOCUMENTATION {
         If the index is either equal or higher than the number of devices detected
         a STL out_of_range exception will be thrown.
         }

         See also: 
         **DeviceManager::deviceCount**,

         **DeviceManager::getDeviceBySerial**,

         **DeviceManager::getDeviceByFamily**,

         **DeviceManager::getDeviceByProduct**
         :rtype: :py:class:`Device`
         :return: 
             - A pointer to the device if *index* specifies a valid value.

             - an exception will be raised otherwise.

        :type index: int
        :param index: [in] The index of the device to be returned.
        """
        return lib_mvIMPACT_acquire.DeviceManager_getDevice(self, index)

    def getDeviceBySerial(self, *args):
        r"""
         Tries to locate a device via the serial number.
         This function tries to find a device by its serial number (or parts of this number).
         The user can specify only parts of the serial number and a wildcard. The **mvIMPACT::acquire::DeviceManager**
         object will then try to find that matches these parameters in its current list.

        If: DOXYGEN_CPP_DOCUMENTATION {

        .. code-block:: c++

             DeviceManager devMgr;
             // this will return a pointer to the second device with
             // a serial number starting with 'SD' device found or 0
             // if there are no 2 sample devices in the system
             devMgr.getDeviceBySerial( "SD*******", 1, '*' );
             // will return a pointer to the device with the serial
             // number SD000001 if present or 0
             devMgr.getDeviceBySerial( "SD0000001" );
             // will return a pointer to the first device in the system
             devMgr.getDeviceBySerial( "*", 0, '*' );
        }Else if: DOXYGEN_JAVA_DOCUMENTATION {

        .. code-block:: c++

             DeviceManager devMgr = new DeviceManager();
             // this will return a pointer to the second device with
             // a serial number starting with 'SD' device found or 0
             // if there are no 2 sample devices in the system
             devMgr.getDeviceBySerial( "SD*******", 1, '*' );
             // will return a pointer to the device with the serial
             // number SD000001 if present or 0
             devMgr.getDeviceBySerial( "SD0000001" );
             // will return a pointer to the first device in the system
             devMgr.getDeviceBySerial( "*", 0, '*' );
        }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

        .. code-block:: c++

             devMgr = acquire.DeviceManager()
             # this will return a reference to the second device with
             # a serial number starting with 'SD' device found or 0
             # if there are no 2 sample devices in the system
             devMgr.getDeviceBySerial("SD*******", 1, '*')
             # will return a reference to the device with the serial
             # number SD000001 if present or 0
             devMgr.getDeviceBySerial("SD0000001")
             # will return a reference to the first device in the system
             devMgr.getDeviceBySerial("*", 0, '*')
        }

         See also: 
         **DeviceManager::getDeviceByFamily**,

         **DeviceManager::getDeviceByProduct**,

         **DeviceManager::getDeviceByProductAndID**
         :rtype: :py:class:`Device`
         :return: 
             - A pointer to the device if found.

             - an invalid pointer or reference otherwise.

        :type serial: string
        :param serial: [in] The full serial number or the known parts of the serial number and wildcard characters.
        :type devNr: int
        :param devNr: [in] The number of the device to return (if there is more than one candidate).
        :type wildcard: char
        :param wildcard: [in] The character to ignore in *serial*.
        """
        return lib_mvIMPACT_acquire.DeviceManager_getDeviceBySerial(self, *args)

    def getDeviceByFamily(self, *args):
        r"""
         Tries to locate a device via the family name.
         This function tries to find a device by its family (or parts of this family name).
         The user can specify only parts of the family name and a wildcard. The **mvIMPACT::acquire::DeviceManager**
         object will then try to find the device that matches these parameters in its current list.
         The family is the most general method of searching for a device apart from 'any device'.
         E.g. for a device the family name might be 'SampleDevice'

        If: DOXYGEN_CPP_DOCUMENTATION {

        .. code-block:: c++

             DeviceManager devMgr;
             // this will return a pointer to the second 'SampleDevice'
             // device found or 0 if there are no 2 'SampleDevice'
             // devices in the system
             devMgr.getDeviceByFamily( "SampleD*", 1, '*' );
             // will return a pointer to the first device belonging
             // to the 'SampleDevice' family if present or 0.
             devMgr.getDeviceByFamily( "SampleDevice" );
             // will return the first recognized device in the system
             devMgr.getDeviceByFamily( "*", 0, '*' );
        }Else if: DOXYGEN_JAVA_DOCUMENTATION {

        .. code-block:: c++

             DeviceManager devMgr = new DeviceManager();
             // this will return a pointer to the second 'SampleDevice'
             // device found or 0 if there are no 2 'SampleDevice'
             // devices in the system
             devMgr.getDeviceByFamily( "SampleD*", 1, '*' );
             // will return a pointer to the first device belonging
             // to the 'SampleDevice' family if present or 0.
             devMgr.getDeviceByFamily( "SampleDevice" );
             // will return the first recognized device in the system
             devMgr.getDeviceByFamily( "*", 0, '*' );
        }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

        .. code-block:: c++

             devMgr = acquire.DeviceManager()
             # this will return a reference to the second 'SampleDevice'
             # device found or 0 if there are no 2 'SampleDevice'
             # devices in the system
             devMgr.getDeviceByFamily("SampleD*", 1, '*')
             # will return a reference to the first device belonging
             # to the 'SampleDevice' family if present or 0.
             devMgr.getDeviceByFamily("SampleDevice")
             # will return the first recognized device in the system
             devMgr.getDeviceByFamily("*", 0, '*')
        }

         See also: 
         **mvIMPACT::acquire::DeviceManager::getDeviceBySerial**,

         **mvIMPACT::acquire::DeviceManager::getDeviceByProduct**,

         **mvIMPACT::acquire::DeviceManager::getDeviceByProductAndID**
         :rtype: :py:class:`Device`
         :return: 
             - A pointer to the device if found.

             - an invalid pointer or reference otherwise.

        :type family: string
        :param family: [in] The full family name of the requested device or known parts of it and wildcard characters.
        :type devNr: int
        :param devNr: [in] The number of the device to return (if there is more than one candidate).
        :type wildcard: char
        :param wildcard: [in] The character to ignore in *family*.
        """
        return lib_mvIMPACT_acquire.DeviceManager_getDeviceByFamily(self, *args)

    def getDeviceByProduct(self, *args):
        r"""
         Tries to locate a device via the product name.
         This function tries to find a device by its product name (or parts of it).
         The user can specify only parts of the name and a wildcard. The **mvIMPACT::acquire::DeviceManager**
         object will then try to find the device that matches these parameters in its current list.
         The product name is a bit more specific than the family name, but less specific than
         the serial. For the 'SampleDevice' for example there might be different product names for different
         device types. This might e.g. be 'SampleDevice-G' for a grey version of the sample device and
         'SampleDevice-C' for the color version of the sample device.

        If: DOXYGEN_CPP_DOCUMENTATION {

        .. code-block:: c++

             DeviceManager devMgr;
             // this will return a pointer to the second sample
             // device of type 'G' found or 0 if there aren't
             // two devices of this type in the system
             devMgr.getDeviceByProduct( "SampleDevice-G", 1 );
             // will return a pointer to the first device whose
             // product string starts with 'SampleDev' or 0 if
             // no such device can be found.
             devMgr.getDeviceByProduct( "SampleDev*", 0, '*' );
             // will return the first recognized device in the system
             devMgr.getDeviceByProduct( "*", 0, '*' );
        }Else if: DOXYGEN_JAVA_DOCUMENTATION {
         DeviceManager devMgr = new DeviceManager();
         // this will return a pointer to the second sample
         // device of type 'G' found or 0 if there aren't
         // two devices of this type in the system
         devMgr.getDeviceByProduct( "SampleDevice-G", 1 );
         // will return a pointer to the first device whose
         // product string starts with 'SampleDev' or 0 if
         // no such device can be found.
         devMgr.getDeviceByProduct( "SampleDev*", 0, '*' );
         // will return the first recognized device in the system
         devMgr.getDeviceByProduct( "*", 0, '*' );

        .. code-block:: c++

        }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

        .. code-block:: c++

             devMgr = acquire.DeviceManager()
             # this will return a reference to the second sample
             # device of type 'G' found or 0 if there aren't
             # two devices of this type in the system
             devMgr.getDeviceByProduct("SampleDevice-G", 1)
             # will return a reference to the first device whose
             # product string starts with 'SampleDev' or 0 if
             # no such device can be found.
             devMgr.getDeviceByProduct("SampleDev*", 0, '*')
             # will return the first recognized device in the system
             devMgr.getDeviceByProduct("*", 0, '*')
        }

         See also: 
         **DeviceManager::getDeviceBySerial**,

         **DeviceManager::getDeviceByFamily**,

         **DeviceManager::getDeviceByProductAndID**
         :rtype: :py:class:`Device`
         :return: 
             - A pointer to the device if found.

             - an invalid pointer or reference otherwise.

        :type product: string
        :param product: [in] The full product name of the requested device or known parts of it and wildcard characters.
        :type devNr: int
        :param devNr: [in] The number of the device to return (if there is more than one candidate).
        :type wildcard: char
        :param wildcard: [in] The character to ignore in *product*.
        """
        return lib_mvIMPACT_acquire.DeviceManager_getDeviceByProduct(self, *args)

    def getDeviceByProductAndID(self, *args):
        r"""
        *Overload 1:*
         Tries to locate a device via the product name and the device ID.
         This function behaves like
         **mvIMPACT::acquire::DeviceManager::getDeviceByProduct**
         except that the second parameter now is interpreted as the device ID.

        If: DOXYGEN_CPP_DOCUMENTATION {

        .. code-block:: c++

             DeviceManager devMgr;
             // this will return a pointer to the sample device of
             // type 'G' which has been assigned a device ID of '1'
             // or 0 if there is no sample device with this ID in the system.
             devMgr.getDeviceByProductAndID( "SampleDevice-G", 1 );
             // will return a pointer to the device whose product string
             // starts with 'SampleDev' and whose device ID has been set
             // to '0' or 0 if no such device can be found.
             devMgr.getDeviceByProductAndID( "SampleDev*", 0, '*' );
             // will return the first recognized device with an assigned
             // device ID of '0' in the system.
             devMgr.getDeviceByProductAndID( "*", 0 );
        }Else if: DOXYGEN_JAVA_DOCUMENTATION {

        .. code-block:: c++

             DeviceManager devMgr = new DeviceManager();
             // this will return a pointer to the sample device of
             // type 'G' which has been assigned a device ID of '1'
             // or 0 if there is no sample device with this ID in the system.
             devMgr.getDeviceByProductAndID( "SampleDevice-G", 1 );
             // will return a pointer to the device whose product string
             // starts with 'SampleDev' and whose device ID has been set
             // to '0' or 0 if no such device can be found.
             devMgr.getDeviceByProductAndID( "SampleDev*", 0, '*' );
             // will return the first recognized device with an assigned
             // device ID of '0' in the system.
             devMgr.getDeviceByProductAndID( "*", 0 );
        }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

        .. code-block:: c++

             devMgr = acquire.DeviceManager()
             # this will return a reference to the sample device of
             # type 'G' which has been assigned a device ID of '1'
             # or 0 if there is no sample device with this ID in the system.
             devMgr.getDeviceByProductAndID("SampleDevice-G", 1)
             # will return a reference to the device whose product string
             # starts with 'SampleDev' and whose device ID has been set
             # to '0' or 0 if no such device can be found.
             devMgr.getDeviceByProductAndID("SampleDev*", 0, '*')
             # will return the first recognized device with an assigned
             # device ID of '0' in the system.
             devMgr.getDeviceByProductAndID("*", 0)
        }

         See also: 
         **Device::deviceID**,

         **DeviceManager::getDeviceByFamily**,

         **DeviceManager::getDeviceByProduct**,

         **DeviceManager::getDeviceBySerial**,

         **Device::setID**
         :rtype: :py:class:`Device`
         :return: 
             - A pointer to the device if found.

             - an invalid pointer or reference otherwise.

        :type product: string
        :param product: [in] The full product name of the requested device or known parts of it and wildcard characters.
        :type devID: int
        :param devID: [in] The ID associated with this device.
        :type wildcard: char
        :param wildcard: [in] The character to ignore in *product*.

        |

        *Overload 2:*
         Tries to locate a device via the product name and the device ID.
         This function can be used to locate devices with a certain string identifier that has previously been written into a devices non-volatile
         memory. E.g. GenICam devices may support the ``DeviceUserID`` feature to assign a certain user defined name. A user defined
         name might be useful e.g. to access a device with a certain function without the need to worry about which device is it. You could
         e.g. have a ``barcodeReadingDevice`` and a ``monitorCamera``.
         This function behaves like **mvIMPACT::acquire::DeviceManager::getDeviceByProduct**
         except that the second parameter now is interpreted as the device ID.

        If: DOXYGEN_CPP_DOCUMENTATION {

        .. code-block:: c++

             DeviceManager devMgr;
             // this will return a pointer to the sample device of
             // type 'G' which has been assigned a device ID of 'abc'
             // or 0 if there is no sample device with this ID in the system.
             devMgr.getDeviceByProductAndID( "SampleDevice-G", "abc" );
             // will return a pointer to the device whose product string
             // starts with 'SampleDev' and whose device ID has been set
             // to 'def' or 0 if no such device can be found.
             devMgr.getDeviceByProductAndID( "SampleDev*", "def", '*' );
             // will return the first recognized device with an assigned
             // device ID of 'anyString' in the system.
             devMgr.getDeviceByProductAndID( "*", "anyString" );
        }Else if: DOXYGEN_JAVA_DOCUMENTATION {

        .. code-block:: c++

             DeviceManager devMgr = new DeviceManager();
             // this will return a pointer to the sample device of
             // type 'G' which has been assigned a device ID of 'abc'
             // or 0 if there is no sample device with this ID in the system.
             devMgr.getDeviceByProductAndID( "SampleDevice-G", "abc" );
             // will return a pointer to the device whose product string
             // starts with 'SampleDev' and whose device ID has been set
             // to 'def' or 0 if no such device can be found.
             devMgr.getDeviceByProductAndID( "SampleDev*", "def", '*' );
             // will return the first recognized device with an assigned
             // device ID of 'anyString' in the system.
             devMgr.getDeviceByProductAndID( "*", "anyString" );
        }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

        .. code-block:: c++

             devMgr = acquire.DeviceManager()
             # this will return a reference to the sample device of
             # type 'G' which has been assigned a device ID of 'abc'
             # or 0 if there is no sample device with this ID in the system.
             devMgr.getDeviceByProductAndID("SampleDevice-G", "abc")
             # will return a reference to the device whose product string
             # starts with 'SampleDev' and whose device ID has been set
             # to 'def' or 0 if no such device can be found.
             devMgr.getDeviceByProductAndID("SampleDev*", "def", '*')
             # will return the first recognized device with an assigned
             # device ID of 'anyString' in the system.
             devMgr.getDeviceByProductAndID("*", "anyString")
        }

         See also: 
         **Device::deviceID**,

         **DeviceManager::getDeviceByFamily**,

         **DeviceManager::getDeviceByProduct**,

         **DeviceManager::getDeviceBySerial**,

         **Device::setID**
         :rtype: :py:class:`Device`
         :return: 
             - A pointer to the device if found.

             - an invalid pointer or reference otherwise.

        :type product: string
        :param product: [in] The full product name of the requested device or known parts of it and wildcard characters.
        :type devID: string
        :param devID: [in] The device ID associated with this device.
        :type wildcard: char
        :param wildcard: [in] The character to ignore in *product*.

        |

        *Overload 3:*
         Tries to locate a device via the product name and the device ID.
         This function can be used to locate devices with a certain string identifier that has previously been written into a devices non-volatile
         memory. E.g. GenICam devices may support the ``DeviceUserID`` feature to assign a certain user defined name. A user defined
         name might be useful e.g. to access a device with a certain function without the need to worry about which device is it. You could
         e.g. have a ``barcodeReadingDevice`` and a ``monitorCamera``.
         This function behaves like **mvIMPACT::acquire::DeviceManager::getDeviceByProduct**
         except that the second parameter now is interpreted as the device ID.

        If: DOXYGEN_CPP_DOCUMENTATION {

        .. code-block:: c++

             DeviceManager devMgr;
             // this will return a pointer to the sample device of
             // type 'G' which has been assigned a device ID of 'abc'
             // or 0 if there is no sample device with this ID in the system.
             devMgr.getDeviceByProductAndID( "SampleDevice-G", "abc" );
             // will return a pointer to the device whose product string
             // starts with 'SampleDev' and whose device ID has been set
             // to 'def' or 0 if no such device can be found.
             devMgr.getDeviceByProductAndID( "SampleDev*", "def", '*' );
             // will return the first recognized device with an assigned
             // device ID of 'anyString' in the system.
             devMgr.getDeviceByProductAndID( "*", "anyString" );
        }Else if: DOXYGEN_JAVA_DOCUMENTATION {

        .. code-block:: c++

             DeviceManager devMgr = new DeviceManager();
             // this will return a pointer to the sample device of
             // type 'G' which has been assigned a device ID of 'abc'
             // or 0 if there is no sample device with this ID in the system.
             devMgr.getDeviceByProductAndID( "SampleDevice-G", "abc" );
             // will return a pointer to the device whose product string
             // starts with 'SampleDev' and whose device ID has been set
             // to 'def' or 0 if no such device can be found.
             devMgr.getDeviceByProductAndID( "SampleDev*", "def", '*' );
             // will return the first recognized device with an assigned
             // device ID of 'anyString' in the system.
             devMgr.getDeviceByProductAndID( "*", "anyString" );
        }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

        .. code-block:: c++

             devMgr = acquire.DeviceManager()
             # this will return a reference to the sample device of
             # type 'G' which has been assigned a device ID of 'abc'
             # or 0 if there is no sample device with this ID in the system.
             devMgr.getDeviceByProductAndID("SampleDevice-G", "abc")
             # will return a reference to the device whose product string
             # starts with 'SampleDev' and whose device ID has been set
             # to 'def' or 0 if no such device can be found.
             devMgr.getDeviceByProductAndID("SampleDev*", "def", '*')
             # will return the first recognized device with an assigned
             # device ID of 'anyString' in the system.
             devMgr.getDeviceByProductAndID("*", "anyString")
        }

         See also: 
         **Device::deviceID**,

         **DeviceManager::getDeviceByFamily**,

         **DeviceManager::getDeviceByProduct**,

         **DeviceManager::getDeviceBySerial**,

         **Device::setID**
         :rtype: :py:class:`Device`
         :return: 
             - A pointer to the device if found.

             - an invalid pointer or reference otherwise.

        :type product: string
        :param product: [in] The full product name of the requested device or known parts of it and wildcard characters.
        :type devID: string
        :param devID: [in] The device ID associated with this device.
        :param wildcard: [in] The character to ignore in *product*.
        """
        return lib_mvIMPACT_acquire.DeviceManager_getDeviceByProductAndID(self, *args)

    def closeAllDevices(self):
        return lib_mvIMPACT_acquire.DeviceManager_closeAllDevices(self)

    def __dummy__del__(self):
        self.closeAllDevices()


    def __getitem__(self, index):
        return lib_mvIMPACT_acquire.DeviceManager___getitem__(self, index)

# Register DeviceManager in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.DeviceManager_swigregister(DeviceManager)

def DeviceManager_getVersionAsString(libraryQuery):
    r"""
     Returns a string containing the version number of the specified library.
     This function returns a string containing the version number of the specified library.

     The format of the string will be MAJOR.MINOR.RELEASE.BUILD.
     Since: 2.1.2
     :rtype: string
     :return: A pointer to an internal version string.

    :type libraryQuery: int
    :param libraryQuery: [in] Specifies the library to query information from.
    """
    return lib_mvIMPACT_acquire.DeviceManager_getVersionAsString(libraryQuery)

dltUndefined = lib_mvIMPACT_acquire.dltUndefined
r""" A placeholder for an undefined list type."""
dltSetting = lib_mvIMPACT_acquire.dltSetting
r"""
    Specifies a certain setting.
    An additional string defines the name of the setting to look for.
    """
dltRequest = lib_mvIMPACT_acquire.dltRequest
r""" Specifies the list of driver owned image request objects."""
dltRequestCtrl = lib_mvIMPACT_acquire.dltRequestCtrl
r"""
    Specifies a certain image request control.
    An additional string defines the name of the setting to look for.
    """
dltInfo = lib_mvIMPACT_acquire.dltInfo
r"""
    Specifies the driver interfaces list containing general information.
    This e.g. can be properties containing the driver version, the current state
    of the device and stuff like that.
    """
dltStatistics = lib_mvIMPACT_acquire.dltStatistics
r"""
    Specifies the driver interface list containing statistical information.
    This list e.g. might contain the current frame rate, the total number of images
    captured, etc.
    """
dltSystemSettings = lib_mvIMPACT_acquire.dltSystemSettings
r"""
    Specifies the driver interface list containing properties, which influence the overall operation of the device.
    This list e.g. might contain the priority of the drivers internal worker thread,
    the number of request objects the driver shall work with, etc.
    """
dltIOSubSystem = lib_mvIMPACT_acquire.dltIOSubSystem
r"""
    Specifies the driver interface list containing properties to work with any kind of I/O pin belonging to that device.
    Here properties addressing the digital inputs and outputs and other I/O related
    properties can be found.
    """
dltRTCtr = lib_mvIMPACT_acquire.dltRTCtr
r"""
     Specifies the driver interface list providing access to the drivers **H**ardware **R**eal-**T**ime **C**ontroller (HRTC).
    Here properties to control the behaviour of the HRTCs can be found.
    Notes: 
    This feature might not be available for every device.
    """
dltCameraDescriptions = lib_mvIMPACT_acquire.dltCameraDescriptions
r"""
    Specifies the driver interface list providing access to the recognized camera description lists.
    Within this list all recognized camera descriptions can be found, each forming a sub list
    containing the properties describing the camera.

    Notes: This feature is only available for frame grabber devices currently.
    """
dltDeviceSpecificData = lib_mvIMPACT_acquire.dltDeviceSpecificData
r"""
    Specifies the driver interface list providing access to the device specific settings lists.
    Notes: This feature currently is only available for frame grabber devices.
    """
dltImageMemoryManager = lib_mvIMPACT_acquire.dltImageMemoryManager
r"""
    Specifies the driver interface list providing access to the devices memory manager list.
    Notes: This feature currently is only available for frame grabber devices.

    This list will contain properties and lists providing access to settings related to the memory
    handling used by the device. E.g. the buffer size for individual DMA blocks can be configured
    here.


    Properties in this list should only be modified by advanced users.
    """
dltPseudoLast = lib_mvIMPACT_acquire.dltPseudoLast
dltLast = lib_mvIMPACT_acquire.dltLast
r"""
    Defines the last entry in this enumeration.
    This is always equal to the last 'real' enum value.
    """
class DeviceComponentLocator(ComponentLocatorBase):
    r"""
     A class to locate components within the driver.
     Every driver will offer a set of properties, methods and component lists.
     **mvIMPACT::acquire::Property** objects contain data such as the current gain in dB, the state of a
     digital input, etc.. **mvIMPACT::acquire::Method** objects can be executed like a normal function and
     **mvIMPACT::acquire::ComponentList** objects are used to group certain
     objects together to form a logical unit.

     When it's necessary to locate one or more of these objects without knowing
     exactly where to look for them this locator class can be used to look for the component.

     In general the properties interesting for the user can be found in one of the
     classes offered by this interface, but when a special property is needed or a
     new property that hasn't been embedded into the C++ interface, this class offers
     a way to get hold of its handle.
    If: DOXYGEN_CPP_DOCUMENTATION {

    .. code-block:: c++

         // assuming a new property 'MyProp' has been added to the setting of a
         // device driver whose product string is 'MyDevice' and it has not been
         // added to the corresponding class or the property shall be accessed
         // without rebuilding the application.
         // The latter situation will require some kind of interpreter that
         // can pass the required information to the device driver
         //-----------------------------------------------------------------------------
         enum TMyEnumType
         //-----------------------------------------------------------------------------
         {
           metOne = 0,
           metTwo,
           metThree
         };

         //-----------------------------------------------------------------------------
         void fn( void )
         //-----------------------------------------------------------------------------
         {
           DeviceManager devMgr;
           Device* pDev = devMgr.getDeviceByProduct( "MyDev*" );
           if( pDev )
           {
             // get access to the base setting
             DeviceComponentLocator locator( pDev, dltSetting, "Base" );
             Property prop;
             locator.bindComponent( prop, "MyProp" );
             // set the value by string
             prop.writeS( "MyVal" );
             if( prop.type() == ctPropInt )
             {
               PropertyI iProp( prop.hObj() );
               int myVal = 666;
               iProp.write( myVal );
             }
             // if the type is known this test can be omitted:
             PropertyF fProp;
             locator.bindComponent( fProp, "MyFloatProperty" );
             fProp.write( 3.14 );

             // When it's an enumerated property this is legal as well:
             PropertyIMyEnumType eProp;
             locator.bindComponent( eProp, "MyEnumeratedProperty" );
             eProp.write( metOne );
           }
         }
    }Else if: DOXYGEN_JAVA_DOCUMENTATION {

    .. code-block:: c++

         //-----------------------------------------------------------------------------
         public static void fn( void )
         //-----------------------------------------------------------------------------
         {
           DeviceManager devMgr = new DeviceManager();
           Device pDev = devMgr.getDeviceByProduct( "MyDev*" );
           if( pDev != null )
           {
             DeviceComponentLocator locator = new DeviceComponentLocator( pDev, TDeviceListType.dltSetting, "Base" );
             Property prop = new Property();
             locator.bindComponent( prop, "MyProp" );
             // set the value by string
             prop.writeS( "MyVal" );
             if( prop.type() == TComponentType.ctPropInt )
             {
               PropertyI iProp = new PropertyI( prop.hObj() );
               int myVal = 666;
               iProp.write( myVal );
             }
             // if the type is known this test can be omitted:
             PropertyF fProp = new PropertyF();
             locator.bindComponent( fProp, "MyFloatProperty" );
             fProp.write( 3.14 );

             // When it's an enumerated property this is legal as well:
             PropertyI eProp = new PropertyI();
             locator.bindComponent( eProp, "MyBooleanProperty" );
             eProp.write( TBoolean.bTrue );
           }
         }
    }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

    .. code-block:: c++

         devMgr = acquire.DeviceManager()
         pDev = devMgr.getDeviceByProduct("MyDev*")
         if pDev:
           # get access to the base setting
           locator = acquire.DeviceComponentLocator(pDev, dltSetting, "Base")
           prop = None
           locator.bindComponent(prop, "MyProp")
           # set the value by string
           prop.writeS("MyVal")
           if prop.type == ctPropInt:
             iProp = PropertyI(prop.hObj())
             myVal = 666
             iProp.write(myVal)

           # if the type is known this test can be omitted:
           fProp = None
           locator.bindComponent(fProp, "MyFloatProperty")
           fProp.write(3.14)

           # When it's an enumerated property this is legal as well:
           eProp = acquire.EnumPropertyI()
           locator.bindComponent(eProp, "MyEnumeratedProperty")
           # e.g. writing the devices interfaceLayout property using the TDeviceInterfaceLayout enum value
           eProp.write(acquire.dilGenICam)
    }
    """

    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"""
        *Overload 1:*
         Constructs a new unbound locator.

        |

        *Overload 2:*
         Constructs a new bound to the specified base list locator.
        :type baselist: int
        :param baselist: [in] A unique identifier to the base list from where to start to search for the search base.

        |

        *Overload 3:*
         Constructs a new locator and searches the search base list.
        :type baselist: int
        :param baselist: [in] A unique identifier to the base list from where to start to search for the search base.
        :type pathToSearchBase: string
        :param pathToSearchBase: [in] The name or path ('/' separated) to the search base.

        |

        *Overload 4:*
         Constructs a new locator and bind the search base to the specified list type of the device.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type deviceListType: int
        :param deviceListType: [in] The type list to locate
        :type sublistName: string
        :param sublistName: [in] A string that can contain the name of the list if there is more than one candidate (e.g. when looking for settings)

        |

        *Overload 5:*
         Constructs a new locator and bind the search base to the specified list type of the device.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type deviceListType: int
        :param deviceListType: [in] The type list to locate
        :param sublistName: [in] A string that can contain the name of the list if there is more than one candidate (e.g. when looking for settings)
        """
        lib_mvIMPACT_acquire.DeviceComponentLocator_swiginit(self, lib_mvIMPACT_acquire.new_DeviceComponentLocator(*args))

    def bindSearchBaseList(self, *args):
        r"""
         Assign a new search base to the locator.
         This new search base will be search starting from the base list specified.
         :rtype: int
         :return: The unique identifier of the new search base.

        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type deviceListType: int
        :param deviceListType: [in] The type list to locate
        :type sublistName: string
        :param sublistName: [in] The name or path to the search base.
        """
        return lib_mvIMPACT_acquire.DeviceComponentLocator_bindSearchBaseList(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_DeviceComponentLocator

# Register DeviceComponentLocator in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.DeviceComponentLocator_swigregister(DeviceComponentLocator)

class ImageBufferDesc(object):
    r"""
    A wrapper class to handle **mvIMPACT::acquire::ImageBuffer** structures.
    This class acts as a simple wrapper to handle **mvIMPACT::acquire::ImageBuffer** structures.
    When using this class the user is no longer responsible for the memory management
    of **mvIMPACT::acquire::ImageBuffer** structures.

    Instances of this class are reference counted. Memory is freed once the last instance
    to it is destroyed. For details read the corresponding sections in the documentation
    of the various constructors and function belonging to this 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"""
        *Overload 1:*
         Constructs a new **mvIMPACT::acquire::ImageBufferDesc** from an existing one.
         The image buffer associated with this descriptor will not be copied! The internal
         data will be reference counted and changing this new object will also affect the
         original one. The internal data is freed when the last descriptor referencing the
         image is destroyed.

        :type source: :py:class:`ImageBufferDesc`
        :param source: [in] The source buffer descriptor.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::ImageBufferDesc** object with *channelCount* channel specific data elements.
         This constructor does **NOT** allocate memory for the actual pixel data but only for the
         a structure describing an image.

         When passing invalid values to this constructor (e.g. a negative value for ``channelCount)`` an
         exception will be thrown.

        :type channelCount: int
        :param channelCount: [in] The number of channel specific data elements to allocate memory for.

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::ImageBufferDesc** object and allocates all memory needed.
         This constructor will allocate and handle a new and complete **ImageBuffer** object including
         memory for the pixel data for the given pixel format.

         The size(in bytes) of allocated pixel memory will depend on the *pixelFormat* as well as on the
         parameters *width* and *height*. **mvIMPACT::acquire::ImageBuffer::iSize** will return the
         amount of memory allocated for the buffer.

         When passing invalid values to this constructor (e.g. a negative value for ``height)`` an
         exception will be thrown.

        :type pixelFormat: int
        :param pixelFormat: [in] The desired pixel format for the new **mvIMPACT::acquire::ImageBuffer** object handled by this descriptor.
        :type width: int
        :param width: [in] The width of the new **mvIMPACT::acquire::ImageBuffer** object handled by this descriptor.
        :type height: int
        :param height: [in] The height of the new **mvIMPACT::acquire::ImageBuffer** object handled by this descriptor.

        |

        *Overload 4:*
         Constructs a new **mvIMPACT::acquire::ImageBufferDesc** object from a file and allocates all memory needed.
         This constructor will allocate and handle a new and complete **ImageBuffer** object including
         memory for the pixel data for the given pixel format. The buffer will be filled with the
         data from the file referenced by ``fileName``.

         Notes: 
         Internally The FreeImage library (see 'legal notice' section) is used for this operation. If the library
         cannot be located in version 3.16.0 on the host system calling this constructor will fail and an
         exception will be thrown.

        Since: 2.23.0

        :type fileName: string
        :param fileName: [in] The name of the file to load.
        :type fileFormat: int
        :param fileFormat: [in] The format of the file to load.

        |

        *Overload 5:*
         Constructs a new **mvIMPACT::acquire::ImageBufferDesc** object from a file and allocates all memory needed.
         This constructor will allocate and handle a new and complete **ImageBuffer** object including
         memory for the pixel data for the given pixel format. The buffer will be filled with the
         data from the file referenced by ``fileName``.

         Notes: 
         Internally The FreeImage library (see 'legal notice' section) is used for this operation. If the library
         cannot be located in version 3.16.0 on the host system calling this constructor will fail and an
         exception will be thrown.

        Since: 2.23.0

        :type fileName: string
        :param fileName: [in] The name of the file to load.
        :param fileFormat: [in] The format of the file to load.
        """
        lib_mvIMPACT_acquire.ImageBufferDesc_swiginit(self, lib_mvIMPACT_acquire.new_ImageBufferDesc(*args))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_ImageBufferDesc

    def clone(self):
        r"""
        Returns a deep copy of the **mvIMPACT::acquire::ImageBuffer** object referenced by this descriptor.
        This function will create a deep copy of the **mvIMPACT::acquire::ImageBuffer** object referenced by this
        descriptor. Afterwards modifying one of the images will **NOT** influence the other one.

        :rtype: :py:class:`ImageBufferDesc`
        :return: A deep copy of the **mvIMPACT::acquire::ImageBuffer** object referenced by this descriptor.
        """
        return lib_mvIMPACT_acquire.ImageBufferDesc_clone(self)

    def copy(self, pDst, dstSize):
        r"""
         Returns a deep copy of the data buffer of the underlying **mvIMPACT::acquire::ImageBuffer** object referenced by this descriptor.
         This function will create a deep copy of the data buffer of the **mvIMPACT::acquire::ImageBuffer** object referenced by this
         descriptor. Afterwards modifying one of the buffers will **NOT** influence the other one.

        Since: 2.36.0
         :rtype: int
         :return: The buffer size needed for ``pDst`` if ``dstSize`` was too small or the size used if the operation was successful.

        :type pDst: string
        :param pDst: A pointer to the buffer to copy the data into. Can be 0 if just the size needed shall be queried.
        :type dstSize: int
        :param dstSize: The size of the buffer pointed to by ``pDst``. Is 'don't care' if just the size needed shall be queried.
        """
        return lib_mvIMPACT_acquire.ImageBufferDesc_copy(self, pDst, dstSize)

    def getBuffer(self):
        r"""
        Grants access to the underlying **mvIMPACT::acquire::ImageBuffer** structure managed by this object.
        :rtype: :py:class:`ImageBuffer`
        :return: A pointer to the **mvIMPACT::acquire::ImageBuffer** object referenced by this descriptor.
        """
        return lib_mvIMPACT_acquire.ImageBufferDesc_getBuffer(self)

    def save(self, *args):
        r"""
         Stores the complete data of one **ImageBuffer** structure into a file.
         This function stores the image described by a **mvIMPACT::acquire::ImageBuffer** structure pointed to by the ``pBuffer`` variable
         into a file.

         Notes: 
         Internally The FreeImage library (see 'legal notice' section) is used for this operation. If the library
         cannot be located in version 3.16.0 on the host system calling this function will fail.

        Since: 2.23.0
         :rtype: int
         :return: 
             - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
             - **mvIMPACT::acquire::DMR_LIBRARY_NOT_FOUND** if the required version of the FreeImage library could not be located on the host system.
             - **mvIMPACT::acquire::DEV_UNSUPPORTED_PARAMETER** if a pixel format has been passed to the function that is not supported by the internal algorithms.
             - **mvIMPACT::acquire::DEV_INPUT_PARAM_INVALID** if a pixel format has been passed to the function that is not supported by the FreeImage library.
             - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.

        :type fileName: string
        :param fileName: [in] The full path of the file to create.
        :type format: int
        :param format: [in] The format of the file to be created. If this parameter is set to **mvIMPACT::acquire::iffAuto** make sure to specify a proper file extension.
        """
        return lib_mvIMPACT_acquire.ImageBufferDesc_save(self, *args)

    r""" \brief A property \b (read-only) which holds a const reference to the mvIMPACT.acquire.ImageBuffer object referenced by this descriptor. See mvIMPACT.acquire.ImageBufferDesc.getBuffer() """
    buffer = property (getBuffer, None, None, None)


# Register ImageBufferDesc in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.ImageBufferDesc_swigregister(ImageBufferDesc)

class ComponentCollection(object):
    r""" A base class for sets of properties that can be modified by the user."""

    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__ = lib_mvIMPACT_acquire.delete_ComponentCollection

    def hObj(self):
        r"""
        Returns a unique identifier for the component collection referenced by this object.
        This handle will always reference an object of type **mvIMPACT::acquire::ComponentList**.
        :rtype: int
        :return: A unique identifier for the component referenced by this object.
        """
        return lib_mvIMPACT_acquire.ComponentCollection_hObj(self)

    def restoreDefault(self):
        r"""
        Restores the default for every component of this collection.
        Calling this function will restore the default value for every component
        belonging to this collection.

        Notes: The caller must have the right to modify the component. Otherwise
        an exception will be thrown.

        :rtype: :py:class:`ComponentCollection`
        :return: A const reference to the component.
        """
        return lib_mvIMPACT_acquire.ComponentCollection_restoreDefault(self)

# Register ComponentCollection in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.ComponentCollection_swigregister(ComponentCollection)

class BufferPart(ComponentCollection):
    r"""
     Contains information about a specific part of a captured buffer.
     This class provides access to all sorts of information about a specific part of a captured buffer.
     Only Instances of **mvIMPACT::acquire::Request** are allowed to create objects of **mvIMPACT::acquire::BufferPart**.
     Consequently the only way to get access to a **mvIMPACT::acquire::BufferPart** object is via a call to
     **mvIMPACT::acquire::Request::getBufferPart**.

    See also: 
    'ImageAcquisition_MultiPart'
    Since: 2.20.0
    """

    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

    def getImageBufferDesc(self):
        r"""
        Returns a const reference to the image buffer descriptor of this buffer part.
        This function returns a const reference to the **mvIMPACT::acquire::ImageBufferDesc** associated
        with this **mvIMPACT::acquire::BufferPart**.

        Warning: 
        Please do **NEVER** work with old references to this structure. So do **NOT** store this reference in
        some variable to use it for the evaluation of the next **mvIMPACT::acquire::BufferPart** object as well,
        as this will not work. Whenever **mvIMPACT::acquire::BufferPart::getImageBufferDesc** is called the function
        will make sure that the data in the returned structure is up to date while when working with
        an old reference to the **mvIMPACT::acquire::ImageBufferDesc** structure the containing data might refer
        to a previous result or even worse invalid memory locations. This reference will remain valid until an
        application calls **mvIMPACT::acquire::Request::unlock** for the corresponding request.
        """
        return lib_mvIMPACT_acquire.BufferPart_getImageBufferDesc(self)
    address = property(lib_mvIMPACT_acquire.BufferPart_address_get, doc=r"""
     A pointer property **(read-only)** containing the start address of this buffer part.
    See remarks under **mvIMPACT::acquire::Request::imageData**. Most of the information provided there
    will be valid for this property as well.
    """)
    dataSize = property(lib_mvIMPACT_acquire.BufferPart_dataSize_get, doc=r"""
     A 64-bit integer property **(read-only)** containing the size (in bytes) of this buffer part.
    See remarks under **mvIMPACT::acquire::Request::imageData**. Most of the information provided there
    will be valid for this property as well.
    """)
    dataType = property(lib_mvIMPACT_acquire.BufferPart_dataType_get, doc=r"""
    An enumerated 64-bit integer property **(read-only)** containing the data type of this buffer part.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBufferPartDataType**.
    """)
    pixelFormat = property(lib_mvIMPACT_acquire.BufferPart_pixelFormat_get, doc=r"""
    An enumerated integer property defining the pixel format of this buffer part.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TImageBufferPixelFormat**.
    """)
    width = property(lib_mvIMPACT_acquire.BufferPart_width_get, doc=r""" A 64-bit integer property **(read-only)** containing the width of the buffer part in pixels.""")
    height = property(lib_mvIMPACT_acquire.BufferPart_height_get, doc=r""" A 64-bit integer property **(read-only)** containing the height of the buffer part in pixels.""")
    offsetX = property(lib_mvIMPACT_acquire.BufferPart_offsetX_get, doc=r""" A 64-bit integer property **(read-only)** containing the X-offset of the buffer part in pixels.""")
    offsetY = property(lib_mvIMPACT_acquire.BufferPart_offsetY_get, doc=r""" A 64-bit integer property **(read-only)** containing the Y-offset of the buffer part in pixels.""")
    paddingX = property(lib_mvIMPACT_acquire.BufferPart_paddingX_get, doc=r""" A 64-bit integer property **(read-only)** containing the number of padding bytes in X direction of the buffer part.""")
    bytesPerPixel = property(lib_mvIMPACT_acquire.BufferPart_bytesPerPixel_get, doc=r""" A 64-bit integer property **(read-only)** containing the number of bytes per pixel in this buffer part.""")
    bayerMosaicParity = property(lib_mvIMPACT_acquire.BufferPart_bayerMosaicParity_get, doc=r"""
    An enumerated 64-bit integer property **(read-only)** containing the Bayer parity of this buffer part.
    If the current buffer part does not contain Bayer data, this value will be **mvIMPACT::acquire::bmpUndefined**.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBayerMosaicParity**.
    """)
    channelCount = property(lib_mvIMPACT_acquire.BufferPart_channelCount_get, doc=r"""
    A 64-bit integer property **(read-only)** containing the number of channels this buffer part consists of.
    For an RGB image this value e.g. would be 3. This value also defines how many parameters are stored by the properties
    **mvIMPACT::acquire::BufferPart::pixelPitch**,

    **mvIMPACT::acquire::BufferPart::linePitch**,

    **mvIMPACT::acquire::BufferPart::channelBitDepth**,

    **mvIMPACT::acquire::BufferPart::channelDesc** and

    **mvIMPACT::acquire::BufferPart::channelOffset**.

    If e.g. the channel count is 3 a call like bufferPart.channelOffset.read( 2 ) would return the channel offset of
    channel 3 (as calls to the read functions of properties are '0' based).
    """)
    channelDesc = property(lib_mvIMPACT_acquire.BufferPart_channelDesc_get, doc=r"""
     A string property **(read-only)** containing the string descriptors of each channel belonging to the current buffer part.
    See remarks under **mvIMPACT::acquire::Request::imageChannelDesc**. Most of the information provided there
    will be valid for this property as well.
    """)
    pixelPitch = property(lib_mvIMPACT_acquire.BufferPart_pixelPitch_get, doc=r"""
    A 64-bit integer property **(read-only)** containing the offset (in bytes) to the next pixel of the specified channel of this buffer part.
    Notes: 
    This property will store *channelCount* values. These can be queried one by one using the *index* parameter of the function
    **mvIMPACT::acquire::PropertyI64::read()** or in a single call by using the overloaded *read* function accepting a reference to a
    vector.
    """)
    linePitch = property(lib_mvIMPACT_acquire.BufferPart_linePitch_get, doc=r"""
    A 64-bit integer property **(read-only)** containing the offset (in bytes) to the next line of each channel belonging to the current buffer part.
    Notes: 
    This property will store *channelCount* values. These can be queried one by one using the *index* parameter of the function
    **mvIMPACT::acquire::PropertyI64::read()** or in a single call by using the overloaded *read* function accepting a reference to a
    vector.
    """)
    channelBitDepth = property(lib_mvIMPACT_acquire.BufferPart_channelBitDepth_get, doc=r"""
    A 64-bit integer property **(read-only)** containing the number of effective bits stored in each channel belonging to the current buffer part.
    Notes: 
    This property will store *channelCount* values. These can be queried one by one using the *index* parameter of the function
    **mvIMPACT::acquire::PropertyI64::read()** or in a single call by using the overloaded *read* function accepting a reference to a
    vector.
    """)
    channelOffset = property(lib_mvIMPACT_acquire.BufferPart_channelOffset_get, doc=r"""
     A 64-bit integer property **(read-only)** containing the offset (in bytes) to each channel belonging to the current buffer part relative to the address contained in **mvIMPACT::acquire::BufferPart::address**.
    Notes: 
    This property will store *channelCount* values. These can be queried one by one using the *index* parameter of the function
    **mvIMPACT::acquire::PropertyI64::read()** or in a single call by using the overloaded *read* function accepting a reference to a
    vector.
    """)
    sourceID = property(lib_mvIMPACT_acquire.BufferPart_sourceID_get, doc=r"""
     Identifier allowing to group data parts belonging to the same source (usually corresponding with the SourceSelector/ChunkSourceID features from SFNC).
    Parts marked with the same source_id can be pixel mapped together. Parts carrying data from different ROI's of the same source would typically be marked with the
    same source_id. It is not mandatory that source_id's within a given buffer make a contiguous sequence of numbers starting with zero.
    Notes: 
    For example with a dual-source 3D camera, the buffer can contain data parts carrying the 3D data and Confidence data corresponding to both
    of the two different sources. In this case the source ID helps to match the 3D and Confidence parts belonging together.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_BufferPart

# Register BufferPart in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.BufferPart_swigregister(BufferPart)

class Request(object):
    r"""
    Contains information about a captured buffer.
    This class provides access to all sorts of information about the captured buffer.
    Only Instances of **mvIMPACT::acquire::FunctionInterface** are allowed to create objects of **mvIMPACT::acquire::Request**.
    Consequently the only way to get access to a **mvIMPACT::acquire::Request** object is via a call to
    **mvIMPACT::acquire::FunctionInterface::getRequest**.

    A **mvIMPACT::acquire::Request** represents an object used by the driver to fill its internal job
    queues. Whenever a buffer shall be captured a **mvIMPACT::acquire::Request** is sent to the driver
    and the hardware then tries to capture the desired buffer as fast as possible.

    Requests are managed by the driver. The only thing the user needs to configure is the
    maximum number of requests he wants the driver to work with. To make sure a
    certain number of requests are available, the property
    **mvIMPACT::acquire::SystemSettings::requestCount** can be used.
    This can be useful for time critical applications where the hardware can capture
    images in the background while the PC performs other tasks. In that case it's
    necessary to make sure that the request queue never runs low to ensure lossless
    data acquisition.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::Request** from an existing one.
        :type src: :py:class:`Request`
        :param src: [in] A constant reference to the **mvIMPACT::acquire::Request** object, this object shall be created from
        """
        if self.__class__ == Request:
            _self = None
        else:
            _self = self
        lib_mvIMPACT_acquire.Request_swiginit(self, lib_mvIMPACT_acquire.new_Request(_self, *args))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_Request

    def getComponentLocator(self):
        r"""
         Returns a component locator for this request.
        This will allow to write custom feature bind operations.

         Since: 1.12.68
        :rtype: :py:class:`DeviceComponentLocator`
        :return: A component locator for this request.
        """
        return lib_mvIMPACT_acquire.Request_getComponentLocator(self)

    def getBufferPartCount(self):
        r"""
         Returns the number of buffer parts currently associated with this request.
        Certain device drivers are able to deliver multiple buffer part within a single request object.
        See also: 
        'ImageAcquisition_MultiPart'
        Since: 2.20.0
        :rtype: int
        :return: The number of buffer parts currently associated with this request. This might be zero in case the device
            driver delivers a ``standard`` data stream. It might also be 1 for special data formats such as JPEG, which must be handled
            differently from an image describing properties perspective.
        """
        return lib_mvIMPACT_acquire.Request_getBufferPartCount(self)

    def getBufferPart(self, index):
        r"""
         Returns a reference to a buffer part descriptor of this request.
         This function returns a reference to a **mvIMPACT::acquire::BufferPart** at index ``index`` associated
         with this **mvIMPACT::acquire::Request**.

         Warning: 
         Please do **NEVER** work with old references to this class. So do **NOT** store this reference in
         some variable to use it for the evaluation of the next **mvIMPACT::acquire::Request** object as well,
         as this might not work because the buffer layout might have changed. Whenever **mvIMPACT::acquire::Request::getBufferPart**
         is called the function will make sure that the data in the returned structure is up to date while when working with
         an old reference to the **mvIMPACT::acquire::BufferPart** structure the containing data might refer
         to a previous result or worse an invalid memory location. This reference will remain valid until an
         application calls **mvIMPACT::acquire::Request::unlock** for the corresponding request.

        See also: 
        **mvIMPACT::acquire::Request::getBufferPartCount**

        'ImageAcquisition_MultiPart'

        Since: 2.20.0
        :rtype: :py:class:`BufferPart`
        :return: A reference to the buffer part defined by ``index``

        :type index: int
        :param index: [in] The index of the buffer part to return
        """
        return lib_mvIMPACT_acquire.Request_getBufferPart(self, index)

    def getName(self):
        r"""
         Returns the name associated with this request.
        Since: 2.32.0
        """
        return lib_mvIMPACT_acquire.Request_getName(self)

    def getNumber(self):
        r""" Returns the number associated with this request."""
        return lib_mvIMPACT_acquire.Request_getNumber(self)

    def getImageBufferDesc(self):
        r"""
        Returns a const reference to the image buffer descriptor of this request.
        This function returns a const reference to the **mvIMPACT::acquire::ImageBufferDesc** associated
        with this **mvIMPACT::acquire::Request**.

        Warning: 
        Please do **NEVER** work with old references to this structure. So do **NOT** store this reference in
        some variable to use it for the evaluation of the next **mvIMPACT::acquire::Request** object as well,
        as this will not work. Whenever **mvIMPACT::acquire::Request::getImageBufferDesc** is called the function
        will make sure that the data in the returned structure is up to date while when working with
        an old reference to the **mvIMPACT::acquire::ImageBufferDesc** structure the containing data might refer
        to a previous result.
        """
        return lib_mvIMPACT_acquire.Request_getImageBufferDesc(self)

    def getInfoIterator(self):
        r"""
         Returns an iterator for iterating inside the info list of the request.
         This can be useful when custom or device specific information has been attached to the request
         object that wasn't known at compile time.

        It allows to write code like this:
        If: DOXYGEN_CPP_DOCUMENTATION {

        .. code-block:: c++

             // 'fi' is assumed to be a valid instance of mvIMPACT::acquire::FunctionInterface,
             // 'nr' is assumed to be a valid request number returned from a previous call to
             // mvIMPACT::acquire::FunctionInterface::imageRequestWaitFor()
             const Request* pRequest = fi.getRequest( nr );
             if( pRequest )
             {
               Component it(pRequest-getInfoIterator());
               std::mapstd::string, std::string m;
               while( it.isValid() )
               {
                 // collect all entries that are properties and store their current name and value in a map
                 if( it.isProp()  it.isVisible() )
                 {
                   Property prop( it );
                   m.insert( std::make_pair( prop.name(), prop.readS() ) );
                 }
                 ++it;
               }
               // Here you can work with the information you just obtained
             }
        }Else if: DOXYGEN_JAVA_DOCUMENTATION {

        .. code-block:: c++

             import java.util.Hashtable;

             // ...

             Component it = pRequest.getInfoIterator();
             HashtableString, String m = new HashtableString, String();
             while( it.isValid() )
             {
               // collect all entries that are properties and store their current name and value in a hash table
               if( it.isProp()  it.isVisible() )
               {
                 Property prop = new Property( it.hObj() );
                 m.put( prop.name(), prop.readS() );
               }
               it = it.nextSibling();
             }
             // Here you can work with the information you just obtained
        }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

        .. code-block:: c++

             # 'fi' is assumed to be a valid instance of acquire.FunctionInterface,
             # 'nr' is assumed to be a valid request number returned from a previous call to
             # acquire.FunctionInterface.imageRequestWaitFor()
             pRequest = fi.getRequest(requestNr)
             if pRequest:
                 it = pRequest.getInfoIterator()
                 props = {None:None}
                 while it.isValid:
                     if it.isProp and it.isVisible:
                         prop = acquire.Property(it.hObj())
                         props[prop.name()] = prop.readS()
                     it = it.nextSibling()
                 # Here you can work with the information you just obtained
        }
        :rtype: :py:class:`Component`
        :return: 
            An iterator for iterating inside the info list of the request.
        """
        return lib_mvIMPACT_acquire.Request_getInfoIterator(self)

    def getImageProcessingResultsIterator(self):
        r"""
         Returns an iterator for iterating inside the info/imageProcessingResults list of the request.
         This can be useful when custom or device specific algorithms have been applied to the request
         object that weren't known at compile time.

         For a code example please refer to the documentation of **mvIMPACT::acquire::Request::getInfoIterator**
         See also: 
         **mvIMPACT::acquire::Request::getInfoIterator**


        Since: 2.14.0

        :rtype: :py:class:`Component`
        :return: 
            An iterator for iterating inside the info/imageProcessingResults list of the request.
        """
        return lib_mvIMPACT_acquire.Request_getImageProcessingResultsIterator(self)

    def getHasProcessingBeenSkipped(self):
        r"""
        Checks if image processing that was set up for this request has been skipped for performance reasons.
        If **mvIMPACT::acquire::Device::userControlledImageProcessingEnable** is set to **mvIMPACT::acquire::bTrue** and
        **mvIMPACT::acquire::SystemSettings::imageProcessingMode** is set to  **mvIMPACT::acquire::ipmProcessLatestOnly**
        this function can be used to check if at least one algorithm has been skipped because of a lack of processing time.
        See also: 
        **mvIMPACT::acquire::Device::userControlledImageProcessingEnable**,

        **mvIMPACT::acquire::SystemSettings::imageProcessingMode**


        Since: 2.14.0

        :rtype: boolean
        :return: 
            - true if at least one internal algorithm has been skipped.
            - false otherwise.
        """
        return lib_mvIMPACT_acquire.Request_getHasProcessingBeenSkipped(self)

    def getChunkCounterCount(self):
        r"""
        Returns the number of counter values that can be returned as part of the additional data of the buffer containing the request data.
        A device may support a large number of counters even though just a few of them or none is configured
        for counting. In such a case situation when switching on the transmission of the counter values
        at the time of the internal frame start event will allow to access the number of counters returned
        by this function but then the data in these counters of course will be meaningless.

        Notes: 
        For additional information about the chunk data format please refer to 'ImageAcquisition_chunk'.

        Since: 2.0.15
        :rtype: int
        :return: 
            The number of counter values that can be returned as part of the additional data of the buffer containing the request data.
        """
        return lib_mvIMPACT_acquire.Request_getChunkCounterCount(self)

    def getChunkCounterValue(self, index):
        r"""
         Returns a 64 bit integer property **(read-only)** defining the selected counter value at the time of the internal frame start event for this request.
         If: DOXYGEN_CPP_DOCUMENTATION {
         If *index* is invalid(too large) a STL out_of_range exception
         will be thrown.
         }

         Notes: 
         For additional information about the chunk data format please refer to 'ImageAcquisition_chunk'.

         Since: 2.0.15

        :type index: int
        :param index: [in] The index of the counter to return
        """
        return lib_mvIMPACT_acquire.Request_getChunkCounterValue(self, index)

    def getChunkTimerCount(self):
        r"""
        Returns the number of timer values that can be returned as part of the additional data of the buffer containing the request data.
        A device may support a large number of timers even though just a few of them or none is configured
        to run. In such a case situation when switching on the transmission of the timer values
        at the time of the internal frame start event will allow to access the number of timers returned
        by this function but then the data in these timers of course will be meaningless.

        Notes: 
        For additional information about the chunk data format please refer to 'ImageAcquisition_chunk'.

        Since: 2.0.15
        """
        return lib_mvIMPACT_acquire.Request_getChunkTimerCount(self)

    def getChunkTimerValue(self, index):
        r"""
         Returns a floating point property **(read-only)** defining the selected timer value at the time of the internal frame start event for this request.
         If: DOXYGEN_CPP_DOCUMENTATION {
         If *index* is invalid(too large) a STL out_of_range exception
         will be thrown.
         }

         Notes: 
         For additional information about the chunk data format please refer to 'ImageAcquisition_chunk'.

         Since: 2.0.15

        :type index: int
        :param index: [in] The index of the timer to return
        """
        return lib_mvIMPACT_acquire.Request_getChunkTimerValue(self, index)

    def getChunkGainCount(self):
        r"""
        Returns the number of gain values that can be returned as part of the additional data of the buffer containing the request data.
        A device may support a large number of gains even though just a few of them or none is configured
        to run. In such a case situation when switching on the transmission of the gain values
        at the time of the internal frame start event will allow to access the number of gains returned
        by this function but then the data in these gains of course will be meaningless.

        Notes: 
        For additional information about the chunk data format please refer to 'ImageAcquisition_chunk'.

        Since: 2.17.3
        """
        return lib_mvIMPACT_acquire.Request_getChunkGainCount(self)

    def getChunkGain(self, *args):
        r"""
        *Overload 1:*
         Returns a floating point property **(read-only)** defining the selected gain value at the time of the internal frame start event for this request.
         If: DOXYGEN_CPP_DOCUMENTATION {
         If *index* is invalid(too large) a STL out_of_range exception
         will be thrown.
         }

         Notes: 
         For additional information about the chunk data format please refer to 'ImageAcquisition_chunk'.

         Since: 2.17.3

        :type index: int
        :param index: [in] The index of the gain to return

        |

        *Overload 2:*
         Returns a floating point property **(read-only)** defining the selected gain value at the time of the internal frame start event for this request.
         If: DOXYGEN_CPP_DOCUMENTATION {
         If *name* is invalid(not a valid gain to select) a **mvIMPACT::acquire::EInvalidInputParameter** exception
         will be thrown.
         }

         Notes: 
         For additional information about the chunk data format please refer to 'ImageAcquisition_chunk'.

         Since: 2.17.3

        :type name: string
        :param name: [in] The name of the gain to return (as selected by **mvIMPACT::acquire::GenICam::AnalogControl::gainSelector**)
        """
        return lib_mvIMPACT_acquire.Request_getChunkGain(self, *args)

    def getIsOK(self):
        r"""
         Convenience function to check if a request has been processed successfully.
        This is just a nicer way of checking the value of the *requestResult* property.
        It allows to write code like this:

        If: DOXYGEN_CPP_DOCUMENTATION {

        .. code-block:: c++

             // 'fi' is assumed to be a valid instance of mvIMPACT::acquire::FunctionInterface,
             // 'nr' is assumed to be a valid request number returned from a previous call to
             // mvIMPACT::acquire::FunctionInterface::imageRequestWaitFor()
             const Request* pRequest = fi.getRequest( nr );
             if( pRequest-isOK() )
             {
               // do something
             }
        }Else if: DOXYGEN_JAVA_DOCUMENTATION {

        .. code-block:: c++

             // 'fi' is assumed to be a valid instance of mvIMPACT::acquire::FunctionInterface,
             // 'nr' is assumed to be a valid request number returned from a previous call to
             // mvIMPACT.acquire.FunctionInterface.imageRequestWaitFor()
             Request pRequest = fi.getRequest( nr );
             if( pRequest.isOK() )
             {
               // do something
             }
        }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

        .. code-block:: c++

             # 'fi' is assumed to be a valid instance of acquire.FunctionInterface,
             # 'nr' is assumed to be a valid request number returned from a previous call to
             # acquire.FunctionInterface.imageRequestWaitFor()
             pRequest = fi.getRequest(nr)
             if pRequest.isOK:
               # do something
        }

        Instead if this:

        If: DOXYGEN_CPP_DOCUMENTATION {

        .. code-block:: c++

             // 'fi' is assumed to be a valid instance of mvIMPACT::acquire::FunctionInterface,
             // 'nr' is assumed to be a valid request number returned from a previous call to
             // mvIMPACT::acquire::FunctionInterface::imageRequestWaitFor()
             const Request* pRequest = fi.getRequest( nr );
             if( pRequest-requestResult.read() == rrOK )
             {
               // do something
             }
        }Else if: DOXYGEN_JAVA_DOCUMENTATION {

        .. code-block:: c++

             // 'fi' is assumed to be a valid instance of mvIMPACT::acquire::FunctionInterface,
             // 'nr' is assumed to be a valid request number returned from a previous call to
             // mvIMPACT.acquire.FunctionInterface.imageRequestWaitFor()
             Request pRequest = fi.getRequest( nr );
             if( pRequest.getRequestResult().read() == TRequestResult.rrOK )
             {
               // do something
             }
        }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

        .. code-block:: c++

             # 'fi' is assumed to be a valid instance of acquire.FunctionInterface,
             # 'nr' is assumed to be a valid request number returned from a previous call to
             # acquire.FunctionInterface.imageRequestWaitFor()
             pRequest = fi.getRequest(nr)
             if(pRequest.requestResult.read() == acquire.rrOK):
               # do something
        }

         Since: 1.12.63

         :rtype: boolean
         :return: 
             - true if the request has been processed successfully.
             - false otherwise.
        """
        return lib_mvIMPACT_acquire.Request_getIsOK(self)

    def configure(self):
        r"""
         Sets a request into configuration mode.
         In configuration mode certain properties like **mvIMPACT::acquire::Request::imageData**,
         **mvIMPACT::acquire::Request::imageSize**, **mvIMPACT::acquire::Request::imageMemoryMode**
         of a request object can be modified. This can be used to configure one or more requests
         to use a user supplied memory. To use only a subset of the **mvIMPACT::acquire::Request**
         objects available the **mvIMPACT::acquire::ImageRequestControl::requestToUse** feature
         can be used.

         Only requests that are currently not used by the driver and are not locked
         because they contain image data that hasn't been processed can be set into
         configuration mode.

         Notes: 
         Instead of calling this function directly for most cases it is much more convenient to use
         the functions **mvIMPACT::acquire::Request::attachUserBuffer** and **mvIMPACT::acquire::Request::detachUserBuffer**
         instead.

         User supplied buffers must follow the alignment and size requirements reported by versions of the
         function **mvIMPACT::acquire::FunctionInterface::getCurrentCaptureBufferLayout**. Calling
         a version of this function will return all the information required to allocate buffers that
         can be used to capture data for the specified settings.

         When allocating memory on the heap, the complete buffer size is needed which is calculated like
         this:

         **size + alignment**


         The address passed to the request object must be aligned already!

         If: DOXYGEN_CPP_DOCUMENTATION {

        .. code-block:: c++

             Device* pDev = getDevicePointerFromSomewhere()
             FunctionInterface fi(pDev);
             Request* pRequest = fi.getRequest( 0 );
             // the buffer assigned to the request object must be aligned accordingly
             // the size of the user supplied buffer MUST NOT include the additional size
             // caused by the alignment
             if( pRequest-attachUserBuffer( getAlignedMemoryPtr(), getAlignedMemorySize() ) ) == DMR_NO_ERROR )
             {
               ImageRequestControl irc(pDev);
               irc.requestToUse.write( 0 ); // use the buffer just configured for the next image request
               // now the next image will be captured into the user supplied memory
               fi.imageRequestSingle( irc ); // this will send request '0' to the driver
               // wait for the buffer. Once it has been returned by the driver AND the user buffer shall no
               // longer be used call
               if( pRequest-detachUserBuffer() != DMR_NO_ERROR )
               {
                 // handle error
               }
               // now this request will use internal memory again.
             }
             else
             {
                // handle error
             }
         }

         A request that is in configuration mode can't be sent to the driver for acquisition until
         **mvIMPACT::acquire::Request::unlock** or **mvIMPACT::acquire::FunctionInterface::imageRequestUnlock** has been called again.
         By using **mvIMPACT::acquire::Request::attachUserBuffer** and **mvIMPACT::acquire::Request::detachUserBuffer** this locking
         and unlocking is done internally thus the application does not need to worry about this.

         See also: 
         **mvIMPACT::acquire::FunctionInterface::imageRequestSingle**,

         **mvIMPACT::acquire::Request::attachUserBuffer**,

         **mvIMPACT::acquire::Request::detachUserBuffer**,

         **mvIMPACT::acquire::Request::unlock**,

         **mvIMPACT::acquire::FunctionInterface::imageRequestUnlock**,

         **mvIMPACT::acquire::FunctionInterface::imageRequestWaitFor**,

         **mvIMPACT::acquire::FunctionInterface::imageRequestReset**

         Since: 1.12.68

         :rtype: int
         :return: 
             - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
             - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.
        """
        return lib_mvIMPACT_acquire.Request_configure(self)

    def save(self, *args):
        r"""
         Stores the image described by this request into a file.
         This function stores the image described by this request into a file.

         Notes: 
         Internally The FreeImage library (see 'legal notice' section) is used for this operation. If the library
         cannot be located in version 3.16.0 on the host system calling this function will fail.

        Since: 2.23.0
         :rtype: int
         :return: 
             - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
             - **mvIMPACT::acquire::DMR_LIBRARY_NOT_FOUND** if the required version of the FreeImage library could not be located on the host system.
             - **mvIMPACT::acquire::DEV_UNSUPPORTED_PARAMETER** if a pixel format has been passed to the function that is not supported by the internal algorithms.
             - **mvIMPACT::acquire::DEV_INPUT_PARAM_INVALID** if a pixel format has been passed to the function that is not supported by the FreeImage library.
             - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.

        :type fileName: string
        :param fileName: [in] The full path of the file to create.
        :type format: int
        :param format: [in] The format of the file to be created. If this parameter is set to **mvIMPACT::acquire::iffAuto** make sure to specify a proper file extension.
        """
        return lib_mvIMPACT_acquire.Request_save(self, *args)

    def unlock(self):
        r"""
        Unlocks the request for the driver again.

        To ensure that no image data is overwritten by another image request while the user still
        deals with the image from a previous acquisition each image buffer will be locked by the driver when
        it is returned to the user by a call to **mvIMPACT::acquire::FunctionInterface::imageRequestWaitFor**.
        No new image will be captured into the same buffer until the user unlocks the buffer again
        by calling **mvIMPACT::acquire::Request::unlock** or **mvIMPACT::acquire::FunctionInterface::imageRequestUnlock**.

        Notes: 
        After unlocking a request it is no longer guaranteed that the memory once referenced by the
        request and the image buffer belonging to it stays valid, so do **NEVER** try to access
        memory belonging to an unlocked request object. If you need to copy the image buffer or
        modify it in any other way, do everything you have to do **BEFORE** calling this function!

        See also: 
        **mvIMPACT::acquire::FunctionInterface::imageRequestReset**,

        **mvIMPACT::acquire::FunctionInterface::imageRequestSingle**,

        **mvIMPACT::acquire::FunctionInterface::imageRequestWaitFor**

        **mvIMPACT::acquire::FunctionInterface::imageRequestConfigure**,

        **mvIMPACT::acquire::Request::configure**

        Since: 1.12.68

        :rtype: int
        :return: 
            - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
            - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.
        """
        return lib_mvIMPACT_acquire.Request_unlock(self)

    def attachUserBuffer(self, pBuf, bufSize):
        r"""
         Convenience function to attach a user supplied buffer to a **mvIMPACT::acquire::Request** object.
         This function just provides a nicer way to attach a user supplied buffer to a **mvIMPACT::acquire::Request**.

         If: DOXYGEN_CPP_DOCUMENTATION {
         It e.g. makes it possible to write code like this:

        .. code-block:: c++

             // 'fi' is assumed to be a valid instance of mvIMPACT::acquire::FunctionInterface,
             const Request* pRequest = fi.getRequest( 0 ); // get access to request 0
             pRequest-attachUserBuffer( getBufferFromSomewhere(), getBufferSizeFromSomewhere() );

         Instead if this:

        .. code-block:: c++

             // 'fi' is assumed to be a valid instance of mvIMPACT::acquire::FunctionInterface,
             const Request* pRequest = fi.getRequest( 0 ); // get access to request 0
             if( pRequest-configure() == DMR_NO_ERROR )
             {
               pRequest-imageMemoryMode.write( rimmUser );
               pRequest-imageData.write( getBufferFromSomewhere() );
               pRequest-imageSize.write( getBufferSizeFromSomewhere() );
               pRequest-unlock();
             }
         }

         To find out more about capturing to user supplied buffers please refer to the example
         'CaptureToUserMemory.cpp' and have a look at the
         documentation of the function **mvIMPACT::acquire::Request::configure**

         See also: 
         **mvIMPACT::acquire::Request::detachUserBuffer**,

            mvIMPACT::acquire::FunctionInterface::imageRequestUnlock,

            mvIMPACT::acquire::Request::unlock,

            mvIMPACT::acquire::FunctionInterface::imageRequestConfigure,

            mvIMPACT::acquire::Request::configure

         Since: 1.12.68

         :rtype: int
         :return: 
             - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
             - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.

        :type pBuf: void
        :param pBuf: [in] A pointer to a user supplied buffer
        :type bufSize: int
        :param bufSize: [in] The size of the user supplied buffer
        """
        return lib_mvIMPACT_acquire.Request_attachUserBuffer(self, pBuf, bufSize)

    def detachUserBuffer(self):
        r"""
         Convenience function to detach a user supplied buffer from a **mvIMPACT::acquire::Request** object.
         This function just provides a nicer way to detach a user supplied buffer from a **mvIMPACT::acquire::Request**.
         It e.g. allows to write code like this:

        If: DOXYGEN_CPP_DOCUMENTATION {

        .. code-block:: c++

             // 'fi' is assumed to be a valid instance of mvIMPACT::acquire::FunctionInterface
             const Request* pRequest = fi.getRequest( 0 ); // get access to request 0
             pRequest-detachUserBuffer();
        }Else if: DOXYGEN_JAVA_DOCUMENTATION {

        .. code-block:: c++

             // 'fi' is assumed to be a valid instance of mvIMPACT.acquire.FunctionInterface
             Request pRequest = fi.getRequest( 0 ); // get access to request 0
             pRequest.detachUserBuffer();
        }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

        .. code-block:: c++

             # 'fi' is assumed to be a valid instance of acquire.FunctionInterface
             pRequest = fi.getRequest(0) # get access to request 0
             pRequest.detachUserBuffer()
        }

         Instead if this:

        If: DOXYGEN_CPP_DOCUMENTATION {

        .. code-block:: c++

             // 'fi' is assumed to be a valid instance of mvIMPACT::acquire::FunctionInterface
             const Request* pRequest = fi.getRequest( 0 ); // get access to request 0
             if( pRequest-configure() == DMR_NO_ERROR )
             {
               pRequest-imageMemoryMode.write( rimmAuto );
               pRequest-unlock();
             }
        }Else if: DOXYGEN_JAVA_DOCUMENTATION {

        .. code-block:: c++

             // 'fi' is assumed to be a valid instance of mvIMPACT.acquire.FunctionInterface
             Request pRequest = fi.getRequest( 0 ); // get access to request 0
             if( pRequest.configure() == TDMR_ERROR.DMR_NO_ERROR )
             {
               pRequest.getImageMemoryMode().write( TRequestImageMemoryMode.rimmAuto );
               pRequest.unlock();
             }
        }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

        .. code-block:: c++

             # 'fi' is assumed to be a valid instance of acquire.FunctionInterface
             pRequest = fi.getRequest(0) # get access to request 0
             if pRequest.configure() == acquire.DMR_NO_ERROR:
               pRequest.imageMemoryMode.write(acquire.rimmAuto)
               pRequest.unlock()
        }

         To find out more about capturing to user supplied buffers please refer to the example
         'CaptureToUserMemory.cpp' and have a look at the
         documentation of the function **mvIMPACT::acquire::Request::configure**

         See also: 
         **mvIMPACT::acquire::Request::attachUserBuffer**,

         **mvIMPACT::acquire::FunctionInterface::imageRequestUnlock**,

         **mvIMPACT::acquire::Request::unlock**,

         **mvIMPACT::acquire::FunctionInterface::imageRequestConfigure**,

         **mvIMPACT::acquire::Request::configure**

         Since: 1.12.68

         :rtype: int
         :return: 
             - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
             - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.
        """
        return lib_mvIMPACT_acquire.Request_detachUserBuffer(self)
    requestResult = property(lib_mvIMPACT_acquire.Request_requestResult_get, doc=r"""
    An enumerated integer property **(read-only)** defining the result of this request.
    This parameter indicates whether a previous image acquisition has been
    successful or not.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TRequestResult**.
    """)
    requestState = property(lib_mvIMPACT_acquire.Request_requestState_get, doc=r"""
    An enumerated integer property **(read-only)** defining the current state of this request.
    This parameter indicates the current state of this request. A **mvIMPACT::acquire::Request** e.g.
    can currently be idle. This would mean that it is currently not used for
    image acquisition. Also a **mvIMPACT::acquire::Request** can be in 'Capturing' state, which means
    it is currently processed by the driver.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TRequestState**.
    """)
    infoFrameID = property(lib_mvIMPACT_acquire.Request_infoFrameID_get, doc=r"""
    A 64 bit integer property **(read-only)** containing a frame identifier.
    This parameter is returned as part of the **mvIMPACT::acquire::Request**. It is
    used to associate a certain image with a unique identifier.

    When an **mvIMPACT::acquire::RTCtrProgramStep** instruction of the type **mvIMPACT::acquire::rtctrlProgTriggerSet**
    is executed, the *frameID* is set to the value of the property *FrameID* of a corresponding **mvIMPACT::acquire::RTCtrProgramStep** if the
    HRTC is used and any program step executes the setting of the ID.

    If a device (e.g. a digital camera) supports the transmission of a unique identifier for an image, this property will reflect
    the identifier as transmitted by the device.

    Notes: **mvBlueFOX** and **mvHYPERION** specific:
    This property will only contain meaningful data if the device supports at least one **HRTC** and a program is running and writing data to
    the property OR if a device supports the transmission of a unique identifier for an image. Currently HRTC programs are supported by **mvBlueFOX** and **mvHYPERION** devices.

    **GigE** **Vision** and **USB3** **Vision** specific:
    This is the property where the so called block ID will be stored which is a unique identifier for each frame that will be transferred by the device as part of each frame as defined by the standard.
    - For **GigE** **Vision** 1.x compliant devices, this will be a 16 bit counter that will be incremented with every data block(e.g. an image or chunk data) transmitted
    by the device where '0' is a reserved value, which will never be used, thus values like this will be transmitted in a round robin scheme:
    1, 2, 3, ..., 65535, 1, 2, ...
    - For devices complying with version 2.0 and greater of the **GigE** **Vision** specification, this will be a 64 bit counter that will be incremented with every data block(e.g. an image or chunk data) transmitted
    by the device where '0' is a reserved value, which will never be used, thus values like this will be transmitted in a round robin scheme:
    1, 2, 3, ..., ((2^64)-1), 1, 2, ...
    - For **USB3** **Vision** compliant devices, this will be a 64 bit counter that will be incremented with every data block(e.g. an image or chunk data) transmitted
    by the device, thus values like this will be transmitted in a round robin scheme:
    0, 1, 2, ..., ((2^64)-1), 0, 1, ...

    Please note that due to the nature of **mvIMPACT::acquire::amContinuous** there might be gaps between the
    last image of a continuous stream and the first image of the next continuous stream if the device is stopped or re-programmed in between.
    """)
    infoFrameNr = property(lib_mvIMPACT_acquire.Request_infoFrameNr_get, doc=r"""
    A 64 bit integer property **(read-only**, zero-based) containing the number of image requests processed since this driver instance has been opened.
    This counter is incremented regardless of the result this request is returned with thus also e.g. if a request did time out, was aborted(e.g. due to a call to **mvIMPACT::acquire::FunctionInterface::imageRequestReset** or **mvIMPACT::acquire::FunctionInterface::acquisitionStop)** or the data was not completely captured.
    So if a **mvIMPACT::acquire::Request** object contains the value *6* here, 6 requests have been processed before this one(the first request would contain the value *0)*
    This value is reset to 0 only if the current driver instance is closed.
    """)
    infoExposeStart_us = property(lib_mvIMPACT_acquire.Request_infoExposeStart_us_get, doc=r"""
    An integer property **(read-only)** containing a timestamp (in us) defining the time the device started the exposure of the image associated with this **mvIMPACT::acquire::Request** object.
    This value will stay 0 if nothing is known about the time the exposure did start.
    In such a case the **mvIMPACT::acquire::Request::infoTimeStamp_us** property should be used instead.
    """)
    infoExposeTime_us = property(lib_mvIMPACT_acquire.Request_infoExposeTime_us_get, doc=r"""
    An integer property **(read-only)** containing the 'real' expose time (in us) used to generate this image.
    This might differ slightly from the value selected by the user via
    the corresponding exposure property depending on the precision
    available for the device or the connected camera.
    """)
    infoTransferDelay_us = property(lib_mvIMPACT_acquire.Request_infoTransferDelay_us_get, doc=r"""
    An integer property **(read-only)** containing the time the transaction of this image has been delayed (in us) because either the bus was blocked or the CPU was busy.
    Normally this value will be 0. A value larger than 0 indicates that the system
    can't manage the current load.

    Notes: This property is not supported by every device.
    Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.
    """)
    infoGain_dB = property(lib_mvIMPACT_acquire.Request_infoGain_dB_get, doc=r""" A float property **(read-only)** containing the gain(in dB) this image has been taken with.""")
    infoTimeStamp_us = property(lib_mvIMPACT_acquire.Request_infoTimeStamp_us_get, doc=r"""
     A 64 bit integer property **(read-only)** containing a timestamp to define the exact time this image has been captured (usually either at exposure start or exposure end, depending on the device).
    **mvBlueFOX** specific:
    The counter of the timestamp starts when the camera gets initialized. It is measured in us.
    """)
    infoSettingUsed = property(lib_mvIMPACT_acquire.Request_infoSettingUsed_get, doc=r"""
    A enumerated integer property **(read-only)** containing the setting that was used for processing this request.
    The string representation will be a valid setting name, the integer representation can be casted into a **mvIMPACT::acquire::HOBJ** type.
    """)
    infoImageAverage = property(lib_mvIMPACT_acquire.Request_infoImageAverage_get, doc=r""" Currently unsupported.""")
    infoVideoChannel = property(lib_mvIMPACT_acquire.Request_infoVideoChannel_get, doc=r"""
    An integer property **(read-only)** containing the video input channel of the device this image has been acquired from.
    Notes: 
    This property is not supported by every device and will only be available if the device has more than one input channel.
    Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.
    """)
    infoCameraOutputUsed = property(lib_mvIMPACT_acquire.Request_infoCameraOutputUsed_get, doc=r"""
    An enumerated integer property **(read-only)** containing the camera output used to transmit the image to the capture device.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraOutput**.

    Notes: This property is not supported by every device. Therefore always call the function **mvIMPACT::acquire::Component::isValid**
    to check if this property is available or not.
    """)
    infoLineCounter = property(lib_mvIMPACT_acquire.Request_infoLineCounter_get, doc=r"""
    An integer property **(read-only)** containing the number of lines since the last trigger event.
    Will contain
    - the number of lines since last trigger event of the first line of the snap if line counting is enabled
    - -1 otherwise

    Notes: This property is not supported by every device. Therefore always call the function **mvIMPACT::acquire::Component::isValid**
    to check if this property is available or not.
    """)
    infoMissingData_pc = property(lib_mvIMPACT_acquire.Request_infoMissingData_pc_get, doc=r"""
    A float property **(read-only)** containing the amount of data missing in the current image.
    The value of this property will be 0 almost always. However if a device
    can detect blocks of missing data and an image request has returned with **mvIMPACT::acquire::rrFrameIncomplete**
    to indicate that not all the data has been captured, this property will contain the amount of data missing in percent.
    """)
    infoIOStatesAtExposureStart = property(lib_mvIMPACT_acquire.Request_infoIOStatesAtExposureStart_get, doc=r"""
     An integer property **(read-only)** containing the state of all the IO lines at the beginning of the frame exposure as a device specific bit field.
     The following table documents which bit in this property represents the state of which digital I/O for **mvBlueFOX** devices:


     |bit|IO|
     |0|in 0|
     |1|in 1|
     |2|in 2(if available)|
     |3|in 3(if available)|
     |4|out 0|
     |5|out 1|
     |6|out 2(if available)|
     |7|out 3(if available)|


    This feature is currently only available for **mvBlueFOX-MLC** devices!

    If: DOXYGEN_CPP_DOCUMENTATION {

    .. code-block:: c++

         #include sstream
         #include mvIMPACT/mvIMPACT_acquire.h

         using namespace std;
         using namespace mvIMPACT::acquire;

         //-----------------------------------------------------------------------------
         templatetypename _Ty
         string decToBinString( _Ty value )
         //-----------------------------------------------------------------------------
         {
           const size_t bitCount = sizeof(_Ty)*8;
           ostringstream oss;
           for( size_t i=0; ibitCount; i++ )
           {
             oss < ( ( value  ( 1 < ( bitCount - 1 - i ) ) ) ? "1" : "0" );
           }
           return oss.str();
         }

         //-----------------------------------------------------------------------------
         void printIOStateOfAValidRequest( const Request* pRequest )
         //-----------------------------------------------------------------------------
         {
           if( pRequest-infoIOStatesAtExposureStart.isValid() )
           {
              cout < pRequest-infoIOStatesAtExposureStart.name() < ": " < decToBinString( pRequest-infoIOStatesAtExposureStart.read() ) < endl;
           }
         }
    }Else if: DOXYGEN_JAVA_DOCUMENTATION {

    .. code-block:: c++

         //-----------------------------------------------------------------------------
         public static void printIOStateOfAValidRequest( Request pRequest )
         //-----------------------------------------------------------------------------
         {
           if( pRequest.getInfoIOStatesAtExposureStart().isValid() )
           {
              System.out.println( pRequest.getInfoIOStatesAtExposureStart().name() + ": " + Integer.toBinaryString( pRequest.getInfoIOStatesAtExposureStart().read() ) );
           }
         }
    }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

    .. code-block:: c++

         def printIOStateOfAValidRequest(pRequest):
           if pRequest.infoIOStatesAtExposureStart.isValid:
             print(pRequest.infoIOStatesAtExposureStart.name() + ": " + format(pRequest.infoIOStatesAtExposureStart.read(), '32b'))
    }
     Notes: This property is not supported by every device. Therefore always call the function **mvIMPACT::acquire::Component::isValid**
     to check if this property is available or not.
    """)
    infoIOStatesAtExposureEnd = property(lib_mvIMPACT_acquire.Request_infoIOStatesAtExposureEnd_get, doc=r"""
    An integer property **(read-only)** containing the state of all the IO lines at the end of the frame exposure as a device specific bit field.
    See **mvIMPACT::acquire::Request::infoIOStatesAtExposureStart** for details on how to interpret the data.

    Notes: This property is not supported by every device. Therefore always call the function **mvIMPACT::acquire::Component::isValid**
    to check if this property is available or not.
    """)
    chunkOffsetX = property(lib_mvIMPACT_acquire.Request_chunkOffsetX_get, doc=r"""
    A 64 bit integer property **(read-only)** containing the X-offset of the image in pixels as returned in the chunk data attached to the image.
    Notes: 
    For additional information about the chunk data format please refer to 'ImageAcquisition_chunk'.
    """)
    chunkOffsetY = property(lib_mvIMPACT_acquire.Request_chunkOffsetY_get, doc=r"""
    A 64 bit integer property **(read-only)** containing the Y-offset of the image in pixels as returned in the chunk data attached to the image.
    Notes: 
    For additional information about the chunk data format please refer to 'ImageAcquisition_chunk'.
    """)
    chunkWidth = property(lib_mvIMPACT_acquire.Request_chunkWidth_get, doc=r"""
    A 64 bit integer property **(read-only)** containing the width of the image in pixels as returned in the chunk data attached to the image.
    Notes: 
    For additional information about the chunk data format please refer to 'ImageAcquisition_chunk'.
    """)
    chunkHeight = property(lib_mvIMPACT_acquire.Request_chunkHeight_get, doc=r"""
    A 64 bit integer property **(read-only)** containing the height of the image in pixels as returned in the chunk data attached to the image.
    Notes: 
    For additional information about the chunk data format please refer to 'ImageAcquisition_chunk'.
    """)
    chunkPixelFormat = property(lib_mvIMPACT_acquire.Request_chunkPixelFormat_get, doc=r"""
    A 64 bit integer property **(read-only)** containing the pixel format of the image as returned in the chunk data attached to the image.
    This will **NOT** be a valid mvIMPACT acquire pixel format but e.g. a GigE Vision, USB3 Vision of PFNC compliant pixel format or something else.
    Notes: 
    For additional information about the chunk data format please refer to 'ImageAcquisition_chunk'.
    """)
    chunkDynamicRangeMin = property(lib_mvIMPACT_acquire.Request_chunkDynamicRangeMin_get, doc=r"""
    A 64 bit integer property **(read-only)** containing the minimum value of dynamic range of the image as returned in the chunk data attached to the image.
    Notes: 
    For additional information about the chunk data format please refer to 'ImageAcquisition_chunk'.
    """)
    chunkDynamicRangeMax = property(lib_mvIMPACT_acquire.Request_chunkDynamicRangeMax_get, doc=r"""
    A 64 bit integer property **(read-only)** containing the maximum value of dynamic range of the image as returned in the chunk data attached to the image.
    Notes: 
    For additional information about the chunk data format please refer to 'ImageAcquisition_chunk'.
    """)
    chunkExposureTime = property(lib_mvIMPACT_acquire.Request_chunkExposureTime_get, doc=r"""
     A floating point property **(read-only)** containing the exposure time used to capture the image as returned in the chunk data attached to the image.
     Notes: 
     For additional information about the chunk data format please refer to 'ImageAcquisition_chunk'.

    Since: 2.5.16
    """)
    chunkTimestamp = property(lib_mvIMPACT_acquire.Request_chunkTimestamp_get, doc=r"""
    A 64 bit integer property **(read-only)** containing the timestamp value of the internal frame start signal of the image as returned in the chunk data attached to the image.
    Notes: 
    For additional information about the chunk data format please refer to 'ImageAcquisition_chunk'.
    """)
    chunkLineStatusAll = property(lib_mvIMPACT_acquire.Request_chunkLineStatusAll_get, doc=r"""
    A 64 bit integer property **(read-only)** containing the status of all I/O lines at the time of the internal frame start signal of the image as returned in the chunk data attached to the image.
    Notes: 
    For additional information about the chunk data format please refer to 'ImageAcquisition_chunk'.
    """)
    chunkSequencerSetActive = property(lib_mvIMPACT_acquire.Request_chunkSequencerSetActive_get, doc=r"""
    A 64-bit integer property **(read-only)** containing the index of the active set of the running sequencer use during the creation of this block of data.
    Notes: 
    For additional information about the chunk data format please refer to 'ImageAcquisition_chunk'.

    Since: 2.12.3
    """)
    chunkmvCustomIdentifier = property(lib_mvIMPACT_acquire.Request_chunkmvCustomIdentifier_get, doc=r"""
    A 64 bit integer property **(read-only)** containing the previously configured user defined identifier attached to the image.
    This identifier can be specified by some other functions belonging to this SDK. If not specified this value will be 0.

    Notes: 
    For additional information about the chunk data format please refer to 'ImageAcquisition_chunk'.

    Since: 2.17.3
    """)
    imageMemoryMode = property(lib_mvIMPACT_acquire.Request_imageMemoryMode_get, doc=r"""
    An enumerated integer property **(read-only)** containing the memory mode used for this request.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TRequestImageMemoryMode**.

    Notes: This property will become writeable if this request is in configuration mode.
    See also: 
    **mvIMPACT::acquire::FunctionInterface::imageRequestConfigure**,

    **mvIMPACT::acquire::Request::configure**
    """)
    imagePixelFormat = property(lib_mvIMPACT_acquire.Request_imagePixelFormat_get, doc=r"""
    An enumerated integer property **(read-only)** containing the pixel format of this image.
    This might be important, when the image data needs to be processed or stored in
    a file or maybe even if the image shall be displayed.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TImageBufferPixelFormat**.
    """)
    imageData = property(lib_mvIMPACT_acquire.Request_imageData_get, doc=r"""
     A pointer property **(read-only)** containing the start address of the image data.
     This address in connection with **mvIMPACT::acquire::Request::imageSize** is sufficient
     to copy the complete image without having any additional information about it.

    If: DOXYGEN_CPP_DOCUMENTATION {

    .. code-block:: c++

         FunctionInterface fi = getFunctionInterfaceFromSomewhere();
         int currentRequestNr = getCurrentRequestNumberFromSomewhere();
         const Request* pRequest = fi.getRequest( currentRequestNr );
         char* pTempBuf = new char[pRequest-imageSize.read()];
         memcpy( pTempBuf, pRequest-imageData.read(), pRequest-imageSize.read() );
         // free the memory once no longer needed...
    }Else if: DOXYGEN_JAVA_DOCUMENTATION {
     FunctionInterface fi = getFunctionInterfaceFromSomewhere();
     int currentRequestNr = getCurrentRequestNumberFromSomewhere();
     Request pRequest = fi.getRequest( currentRequestNr );
     byte[] data = new byte[pRequest.getImageSize().read()];
     pRequest.getImageBufferDesc().copy( data );

    .. code-block:: c++

    }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

    .. code-block:: c++

         currentRequestNr = getCurrentRequestNumberFromSomewhere()
         pRequest = fi.getRequest(currentRequestNr)
         cbuf = (ctypes.c_char * pRequest.imageSize.read()).from_address(int(pRequest.imageData.read()))
    }

     Notes: 
     It's not always necessary to copy the image data! Each image buffer is an
     integral part of the **mvIMPACT::acquire::Request** object returned to the user by a call to
     the corresponding 'waitFor' function offered by the interface.
     The data in this buffer remains valid until the user either
     unlocks the request buffer or closes the **mvIMPACT::acquire::Device** again.


     By unlocking the **mvIMPACT::acquire::Request**, the user informs the driver that this **mvIMPACT::acquire::Request**
     and the image buffer belonging to that **mvIMPACT::acquire::Request** is no longer needed by the
     user. The driver then queues this **mvIMPACT::acquire::Request** for capturing image data into it once
     again. However, once a **mvIMPACT::acquire::Request** has been returned to the user, its image buffer
     can't be overwritten by the driver! Therefore the user can work with, modify, store or
     copy the data safely until he unlocks the **mvIMPACT::acquire::Request** again.

     This property will become writeable if this request is in configuration mode.
     See also: 
     **mvIMPACT::acquire::FunctionInterface::imageRequestConfigure**,

     **mvIMPACT::acquire::Request::configure**,

     **mvIMPACT::acquire::Request::imageSize**,

     **mvIMPACT::acquire::Request::imageFooterSize**
    """)
    imageSize = property(lib_mvIMPACT_acquire.Request_imageSize_get, doc=r"""
    An integer property **(read-only)** containing the size (in bytes) of the whole image.
    This value in connection with **mvIMPACT::acquire::Request::imageData** is sufficient
    to copy the complete image without having any additional information about it.

    Notes: This property will become writeable if this request is in configuration mode.
    See also: 
    **mvIMPACT::acquire::FunctionInterface::imageRequestConfigure**,

    **mvIMPACT::acquire::Request::configure**,

    **mvIMPACT::acquire::Request::imageData**,

    **mvIMPACT::acquire::Request::imageFooterSize**
    """)
    imageFooter = property(lib_mvIMPACT_acquire.Request_imageFooter_get, doc=r"""
    A pointer property **(read-only)** containing the start address of the footer associated with this image.
    A footer may contain additional data like e.g. information about the image (e.g. the exposure time used for this image).
    If this property contains the value '0' no footer is attached to this image.

    Notes: 
    In general it is not necessary to access footer data. Sometime e.g. when the hardware already does some image pre-processing
    a footer containing additional information about the image data might be attached to the image. In this case some additional
    information about the structure of the footer might be needed as well.
    """)
    imageFooterSize = property(lib_mvIMPACT_acquire.Request_imageFooterSize_get, doc=r""" An integer property **(read-only)** containing the size (in bytes) of the footer associated with this image. If this property contains the value '0' no footer is attached to this image.""")
    imagePixelPitch = property(lib_mvIMPACT_acquire.Request_imagePixelPitch_get, doc=r"""
    An integer property **(read-only)** containing the offset (in bytes) to the next pixel of the specified channel of this image.
    Notes: 
    This property will store *imageChannelCount* values. These can be queried one by one using the *index* parameter of the function
    **mvIMPACT::acquire::PropertyI::read()** or in a single call by using the overloaded *read* function accepting a reference to a
    vector.
    """)
    imageChannelCount = property(lib_mvIMPACT_acquire.Request_imageChannelCount_get, doc=r"""
    An integer property **(read-only)** containing the number of channels this image consists of.
    For an RGB image this value e.g. would be 3. This value also defines how many parameters are stored by the properties
    **mvIMPACT::acquire::Request::imagePixelPitch**,

    **mvIMPACT::acquire::Request::imageLinePitch**,

    **mvIMPACT::acquire::Request::imageChannelBitDepth**,

    **mvIMPACT::acquire::Request::imageChannelDesc** and

    **mvIMPACT::acquire::Request::imageChannelOffset**.

    If e.g. the channel count is 3 a call like pRequest->imageChannelOffset.read( 2 ) would return the channel offset of
    channel 3 (as calls to the read functions of properties are '0' based).
    """)
    imageChannelOffset = property(lib_mvIMPACT_acquire.Request_imageChannelOffset_get, doc=r"""
     An integer property **(read-only)** containing the offset (in bytes) to each channel belonging to the current image relative to the address contained in **mvIMPACT::acquire::Request::imageData**.
    Notes: 
    This property will store *imageChannelCount* values. These can be queried one by one using the *index* parameter of the function
    **mvIMPACT::acquire::PropertyI::read()** or in a single call by using the overloaded *read* function accepting a reference to a
    vector.
    """)
    imageChannelBitDepth = property(lib_mvIMPACT_acquire.Request_imageChannelBitDepth_get, doc=r"""
    An integer property **(read-only)** containing the number of effective bits stored in each channel belonging to the current image.
    Notes: 
    This property will store *imageChannelCount* values. These can be queried one by one using the *index* parameter of the function
    **mvIMPACT::acquire::PropertyI::read()** or in a single call by using the overloaded *read* function accepting a reference to a
    vector.
    """)
    imageLinePitch = property(lib_mvIMPACT_acquire.Request_imageLinePitch_get, doc=r"""
    An integer property **(read-only)** containing the offset (in bytes) to the next line of each channel belonging to the current image.
    Notes: 
    This property will store *imageChannelCount* values. These can be queried one by one using the *index* parameter of the function
    **mvIMPACT::acquire::PropertyI::read()** or in a single call by using the overloaded *read* function accepting a reference to a
    vector.
    """)
    imageChannelDesc = property(lib_mvIMPACT_acquire.Request_imageChannelDesc_get, doc=r"""
     A string property **(read-only)** containing the string descriptors of each channel belonging to the current image.
    Notes: 
     This property will store *imageChannelCount* values. These can be queried one by one using the *index* parameter of the function
     **mvIMPACT::acquire::PropertyS::read()** or in a single call by using the overloaded *read* function accepting a reference to a
     vector.

     For an RGB image this property e.g. might contain three values "R", "G" and "B".
    If: DOXYGEN_CPP_DOCUMENTATION {

    .. code-block:: c++

         FunctionInterface fi = getFunctionInterfaceFromSomewhere();
         int currentRequestNr = getCurrentRequestNumberFromSomewhere();
         const Request* pRequest = fi.getRequest( currentRequestNr );
         int channelCount = pRequest-imageChannelCount.read();
         for( int i=0; ichannelCount; i++ )
         {
           cout < "channel[" < i < "]: " < pRequest-imageChannelDesc.read( i ) < endl;
         }
    }Else if: DOXYGEN_JAVA_DOCUMENTATION {

    .. code-block:: c++

         FunctionInterface fi = getFunctionInterfaceFromSomewhere();
         int currentRequestNr = getCurrentRequestNumberFromSomewhere();
         Request pRequest = fi.getRequest( currentRequestNr );
         int channelCount = pRequest.getImageChannelCount().read();
         for( int i=0; ichannelCount; i++ )
         {
           System.out.println( String.format( "channel[%d]: %s", i, pRequest.getImageChannelDesc().read( i ) ) );
         }
    }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

    .. code-block:: c++

         fi = getFunctionInterfaceFromSomewhere()
         currentRequestNr = getCurrentRequestNumberFromSomewhere()
         pRequest = fi.getRequest(currentRequestNr)
         channelCount = pRequest.imageChannelCount.read()
         for i in range(channelCount):
           print("channel[", i, "]: ", pRequest.imageChannelDesc.read(i))
    }
    """)
    imageBytesPerPixel = property(lib_mvIMPACT_acquire.Request_imageBytesPerPixel_get, doc=r""" An integer property **(read-only)** containing the number of bytes per pixel in this image.""")
    imageOffsetX = property(lib_mvIMPACT_acquire.Request_imageOffsetX_get, doc=r"""
    An integer property **(read-only)** containing the X-offset of the image in pixels.
    Notes: 
    This feature will be supported by devices using a mvIMPACT Acquire driver greater or equal version 1.10.92.
    """)
    imageOffsetY = property(lib_mvIMPACT_acquire.Request_imageOffsetY_get, doc=r"""
    An integer property **(read-only)** containing the Y-offset of the image in pixels.
    Notes: 
    This feature will be supported by devices using a mvIMPACT Acquire driver greater or equal version 1.10.92.
    """)
    imageWidth = property(lib_mvIMPACT_acquire.Request_imageWidth_get, doc=r""" An integer property **(read-only)** containing the width of the image in pixels.""")
    imageWidthTotal = property(lib_mvIMPACT_acquire.Request_imageWidthTotal_get, doc=r"""
    An integer property **(read-only)** containing the total width of the image in pixels if this buffer is part of a larger image.
    Notes: 
    This feature will be supported by devices using a mvIMPACT Acquire driver greater or equal version 1.11.50. Not
    every device driver will be capable of dealing with multiple buffers forming a single image. If a device driver can
    not deliver parts of a larger image, then this property will always contain the same value as returned by
    **mvIMPACT::acquire::Request::imageWidth**.
    """)
    imageHeight = property(lib_mvIMPACT_acquire.Request_imageHeight_get, doc=r""" An integer property **(read-only)** containing the height of the image in pixels.""")
    imageHeightTotal = property(lib_mvIMPACT_acquire.Request_imageHeightTotal_get, doc=r"""
    An integer property **(read-only)** containing the total height of the image in pixels if this buffer is part of a larger image.
    Notes: 
    This feature will be supported by devices using a mvIMPACT Acquire driver greater or equal version 1.11.50. Not
    every device driver will be capable of dealing with multiple buffers forming a single image. If a device driver can
    not deliver parts of a larger image, then this property will always contain the same value as returned by
    **mvIMPACT::acquire::Request::imageHeight**.
    """)
    imageBayerMosaicParity = property(lib_mvIMPACT_acquire.Request_imageBayerMosaicParity_get, doc=r"""
    An enumerated integer property **(read-only)** containing the Bayer parity of this image.
    If the current image does not contain Bayer data, this value will be **mvIMPACT::acquire::bmpUndefined**.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBayerMosaicParity**.
    """)

    r""" \brief A bool property \b (read-only) which checks if image processing that was set up for this request has been skipped for performance reasons. See mvIMPACT.acquire.Request.getHasProcessingBeenSkipped() """
    hasProcessingBeenSkipped = property (getHasProcessingBeenSkipped, None, None, None)
    r""" \brief A bool property \b (read-only) which checks if a request has been processed successfully. See mvIMPACT.acquire.Request.getIsOK() """
    isOK = property (getIsOK, None, None, None)
    r""" \brief A property \b (read-only) which holds a const reference to the image buffer descriptor of this request. See mvIMPACT.acquire.Request.getImageBufferDesc() """
    imageBufferDesc = property (getImageBufferDesc, None, None, None)
    r""" \brief A property \b (read-only) which holds an iterator for iterating inside the info list of the request. See mvIMPACT.acquire.Request.getInfoIterator() """
    infoIterator = property (getInfoIterator, None, None, None)
    r""" \brief An integer property \b (read-only) which holds the number associated with this request. See mvIMPACT.acquire.Request.getNumber() """
    number = property (getNumber, None, None, None)

    def __disown__(self):
        self.this.disown()
        lib_mvIMPACT_acquire.disown_Request(self)
        return weakref.proxy(self)

# Register Request in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.Request_swigregister(Request)

class ImageRequestControl(ComponentCollection):
    r""" A helper class to control the way an image request will be processed."""

    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"""
         Constructs a new **mvIMPACT::acquire::ImageRequestControl** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type name: string
        :param name: [in] The name of the driver internal image request control to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableImageRequestControls**, new image request controls can be created with the function **mvIMPACT::acquire::FunctionInterface::createImageRequestControl**
        """
        lib_mvIMPACT_acquire.ImageRequestControl_swiginit(self, lib_mvIMPACT_acquire.new_ImageRequestControl(*args))
    mode = property(lib_mvIMPACT_acquire.ImageRequestControl_mode_get, doc=r"""
     The mode this object shall be operated in.
     Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TImageRequestControlMode**.

     This property can e.g. be used to prepare internal data structures without requesting a
     'real' image from the hardware. This can be useful when the image dimensions must be known
     before the first image is captured.
    If: DOXYGEN_CPP_DOCUMENTATION {

    .. code-block:: c++

         Device* pDev = getDevicePointerFromSomewhere();
         ImageRequestControl irc( pDev );
         irc.mode.write( ircmTrial ); // set to prepare mode
         FunctionInterface fi( pDev );
         fi.imageRequestSingle( irc ); // request dummy image
         int reqNr = fi.imageRequestWaitFor( 500 );
         // waitFor will return as fast as possible. No 'real' image will be taken
         // but a request object that contains a dummy image with the format, dimensions
         // and other information will be returned that is (apart from the pixel data)
         // similar to any 'real' image that would be captured with the current settings
    }Else if: DOXYGEN_JAVA_DOCUMENTATION {

    .. code-block:: c++

         Device pDev = getDevicePointerFromSomewhere();
         ImageRequestControl irc = new ImageRequestControl( pDev );
         irc.getMode().write( TImageRequestControlMode.ircmTrial ); // set to prepare mode
         FunctionInterface fi = new FunctionInterface( pDev );
         fi.imageRequestSingle( irc ); // request dummy image
         int reqNr = fi.imageRequestWaitFor( 500 );
         // waitFor will return as fast as possible. No 'real' image will be taken
         // but a request object that contains a dummy image with the format, dimensions
         // and other information will be returned that is (apart from the pixel data)
         // similar to any 'real' image that would be captured with the current settings
    }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

    .. code-block:: c++

         pDev = getDeviceFromSomewhere()
         irc = ImageRequestControl(pDev)
         irc.mode.write(acquire.ircmTrial) # set to prepare mode
         fi = FunctionInterface(pDev)
         fi.imageRequestSingle(irc) # request dummy image
         reqNr = fi.imageRequestWaitFor(500)
         # waitFor will return as fast as possible. No 'real' image will be taken
         # but a request object that contains a dummy image with the format, dimensions
         # and other information will be returned that is (apart from the pixel data)
         # similar to any 'real' image that would be captured with the current settings
    }
    """)
    imageCount = property(lib_mvIMPACT_acquire.ImageRequestControl_imageCount_get, doc=r"""
    An integer property defining the number of images to capture with each request.
    Notes: This property will currently have no effect.
    """)
    setting = property(lib_mvIMPACT_acquire.ImageRequestControl_setting_get, doc=r"""
    An integer property defining which setting will be used for the acquisition.
    This property defines a translation dictionary. It maps the name of the setting (the parameter
    passed to the function **mvIMPACT::acquire::FunctionInterface::createSetting)** to the actual
    underlying handle of the request. Therefore either the name or the handle of the setting can be used
    to set this property to the desired value.
    """)
    resultQueue = property(lib_mvIMPACT_acquire.ImageRequestControl_resultQueue_get, doc=r""" An integer property defining to which result queue the resulting image will be sent after the acquisition.""")
    requestToUse = property(lib_mvIMPACT_acquire.ImageRequestControl_requestToUse_get, doc=r"""
    An integer property defining which request object shall be used for the next image request.
    This is an advanced feature that should only be used if needed. A value smaller than 0 will
    result in an automatic mode. This is the default behaviour and the driver will decide which buffer to use next then.

    A request can only be sent to the driver once. Until this request is returned to the user it can't
    be sent again thus this property must be changed for each request if multiple requests shall be sent to
    the capture queue.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_ImageRequestControl

# Register ImageRequestControl in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.ImageRequestControl_swigregister(ImageRequestControl)

class RequestFactory(object):
    r"""
     A default request factory.
     Applications need to derive from this class and must re-implement the function
     **mvIMPACT::acquire::RequestFactory::createRequest** to work with custom
     objects derived from **mvIMPACT::acquire::Request**.

     Deriving from **mvIMPACT::acquire::Request** can be useful when a certain
     device driver or device offers a custom feature that is returned as part of
     the request object that can not be accessed using the **mvIMPACT::acquire::Request**
     class offered by this interface.

    If: DOXYGEN_CPP_DOCUMENTATION {
     This shows how a request factory could be used to create custom request objects
     from within a **mvIMPACT::acquire::FunctionInterface** instance.

    .. code-block:: c++

         class MyRequestFactory;

         //-----------------------------------------------------------------------------
         // Example for a derived request object. It doesn't introduce new functionality
         // but rebinds an existing property. Custom properties could bound in a similar
         // way.
         class MyRequest : public mvIMPACT::acquire::Request
         //-----------------------------------------------------------------------------
         {
           friend class MyRequestFactory;
           void init( void )
           {
             DeviceComponentLocator locator(getComponentLocator());
             locator.bindComponent( myRequestResult, "Result" );
           }
         protected:
           explicit MyRequest( Device* pDev, int requestNr ) : Request(pDev, requestNr), myRequestResult()
           {
             init();
           }
         public:
           explicit MyRequest( const MyRequest src ) : Request(src), myRequestResult(src.myRequestResult) {}
           MyRequest operator=( const MyRequest rhs )
           {
             if( this != rhs )
             {
               Request::operator=( rhs );
               init();
             }
             return *this;
           }
           PropertyIRequestResult myRequestResult;
         };

         //-----------------------------------------------------------------------------
         // Example for a factory that creates 'MyRequest' instances
         class MyRequestFactory : public mvIMPACT::acquire::RequestFactory
         //-----------------------------------------------------------------------------
         {
         public:
           virtual mvIMPACT::acquire::Request* createRequest( Device* pDev, int requestNr ) { return new MyRequest( pDev, requestNr ); }
         };


     Now the request factory must be passed to the constructor of the function interface

    .. code-block:: c++

         //-----------------------------------------------------------------------------
         void fn( mvIMPACT::acquire::Device* pDev )
         //-----------------------------------------------------------------------------
         {
           // ... some code ...
           MyRequestFactory mrf;
           FunctionInterface fi(pDev, mrf);
           // ... more additional code
           // assuming we got back a request from the driver at this point:
           const Request* pRequest = fi.getRequest( getRequestNrFromSomewhere() );
           if( pRequest-isOK() )
           {
             const MyRequest* pMyRequest(dynamic_castconst MyRequest*(pRequest));
             cout < pMyRequest-myRequestResult.name() < ": " < pMyRequest-myRequestResult.readS() < endl;
             // do what you want to do with your derived request instance here!
           }
           // ... probably even more additional code
         }
    }Else if: DOXYGEN_JAVA_DOCUMENTATION {
     This shows how a request factory could be used to create custom request objects
     from within a **mvIMPACT::acquire::FunctionInterface** instance.

    MyRequest.java:

    .. code-block:: c++

        import mvIMPACT.acquire.*;

        //-----------------------------------------------------------------------------
        // Example for a derived request object. It doesn't introduce new functionality
        // but rebinds an existing property. Custom properties could bound in a similar
        // way.
        class MyRequest extends Request
        //-----------------------------------------------------------------------------
        {
          private PropertyI myRequestResult_ = new PropertyI();

          private void init()
          {
            DeviceComponentLocator locator = new DeviceComponentLocator( getComponentLocator().hObj() );
            locator.bindComponent( myRequestResult_, "Result" );
          }

          protected MyRequest( Device pDev, int requestNr )
          {
            super( pDev, requestNr );
            init();
          }

          // Without this constructor this whole 'RequestFactory' concept will not work
          // at the moment as in 'FunctionInterface.getRequest' the internal correctly
          // constructed 'MyRequest' generated via the director class and 'MyRequestFactory'
          // will be used to create a new 'Request' instance from it. We now use this to
          // re-create yet another 'MyRequest' instance from that which is kind of silly
          // but in Python we have a very similar effect(see corresponding snippet in the Python manual).
          //
          // Maybe there is a better way to do this! Suggestions welcome!
          public MyRequest( Request pRequest )
          {
            super( Request.getCPtr( pRequest ), false );
            init();
          }

          public PropertyI getMyRequestResult()
          {
            return myRequestResult_;
          }
        }

    MyRequestFactory.java:

    .. code-block:: c++

        import mvIMPACT.acquire.*;

        //-----------------------------------------------------------------------------
        // Example for a factory that creates 'MyRequest' instances
        class MyRequestFactory extends RequestFactory
        //-----------------------------------------------------------------------------
        {

          public Request createRequest( Device pDev, int requestNr )
          {
            return new MyRequest( pDev, requestNr );
          }
        }


     Now the request factory must be passed to the constructor of the function interface!
     This might happen in some other source file or class within the application.

    .. code-block:: c++

         //-----------------------------------------------------------------------------
         void fn( Device pDev )
         //-----------------------------------------------------------------------------
         {
           // ... some code ...
           MyRequestFactory mrf = new MyRequestFactory();
           FunctionInterface fi = new FunctionInterface( pDev, mrf );
           // ... more additional code
           // assuming we got back a request from the driver at this point:
           Request pRequest = fi.getRequest( getRequestNrFromSomewhere() );
           if( pRequest-isOK() )
           {
             System.out.println( String.format( "%s: %s", ( ( MyRequest )pRequest ).getMyRequestResult().name(), ( ( MyRequest )pRequest ).getMyRequestResult().readS() );
             // do what you want to do with your derived request instance here!
           }
           // ... probably even more additional code
         }
    }Else if: DOXYGEN_PYTHON_DOCUMENTATION {
     This shows how a request factory could be used to create custom request objects
     from within a **mvIMPACT::acquire::FunctionInterface** instance.

    .. code-block:: c++

        # Example for a derived request object. It doesn't introduce new functionality
        # but rebinds an existing property. Custom properties could bound in a similar
        # way.
        class MyRequest(acquire.Request):
          def __init__(self, *args):
            acquire.Request.__init__(self, *args)
            self.myRequestResult = acquire.PropertyIRequestResult()
            locator = acquire.DeviceComponentLocator(self.getComponentLocator().hObj())
            locator.bindComponent(self.myRequestResult, "Result")

        class MyRequestFactory(acquire.RequestFactory):
          def __init__(self):
            acquire.RequestFactory.__init__(self)
            self.__instances = []

          def createRequest(self, pDev, requestNr):
            try:
              instance = MyRequest(pDev, requestNr)
              # We MUST keep a reference to this request object here as otherwise the instance gets cleaned up
              # by the garbage collector when leaving this function. We therefore add an artificial reference
              # by adding this MyRequest instance to the array which is kind of silly but in Java we have a
              # very similar effect (see corresponding snippet in the Java manual).
              #
              # Maybe there is a better way to do this! Suggestions welcome!
              self.__instances.append(instance)
                return instance
              except Exception as e:
                print("An exception has been raised by code that is not supposed to raise one: '" + str(e) + "'! If this is NOT handled here the application will crash as this Python exception instance will be returned back into the native code that fired this function callS!")
                return None

     Now the request factory must be passed to the constructor of the function interface

    .. code-block:: c++

         def fn(pDev):
           # ... some code ...
           mrf = MyRequestFactory()
           fi = acquire.FunctionInterface(pDev, mrf)
           # ... more additional code
           # assuming we got back a request from the driver at this point:
           pRequest = fi.getRequest(getRequestNrFromSomewhere())
           if pRequest.isOK:
             # The paranoid could do this additional check, but it is not neccessary:
             if type(pRequest) is MyRequest:
               print(pMyRequest.myRequestResult.name() + ": " + pMyRequest.myRequestResult.readS())
             else:
               print("ERROR! We should have an instance of our derived 'MyRequest' class here!")
               sys.exit(-1)
             # do what you want to do with your derived request instance here!
           # ... probably even more additional code
         }
    }

     Since: 1.12.56
    """

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

    def createRequest(self, arg0, arg1):
        return lib_mvIMPACT_acquire.RequestFactory_createRequest(self, arg0, arg1)

    def __init__(self):
        if self.__class__ == RequestFactory:
            _self = None
        else:
            _self = self
        lib_mvIMPACT_acquire.RequestFactory_swiginit(self, lib_mvIMPACT_acquire.new_RequestFactory(_self, ))
    def __disown__(self):
        self.this.disown()
        lib_mvIMPACT_acquire.disown_RequestFactory(self)
        return weakref.proxy(self)

# Register RequestFactory in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.RequestFactory_swigregister(RequestFactory)

class FunctionInterface(object):
    r"""
     The function interface to devices supported by this interface.
     This class contains all the basic functions needed when working with a device.
     There are not too many functions as most data will be represented by 'properties'
     in other classes of this module, keeping the set of functions to remember rather
     small. To construct a new function interface, a pointer to a **mvIMPACT::acquire::Device** object
     must be passed to the constructor of **mvIMPACT::acquire::FunctionInterface**. In order to work
     with the **mvIMPACT::acquire::FunctionInterface** object the device needs to be initialized, so
     if the **mvIMPACT::acquire::Device** object pointed to by *pDev* in the constructors parameter list
     hasn't been opened already the constructor will try to do that.

    Please refer to one of the examples listed below to get an idea on how to use this class for data acquisition:

    If: DOXYGEN_CPP_DOCUMENTATION {
    - 'SingleCapture.cpp'
    - 'ContinuousCapture.cpp'
    }Else if: DOXYGEN_JAVA_DOCUMENTATION {
    - 'ContinuousCapture.java'
    }Else if: DOXYGEN_PYTHON_DOCUMENTATION {
    - 'ContinuousCapture.py'
    }
    """

    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"""
        *Overload 1:*
         Constructs a new function interface for the device pointed to by *pDev*.
         In order to work with the **mvIMPACT::acquire::FunctionInterface** object the device needs to be
         initialized, so if the **mvIMPACT::acquire::Device** object pointed to by *pDev* in the constructors
         parameter list hasn't been opened already the constructor will try to do that.
         Thus internally a call to **mvIMPACT::acquire::Device::open** might be preformed with all consequences
         following from this call.

         See also: 
         **Device::open**

        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type pRequestFactory: :py:class:`RequestFactory`
        :param pRequestFactory: [in] A pointer to a request factory. By supplying a custom request factory the user can control the type of request objects that will be created by the function interface. Since: 1.12.56

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::FunctionInterface** from an existing one.
        :type src: :py:class:`FunctionInterface`
        :param src: [in] A constant reference to the **mvIMPACT::acquire::FunctionInterface** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.FunctionInterface_swiginit(self, lib_mvIMPACT_acquire.new_FunctionInterface(*args))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_FunctionInterface

    def acquisitionStart(self):
        r"""
         Manually starts the acquisition engine of this device driver instance.
         Calling this function will manually start this device driver's acquisition engine. This will only
         have an effect on the overall behaviour if **mvIMPACT::acquire::Device::acquisitionStartStopBehaviour** is
         set to **mvIMPACT::acquire::assbUser**.

         If supported by the device driver, starting and stopping the acquisition engine manually can sometimes
         help to overcome capture queue underruns or certain restrictions in the underlying device driver
         technology.

         See also: 
         **mvIMPACT::acquire::FunctionInterface::acquisitionStop**,

         **mvIMPACT::acquire::FunctionInterface::imageRequestSingle**,

         **mvIMPACT::acquire::Request::unlock**,

         **mvIMPACT::acquire::FunctionInterface::imageRequestUnlock**,

         **mvIMPACT::acquire::FunctionInterface::imageRequestWaitFor**,

         **mvIMPACT::acquire::Request::configure**,

         **mvIMPACT::acquire::FunctionInterface::imageRequestConfigure**

        Since: 1.12.11

         :rtype: int
         :return: 
             - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
             - **mvIMPACT::acquire::DMR_FEATURE_NOT_AVAILABLE** if this device/driver combination does not support manual control over the acquisition engine. This will also happen if **mvIMPACT::acquire::Device::acquisitionStartStopBehaviour** is **NOT** set to **mvIMPACT::acquire::assbUser**.
             - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.
        """
        return lib_mvIMPACT_acquire.FunctionInterface_acquisitionStart(self)

    def acquisitionStop(self):
        r"""
         Manually stops the acquisition engine of this device driver instance.
         Calling this function will manually stop this device drivers acquisition engine. This will only
         have effect on the overall behaviour, if **mvIMPACT::acquire::Device::acquisitionStartStopBehaviour** is
         set to **mvIMPACT::acquire::assbUser**.

         See also: 
         **mvIMPACT::acquire::FunctionInterface::acquisitionStart**,

         **mvIMPACT::acquire::FunctionInterface::imageRequestSingle**,

         **mvIMPACT::acquire::Request::unlock**,

         **mvIMPACT::acquire::FunctionInterface::imageRequestUnlock**,

         **mvIMPACT::acquire::FunctionInterface::imageRequestWaitFor**,

         **mvIMPACT::acquire::Request::configure**,

         **mvIMPACT::acquire::FunctionInterface::imageRequestConfigure**

        Since: 1.12.11

         :rtype: int
         :return: 
             - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
             - **mvIMPACT::acquire::DMR_FEATURE_NOT_AVAILABLE** if this device/driver combination does not support manual control over the acquisition engine. This will also happen if **mvIMPACT::acquire::Device::acquisitionStartStopBehaviour** is **NOT** set to **mvIMPACT::acquire::assbUser**.
             - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.
        """
        return lib_mvIMPACT_acquire.FunctionInterface_acquisitionStop(self)

    def createImageRequestControl(self, *args):
        r"""
         Creates a new **mvIMPACT::acquire::ImageRequestControl** object.
         This function creates a new **mvIMPACT::acquire::ImageRequestControl** based on an existing one. New **mvIMPACT::acquire::ImageRequestControl** instances can only be derived
         from **mvIMPACT::acquire::ImageRequestControl** instances that already exist. When the driver has been initialized there will be at least
         one base **mvIMPACT::acquire::ImageRequestControl** called 'Base', which acts as the base for all other request controls.

         All **mvIMPACT::acquire::ImageRequestControl** constructed by the application must be derived either from this base or any of its children using this function.

         When this function succeeds, the **mvIMPACT::acquire::ImageRequestControl** constructor can be called with the *name* parameter passed to this function
         to get access to this newly registered **mvIMPACT::acquire::ImageRequestControl**.

         Notes: 
         See all comments made under **mvIMPACT::acquire::FunctionInterface::createSetting** for understanding the relationship between base and
         derived **mvIMPACT::acquire::ImageRequestControl** objects.
         :rtype: int
         :return: 
             - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
             - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** or **mvIMPACT::acquire::TPROPHANDLING_ERROR** otherwise.

        :type name: string
        :param name: [in] The name of the new **mvIMPACT::acquire::ImageRequestControl** object.
        :type parent: string
        :param parent: [in] The name of the **mvIMPACT::acquire::ImageRequestControl** the new object shall be derived from.
        :type pNewRequestControl: :py:class:`ComponentList`
        :param pNewRequestControl: [out] A pointer to a **mvIMPACT::acquire::ComponentList** object that will receive the ID of the newly created request control. This parameter can be 0 if the application is not interested in that parameter.
        """
        return lib_mvIMPACT_acquire.FunctionInterface_createImageRequestControl(self, *args)

    def createSetting(self, *args):
        r"""
         Creates a new setting.
         This function creates a new setting base on an existing one. New settings can only be derived
         from settings that already exist. When the driver has been initialized there will be at least
         one base setting called 'Base', which acts as the base for all other settings.

         When a new setting is created it derives all the properties from the parent setting. That means
         initially the new setting will contain the very same data as the parent setting. As long as a
         component hasn't been modified in the new setting it will depend on the parent settings data.
         That means if e.g. a property in the parent list is modified, the newly created setting will
         also benefit from the updated value.

         To release a certain component from this dependency it must be assigned a new value. The function
         **mvIMPACT::acquire::Component::isDefault** will return false afterwards indicating that the component no longer
         depends on the parent.

         To restore this parent <-> child dependency the user can call the function
         **mvIMPACT::acquire::Component::restoreDefault**. Afterwards settings applied to the parent component
         will also be visible in the child component again.

         When a new setting has been created successfully the name used to create the setting can
         be passed to any of the constructors of the setting related classes (**mvIMPACT::acquire::CameraSettingsBase**,
         **mvIMPACT::acquire::ImageProcessing**, ...) to access the new components.
         :rtype: int
         :return: 
             - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
             - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** or **mvIMPACT::acquire::TPROPHANDLING_ERROR** otherwise.

        :type name: string
        :param name: [in] The name of the setting to be created.
        :type parent: string
        :param parent: [in] The name of the setting to derive the new setting from.
        :type pNewSetting: :py:class:`ComponentList`
        :param pNewSetting: [out] A pointer to a **mvIMPACT::acquire::ComponentList** object that will receive the ID of the newly created setting. This parameter can be 0 if the application is not interested in that parameter.
        """
        return lib_mvIMPACT_acquire.FunctionInterface_createSetting(self, *args)

    def deleteSettingFromStack(self):
        r"""
         Deletes the last setting from the setting stack.
         This function deletes the last setting from the setting stack.

         See **mvIMPACT::acquire::FunctionInterface::saveCurrentSettingOnStack** for an example how to use this feature.

        See also: 
        **mvIMPACT::acquire::FunctionInterface::saveCurrentSettingOnStack**

        **mvIMPACT::acquire::FunctionInterface::loadSettingFromStack**

        **mvIMPACT::acquire::FunctionInterface::loadAndDeleteSettingFromStack**


         Since: 2.19.0
         :rtype: int
         :return: 
             - **mvIMPACT::acquire::DMR_NO_ERROR** if the setting is available.
             - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** or **mvIMPACT::acquire::TPROPHANDLING_ERROR** otherwise.
        """
        return lib_mvIMPACT_acquire.FunctionInterface_deleteSettingFromStack(self)

    def deleteSetting(self, *args):
        r"""
         Deletes a setting from the specified location.
         This function deletes a setting from the specified location.

         Since: 2.19.0
         :rtype: int
         :return: 
             - **mvIMPACT::acquire::DMR_NO_ERROR** if the setting is available.
             - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** or **mvIMPACT::acquire::TPROPHANDLING_ERROR** otherwise.

        :type name: string
        :param name: [in] The name or the full path under where the setting is located.
        :type storageLocation: int
        :param storageLocation: [in] The location of the setting.
        :type scope: int
        :param scope: [in] Specifies the scope of this operation.
        """
        return lib_mvIMPACT_acquire.FunctionInterface_deleteSetting(self, *args)

    def getAvailableSettings(self):
        r"""
        Returns the names of the settings available for this **mvIMPACT::acquire::Device**.
        This function returns a const reference to a string array containing the names of all settings available
        for the current **mvIMPACT::acquire::Device**. These names are valid constructor parameters for objects
        like **mvIMPACT::acquire::CameraSettingsBase**, **mvIMPACT::acquire::ImageProcessing**, **mvIMPACT::acquire::ImageDestination** or
        classes derived from these types.

        New settings can be created by calling
        **mvIMPACT::acquire::FunctionInterface::createSetting**
        :rtype: std::vector< std::string,std::allocator< std::string > >
        :return: A const reference to an array containing the names of all request controls available.
        """
        return lib_mvIMPACT_acquire.FunctionInterface_getAvailableSettings(self)

    def getAvailableImageRequestControls(self):
        r"""
        Returns the names of the image request controls available for this **mvIMPACT::acquire::Device**.
        This function returns a const reference to a string array containing the names of all image request controls available
        for the current **mvIMPACT::acquire::Device**. These names are valid constructor parameters for objects
        of the type **mvIMPACT::acquire::ImageRequestControl**.

        New image request controls can be created by calling **mvIMPACT::acquire::FunctionInterface::createImageRequestControl**.
        :rtype: std::vector< std::string,std::allocator< std::string > >
        :return: A const reference to an array containing the names of all settings available.
        """
        return lib_mvIMPACT_acquire.FunctionInterface_getAvailableImageRequestControls(self)

    def getRequest(self, nr):
        r"""
         Returns a pointer to the desired **mvIMPACT::acquire::Request**.
         This function returns a pointer to the **mvIMPACT::acquire::Request** stored at *nr*
         in the internal array of requests.
         If: DOXYGEN_CPP_DOCUMENTATION {
         If *nr* refers to an invalid **mvIMPACT::acquire::Request**

         (e.g. when *nr* is higher than the actual number of

         available requests) a STL out_of_range exception will be thrown.
         }
         :rtype: :py:class:`Request`
         :return: A pointer to a **mvIMPACT::acquire::Request** object.

        :type nr: int
        :param nr: [in] The number of the request to return
        """
        return lib_mvIMPACT_acquire.FunctionInterface_getRequest(self, nr)

    def getSetting(self, name):
        r"""
         Returns a **mvIMPACT::acquire::ComponentList** object to a setting with a specified name.
         This function returns a **mvIMPACT::acquire::ComponentList** object to a setting with a specified name
         or will raise an exception if no such setting exists.

         Since: 1.12.58

         :rtype: :py:class:`ComponentList`
         :return: A **mvIMPACT::acquire::ComponentList** object to a setting with a specified name

        :type name: string
        :param name: [in] The name of the setting to locate
        """
        return lib_mvIMPACT_acquire.FunctionInterface_getSetting(self, name)

    def imageRequestConfigure(self, pRequest):
        r"""
         Sets a request into configuration mode.
         Notes: 
         Another version of this function is available that might be nicer to use depending on personal
         preferences and use case: **mvIMPACT::acquire::Request::configure**.

         In configuration mode certain properties like **mvIMPACT::acquire::Request::imageData**,
         **mvIMPACT::acquire::Request::imageSize**, **mvIMPACT::acquire::Request::imageMemoryMode**
         of a request object can be modified. This can be used to configure one or more requests
         to use a user supplied memory. To use only a subset of the **mvIMPACT::acquire::Request**
         objects available the **mvIMPACT::acquire::ImageRequestControl::requestToUse** feature
         can be used.

         Only requests that are currently not used by the driver and are not locked
         because they contain image data that hasn't been processed can be set into
         configuration mode.


         Instead of calling this function directly for most cases it is much more convenient to use
         the functions **mvIMPACT::acquire::Request::attachUserBuffer** and **mvIMPACT::acquire::Request::detachUserBuffer**
         instead.

         User supplied buffers must follow the alignment and size requirements reported by versions of the
         function **mvIMPACT::acquire::FunctionInterface::getCurrentCaptureBufferLayout**. Calling
         a version of this function will return all the information required to allocate buffers that
         can be used to capture data for the specified settings.

         When allocating memory on the heap, the complete buffer size is needed which is calculated like
         this:

         **size** + alignment


         The address passed to the request object must be aligned already!

        If: DOXYGEN_CPP_DOCUMENTATION {

        .. code-block:: c++

             Device* pDev = getDevicePointerFromSomewhere()
             FunctionInterface fi( pDev );
             ImageRequestControl irc( pDev );
             int bufferSize = 0;
             int bufferAlignment = 0;
             const TDMR_ERROR result = static_castTDMR_ERROR( fi.getCurrentCaptureBufferLayout( irc, bufferSize, bufferAlignment ) );
             Request* pRequest = fi.getRequest( 0 );
             // the buffer assigned to the request object must be aligned accordingly
             // the size of the user supplied buffer MUST NOT include the additional size
             // caused by the alignment
             if( pRequest-attachUserBuffer( getAlignedMemoryPtr( bufferSize, bufferAlignment ), bufferSize ) == DMR_NO_ERROR )
             {
               irc.requestToUse.write( 0 ); // use the buffer just configured for the next image request
               // now the next image will be captured into the user supplied memory
               fi.imageRequestSingle( irc ); // this will send request '0' to the driver
               // wait for the buffer. Once it has been returned by the driver AND the user buffer shall no
               // longer be used call
               if( pRequest-detachUserBuffer() != DMR_NO_ERROR )
               {
                 // handle error
               }
               // now this request will use internal memory again.
             }
             else
             {
                // handle error
             }
        }Else if: DOXYGEN_JAVA_DOCUMENTATION {
        Warning: There is currently no way to deal with alignment in Java when capturing into user supplied(thus managed) memory! Suggestions welcome!

        .. code-block:: c++

             import java.nio.ByteBuffer;

            // ...

             Device pDev = getDevicePointerFromSomewhere()
             FunctionInterface fi = new FunctionInterface( pDev );
             ImageRequestControl irc = new ImageRequestControl( pDev );
             int[] bufferSize = {0};
             int[] bufferAlignment = {0};
             if( fi.getCurrentCaptureBufferLayout( irc, bufferSize, bufferAlignment ) == TDMR_ERROR.DMR_NO_ERROR )
             {
               Request pRequest = fi.getRequest( 0 );
               // the buffer assigned to the request object must be aligned accordingly
               // the size of the user supplied buffer MUST NOT include the additional size
               // caused by the alignment
               ByteBuffer pBuffer = ByteBuffer.allocateDirect( bufferSize[0] + bufferAlignment[0] ); // todo: There is currently no way to deal with alignment in Java! Suggestions welcome!
               if( pRequest.attachUserBuffer( pBuffer ) == TDMR_ERROR.DMR_NO_ERROR )
               {
                 irc.getRequestToUse().write( 0 ); // use the buffer just configured for the next image request
                 // now the next image will be captured into the user supplied memory
                 fi.imageRequestSingle( irc ); // this will send request '0' to the driver
                 // wait for the buffer. Once it has been returned by the driver AND the user buffer shall no
                 // longer be used call
                 if( pRequest.detachUserBuffer() != TDMR_ERROR.DMR_NO_ERROR )
                 {
                   // handle error
                 }
                 // now this request will use internal memory again.
               }
               else
               {
                  // handle error
               }
             }
             else
             {
                // handle error
             }
        }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

        .. code-block:: c++

             pDev = getDevicePointerFromSomewhere()
             fi = acquire.FunctionInterface(pDev)
             irc = acquire.ImageRequestControl(pDev)
             # this function returns a list containing [result, size, alignment]
             results = fi.getCurrentCaptureBufferLayout(irc)
             if results[0] == int(acquire.DMR_NO_ERROR):
               pRequest = fi.getRequest(0)
               # the buffer assigned to the request object must be aligned accordingly
               # the size of the user supplied buffer MUST NOT include the additional size
               # caused by the alignment
               if pRequest.attachUserBuffer(getAlignedMemoryPtr(results[1], results[2] ), results[2]) == int(acquire.DMR_NO_ERROR):
                 irc.requestToUse.write(0) # use the buffer just configured for the next image request
                 # now the next image will be captured into the user supplied memory
                 fi.imageRequestSingle(irc) # this will send request '0' to the driver
                 # wait for the buffer. Once it has been returned by the driver AND the user buffer shall no
                 # longer be used call
                 if pRequest.detachUserBuffer() != TDMR_ERROR.DMR_NO_ERROR:
                   # handle error
                 # now this request will use internal memory again.
               else:
                  # handle error
             else:
                # handle error
        }

         A request that is in configuration mode can't be sent to the driver for acquisition until
         **mvIMPACT::acquire::Request::unlock** or **mvIMPACT::acquire::FunctionInterface::imageRequestUnlock** has been called again.
         By using **mvIMPACT::acquire::Request::attachUserBuffer** and **mvIMPACT::acquire::Request::detachUserBuffer** this locking
         and unlocking is done internally thus the application does not need to worry about this.

         See also: 
         **mvIMPACT::acquire::Request::configure**,

         **mvIMPACT::acquire::FunctionInterface::imageRequestSingle**,

         **mvIMPACT::acquire::Request::attachUserBuffer**,

         **mvIMPACT::acquire::Request::detachUserBuffer**,

         **mvIMPACT::acquire::Request::unlock**,

         **mvIMPACT::acquire::FunctionInterface::imageRequestUnlock**,

         **mvIMPACT::acquire::FunctionInterface::imageRequestWaitFor**,

         **mvIMPACT::acquire::FunctionInterface::imageRequestReset**

        Since: 1.10.31

         :rtype: int
         :return: 
             - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
             - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.

        :type pRequest: :py:class:`Request`
        :param pRequest: [in] A const pointer to the request object to configure
        """
        return lib_mvIMPACT_acquire.FunctionInterface_imageRequestConfigure(self, pRequest)

    def imageRequestResultQueueElementCount(self, queueNr=0):
        r"""
         Returns the number of **mvIMPACT::acquire::Request** objects in the result queue .
         This functions queries the number of **mvIMPACT::acquire::Request** objects currently in the result queue

         See also: 
         **mvIMPACT::acquire::FunctionInterface::acquisitionStart**,

         **mvIMPACT::acquire::FunctionInterface::acquisitionStop**,

         **mvIMPACT::acquire::FunctionInterface::imageRequestReset**,

         **mvIMPACT::acquire::Request::unlock**,

         **mvIMPACT::acquire::FunctionInterface::imageRequestUnlock**,

         **mvIMPACT::acquire::FunctionInterface::imageRequestResultQueueElementCount**,

         **mvIMPACT::acquire::FunctionInterface::imageRequestWaitFor**

         **mvIMPACT::acquire::Request::configure**,

         **mvIMPACT::acquire::FunctionInterface::imageRequestConfigure**

        Since: 2.9.0

         :rtype: int
         :return: 
             - The number of **mvIMPACT::acquire::Request** objects in the result queue if successful.
             - **mvIMPACT::acquire::DMR_INVALID_QUEUE_SELECTION** if the selected result queue does not exist.
             - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.

        :type queueNr: int
        :param queueNr: [in] The result queue to be queried.
        """
        return lib_mvIMPACT_acquire.FunctionInterface_imageRequestResultQueueElementCount(self, queueNr)

    def imageRequestReset(self, requestCtrlNr, mode):
        r"""
         Deletes all requests currently queued for the specified **mvIMPACT::acquire::ImageRequestControl**.
         This function will terminate all running image acquisitions associated with the queue
         bound to the specified image request control and in addition to that
         will empty the queue of pending image requests for that queue. Also all requests that reside in the
         result queue and have not been picked up by the application will be unlocked and removed from the
         result queue. So after this function returns only the requests currently in possession of the
         application (so requests that have been picked up by successful calls to **mvIMPACT::acquire::FunctionInterface::imageRequestWaitFor**
         that have **NOT** been unlocked) need to be handled. All other requests are in a state where they
         can be queued for an acquisition again.

         See also: 
         **mvIMPACT::acquire::FunctionInterface::imageRequestSingle**,

         **mvIMPACT::acquire::Request::unlock**,

         **mvIMPACT::acquire::FunctionInterface::imageRequestUnlock**,

         **mvIMPACT::acquire::FunctionInterface::imageRequestWaitFor**,

         **mvIMPACT::acquire::Request::configure**,

         **mvIMPACT::acquire::FunctionInterface::imageRequestConfigure**
         :rtype: int
         :return: 
             - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
             - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.

        :type requestCtrlNr: int
        :param requestCtrlNr: [in] The **mvIMPACT::acquire::ImageRequestControl** for which all the requests shall be cancelled.
        :type mode: int
        :param mode: [in] Currently unsupported. MUST be set 0.
        """
        return lib_mvIMPACT_acquire.FunctionInterface_imageRequestReset(self, requestCtrlNr, mode)

    def imageRequestUnlock(self, nr):
        r"""
         Unlocks the request for the driver again.
        Notes: 
         Another version of this function is available that might be nicer to use depending on personal
         preferences and use case: **mvIMPACT::acquire::Request::unlock**. Unlocking a certain request
         might be nicer by using this function, e.g. unlocking **ALL** requests in a loop is probably easier
         done by writing
        If: DOXYGEN_CPP_DOCUMENTATION {

        .. code-block:: c++

             Device* pDev = getDevicePointerFromSomewhere()
             FunctionInterface fi( pDev );
             const int rc = static_cast int ( fi.requestCount() );
             for( int i=0; irc; i++ )
             {
               fi.imageRequestUnlock( i );
             }
        }Else if: DOXYGEN_JAVA_DOCUMENTATION {

        .. code-block:: c++

             Device pDev = getDevicePointerFromSomewhere()
             FunctionInterface fi = new FunctionInterface( pDev );
             final long rc = fi.requestCount();
             for( long i=0; irc; i++ )
             {
               fi.imageRequestUnlock( ( int )i );
             }
        }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

        .. code-block:: c++

             pDev = getDevicePointerFromSomewhere()
             fi = acquire.FunctionInterface(pDev)
             rc = fi.requestCount()
             for i in range(rc):
               fi.imageRequestUnlock(i)
        }

         To ensure that no image data is overwritten by another image request while the user still
         deals with the image from a previous acquisition each image buffer will be locked by the driver when
         it is returned to the user by a call to **mvIMPACT::acquire::FunctionInterface::imageRequestWaitFor**.
         No new image will be captured into the same buffer until the user unlocks the buffer again
         by calling **mvIMPACT::acquire::FunctionInterface::imageRequestUnlock**.


         After unlocking a request it is no longer guaranteed that the memory once referenced by the
         request and the image buffer belonging to it stays valid, so do **NEVER** try to access
         memory belonging to an unlocked request object. If you need to copy the image buffer or
         modify it in any other way, do everything you have to do **BEFORE** calling this function!

         See also: 
         **mvIMPACT::acquire::FunctionInterface::imageRequestReset**,

         **mvIMPACT::acquire::FunctionInterface::imageRequestSingle**,

         **mvIMPACT::acquire::FunctionInterface::imageRequestWaitFor**,

         **mvIMPACT::acquire::FunctionInterface::imageRequestResultQueueElementCount**,

         **mvIMPACT::acquire::FunctionInterface::imageRequestConfigure**,

         **mvIMPACT::acquire::Request::configure**
         :rtype: int
         :return: 
             - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
             - **mvIMPACT::acquire::DEV_REQUEST_CANT_BE_UNLOCKED** if the request number defined by *nr* is currently not owned by the application (either already unlocked or queued for acquisition).
             - **mvIMPACT::acquire::DMR_INPUT_BUFFER_TOO_SMALL** if the request number defined by *nr* has been configured to capture into a user supplied buffer but the buffer is too small to acquire data into.
             - **mvIMPACT::acquire::DEV_REQUEST_BUFFER_MISALIGNED** if the request number defined by *nr* has been configured to capture into a user supplied buffer but this buffer is not aligned in order to the alignment restrictions reported by this driver/device combination.
             - **mvIMPACT::acquire::DEV_REQUEST_BUFFER_INVALID** if the request number defined by *nr* has been configured to capture into a user supplied buffer but an invalid (NULL) pointer has been attached to the request.
             - **mvIMPACT::acquire::DEV_INVALID_REQUEST_NUMBER** if the request number defined by *nr* is invalid (out of bounds).
             - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.

        :type nr: int
        :param nr: [in] The number of the request to unlock. This is typically a value returned from a call to **mvIMPACT::acquire::FunctionInterface::imageRequestWaitFor**.
        """
        return lib_mvIMPACT_acquire.FunctionInterface_imageRequestUnlock(self, nr)

    def imageRequestWaitFor(self, timeout_ms, queueNr=0):
        r"""
         Waits for a request object to become ready.
         This function waits for a request object previously sent to the capture device by calling
         **mvIMPACT::acquire::FunctionInterface::imageRequestSingle**. When a new request became ready during
         the period of time specified by the *timeout_ms* parameter this request is extracted from the
         result queue and is returned to the user so the same request can not be returned twice until
         it has been processed and unlocked by the application.

         Notes: Whenever a **mvIMPACT::acquire::Request** is returned to the user the image data
         described by the **mvIMPACT::acquire::Request** remains valid until the user unlocks
         the image buffer again or the driver is closed.

         See also: 
         **mvIMPACT::acquire::Request::unlock**,

         **mvIMPACT::acquire::FunctionInterface::imageRequestUnlock**,

         **mvIMPACT::acquire::FunctionInterface::imageRequestResultQueueElementCount**,

         **mvIMPACT::acquire::FunctionInterface::getRequest**
         :rtype: int
         :return: If the return value is positive, the return value is the request number of the
             image request in the interface's internal array of image requests. In this case the user
             can call **mvIMPACT::acquire::FunctionInterface::getRequest** to get access to the
             results.

            If the result is negative, the return value is an error code.
             The error code that is returned in most cases will be **mvIMPACT::acquire::DEV_WAIT_FOR_REQUEST_FAILED**.
             To find out possible reasons for this error, look at the corresponding explanation.

        :type timeout_ms: int
        :param timeout_ms: [in] The maximum wait time in milliseconds (ms) for this request to become ready. If *timeout_ms* is '-1', the function's timeout interval never elapses. If the result queue specified by the *queueNr* parameter already contains a request when calling this function the function will return immediately. Please note that each request has its own timeout that is independent from this wait timeout, thus this function will return with a valid request after the timeout for this request has elapsed even if e.g. a trigger has not been detected. For detailed information on the interaction of the timeout of this function and the timeout of a request please refer to the chapter 'ImageAcquisition_capture_AcquiringData' in the C++ section.
        :type queueNr: int
        :param queueNr: [in] The queue where to wait for the request. The number of request queues available depends on the number of video channels offered by the device. The queue a processed request ends up in can be defined by setting the property **mvIMPACT::acquire::ImageRequestControl::resultQueue** **BEFORE** calling **mvIMPACT::acquire::FunctionInterface::imageRequestSingle**.
        """
        return lib_mvIMPACT_acquire.FunctionInterface_imageRequestWaitFor(self, timeout_ms, queueNr)

    def getCurrentCaptureBufferLayout(self, imageRequestControl):
        r"""
         Returns information about the current capture buffer requirements.
         When an application wants to provide capture buffers, this function will be needed in order to
         get information on how the capture buffers must be constructed.

         To find out more about capturing to user memory please refer to the application
         'CaptureToUserMemory.cpp'

         See also: 
         **mvIMPACT::acquire::Request::configure**

         Since: 1.12.68

         :rtype: int
         :return: 
             - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
             - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.

        :type imageRequestControl: :py:class:`ImageRequestControl`
        :param imageRequestControl: [in] A reference to the **mvIMPACT::acquire::ImageRequestControl** object containing the setting for which the current capture buffer layout shall be queried. The setting can be defined via the property **mvIMPACT::acquire::ImageRequestControl::setting**.
        :type size: int
        :param size: [out] On a successful call this variable will receive the size needed for capturing into user supplied buffers that use the current settings.
        :type alignment: int
        :param alignment: [out] On a successful call this variable will receive the alignment needed for capturing into user supplied buffers that use the current settings.
        """
        return lib_mvIMPACT_acquire.FunctionInterface_getCurrentCaptureBufferLayout(self, imageRequestControl)

    def isRequestNrValid(self, nr):
        r"""
        Check if *nr* specifies a valid **mvIMPACT::acquire::Request**.
        :rtype: boolean
        :return: 

            - true if *nr* specifies a valid request.
            - false otherwise
        """
        return lib_mvIMPACT_acquire.FunctionInterface_isRequestNrValid(self, nr)

    def isSettingAvailable(self, *args):
        r"""
         Checks if a certain setting is available under the specified location.
         This function checks if a certain setting is available under the specified location.

         Since: 2.19.0
         :rtype: int
         :return: 
             - **mvIMPACT::acquire::DMR_NO_ERROR** if the setting is available.
             - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** or **mvIMPACT::acquire::TPROPHANDLING_ERROR** otherwise.

        :type name: string
        :param name: [in] The name or the full path under where the setting is located.
        :type storageLocation: int
        :param storageLocation: [in] The location of the setting.
        :type scope: int
        :param scope: [in] Specifies the scope of this operation.
        """
        return lib_mvIMPACT_acquire.FunctionInterface_isSettingAvailable(self, *args)

    def loadSetting(self, *args):
        r"""
         Loads a previously stored setting.
         This function can be used to restore a previously stored setting again.

         To load a setting from a file the **mvIMPACT::acquire::sfFile** should be specified
         as part of *storageFlags*. To load a setting from a platform specific location
         such as the Registry under Windows(C) **mvIMPACT::acquire::sfNative** should be
         specified. It's not allowed to combine **mvIMPACT::acquire::sfFile** and
         **mvIMPACT::acquire::sfNative** for this operation.

         Warning: Since mvIMPACT Acquire 2.9.0 GenICam devices will be able to save their properties in a XML File, only if the properties have the **streamable** attribute set (for more information refer to the GenICam standard specification ("http://www.emva.org/standards-technology/genicam/genicam-downloads/")). Properties with no **streamable** attribute set, will be silently ignored when saving, which means they will **not** be saved in the XML file. For MATRIX VISION GenICam cameras, starting with firmware version 1.6.414 the **streamable** attribute is set for all the necessary properties.




         Since mvIMPACT Acquire 2.9.0 and again in version 2.11.0 storing and loading of camera settings in a XML file for the **mvIMPACT::acquire::dilGenICam**
         interface layout has been updated. As a result XML files created with newer versions of mvIMPACT Acquire might **not**
         be readable on systems with older version of mvIMPACT Acquire installed. XML files created on systems
         with earlier versions of mvIMPACT Acquire will always be readable this or newer versions. See the following table for details.

           -----------------------
           |%mvIMPACT Acquire Version|Loading a XML settings file created with %mvIMPACT Acquire version < 2.9.0|Loading a XML settings file created with %mvIMPACT Acquire version 2.9.0 - 2.10.1|Loading a XML settings file created with %mvIMPACT Acquire version 2.11.0 or later
           -----------------------
           | < 2.9.0 | YES | NO | NO
           -----------------------
           | 2.9.0 - 2.10.1 | YES | YES | NO
           -----------------------
           | >= 2.11.0 | YES | YES | YES


         Since mvIMPACT Acquire 2.28.0 it is possible for devices operated in the **::dilGenICam** interface layout to store settings including
         sequencer sets and user sets (see SFNC for details) data by specifying the **::sfProcessGenICamSequencerData** and/or **::sfProcessGenICamUserSetData**
         during the storage operation. Settings stored like this cannot be loaded by previous mvIMPACT Acquire versions.

         Notes: For devices operated in the **mvIMPACT::acquire::dilGenICam** interface layout further restriction apply: Settings created with a certain product type can only
         be used with other devices belonging to the exact same type as defined by the property mvIMPACT::acquire::Device::product inside the device list (the one device specific property list that
         is accessible without initialising the device before). Even if a setting can be used with various firmware versions it is recommended to use one setting
         for multiple devices all updated to the very same firmware version to avoid compatibility problems.

         See also: 
         **mvIMPACT::acquire::FunctionInterface::saveSetting**.
         :rtype: int
         :return: 
             - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
             - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** or **mvIMPACT::acquire::TPROPHANDLING_ERROR** otherwise.

        :type name: string
        :param name: [in] The name or the full path under where the setting is located.
        :type storageFlags: int
        :param storageFlags: [in] The flags which define which information shall be read from the location and how this information shall be interpreted.
        :type scope: int
        :param scope: [in] Specifies where the information is located.
        """
        return lib_mvIMPACT_acquire.FunctionInterface_loadSetting(self, *args)

    def loadSettingFromStack(self):
        r"""
         loads the last setting from the setting stack.
         This function loads the last setting from the setting stack.

         See **mvIMPACT::acquire::FunctionInterface::saveCurrentSettingOnStack** for an example how to use this feature.

         See also **mvIMPACT::acquire::FunctionInterface::loadSetting** to find out which features of a GenICam device
         are stored in a setting and which are not!

        See also: 
        **mvIMPACT::acquire::FunctionInterface::saveCurrentSettingOnStack**

        **mvIMPACT::acquire::FunctionInterface::deleteSettingFromStack**

        **mvIMPACT::acquire::FunctionInterface::loadAndDeleteSettingFromStack**


         Since: 2.19.0
         :rtype: int
         :return: 
             - **mvIMPACT::acquire::DMR_NO_ERROR** if the setting is available.
             - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** or **mvIMPACT::acquire::TPROPHANDLING_ERROR** otherwise.
        """
        return lib_mvIMPACT_acquire.FunctionInterface_loadSettingFromStack(self)

    def loadAndDeleteSettingFromStack(self):
        r"""
         loads the last setting from the setting stack and then removes this setting from the stack.
         This function loads the last setting from the setting stack and then removes this setting from the stack.

         See **mvIMPACT::acquire::FunctionInterface::saveCurrentSettingOnStack** for an example how to use this feature.

         See also **mvIMPACT::acquire::FunctionInterface::loadSetting** to find out which features of a GenICam device
         are stored in a setting and which are not!

        See also: 
        **mvIMPACT::acquire::FunctionInterface::saveCurrentSettingOnStack**

        **mvIMPACT::acquire::FunctionInterface::deleteSettingFromStack**

        **mvIMPACT::acquire::FunctionInterface::loadSettingFromStack**


         Since: 2.19.0
         :rtype: int
         :return: 
             - **mvIMPACT::acquire::DMR_NO_ERROR** if the setting is available.
             - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** or **mvIMPACT::acquire::TPROPHANDLING_ERROR** otherwise.
        """
        return lib_mvIMPACT_acquire.FunctionInterface_loadAndDeleteSettingFromStack(self)

    def loadSettingFromDefault(self, *args):
        r"""
         Loads the default settings.
         This function will try to load the settings from a default location. This function
         can only succeed if a setting has been stored previously by a call to
         **mvIMPACT::acquire::FunctionInterface::saveSettingToDefault**.

         Warning: There has been an incompatible change when loading settings in version 2.9.0 and 2.11.0 of mvIMPACT Acquire as well as in version 2.28.0. See **mvIMPACT::acquire::FunctionInterface::loadSetting** for details.

         :rtype: int
         :return: 
             - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
             - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** or **mvIMPACT::acquire::TPROPHANDLING_ERROR** otherwise.

        :type scope: int
        :param scope: [in] Specifies where the information is located.
        """
        return lib_mvIMPACT_acquire.FunctionInterface_loadSettingFromDefault(self, *args)

    def requestCount(self):
        r"""
        Returns the number of available request objects.
        See also: 
        **mvIMPACT::acquire::SystemSettings::requestCount** to change the number of request objects

        :rtype: int
        :return: Returns the number of available request objects.
        """
        return lib_mvIMPACT_acquire.FunctionInterface_requestCount(self)

    def saveCurrentSettingOnStack(self, *args):
        r"""
         Saves the current setting on the setting stack.
         This function saves the current setting on the setting stack. Together which the
         functions mentioned below this implements a stack for capture settings. This can
         become handy when entering a section of code that might modify the current capture settings
         in various ways and depending on the result these modifications shall either be kept or
         discarded at the end of the operation.

        If: DOXYGEN_CPP_DOCUMENTATION {

        .. code-block:: c++

             // ...
             enum TResult
             {
               rApply,
               rDiscard
             };
             // ...
             FunctionInterface fi = getFunctionInterfaceFromSomewhere();
             fi.saveCurrentSettingOnStack();
             switch( enterSectionThatModifiesDeviceSettings() )
             {
             case rDiscard:
                 fi.loadAndDeleteSettingFromStack(); // revert all changes just applied without worrying about what these changes actually are
                 break;
             case rApply:
                 fi.deleteSettingFromStack(); // remove the setting from the stack, but keep changes
                 break;
             }
        }Else if: DOXYGEN_JAVA_DOCUMENTATION {

        .. code-block:: c++

             // ...
             final int Apply = 1;
             final int Discard = 2;
             // ...
             FunctionInterface fi = getFunctionInterfaceFromSomewhere();
             fi.saveCurrentSettingOnStack();
             final int option = enterSectionThatModifiesDeviceSettings();
             if( option == Discard )
             {
               fi.loadAndDeleteSettingFromStack(); // revert all changes just applied without worrying about what these changes actually are
             }
             else if( option == Apply )
             {
               fi.deleteSettingFromStack(); // remove the setting from the stack, but keep changes
             }
        }Else if: DOXYGEN_PYTHON_DOCUMENTATION {
        DISCARD_SETTING = 1
        APPLY_SETTING = 2
        fi = getFunctionInterfaceFromSomewhere()
        fi.saveCurrentSettingOnStack()
        option = enterSectionThatModifiesDeviceSettings()
        if option == DISCARD_SETTING: # discard
           fi.loadAndDeleteSettingFromStack() # revert all changes just applied without worrying about what these changes actually are
        elif option == APPLY_SETTING: # apply
           fi.deleteSettingFromStack() # remove the setting from the stack, but keep changes
        }

         The stack makes use of mvIMPACT Acquires ability to store capture settings in the memory of
         the current process. Once the last instance of this **mvIMPACT::acquire::FunctionInterface**
         object is deleted all settings pushed on this stack will be deleted automatically.

        See also: 
        **mvIMPACT::acquire::FunctionInterface::deleteSettingFromStack**

        **mvIMPACT::acquire::FunctionInterface::loadSettingFromStack**

        **mvIMPACT::acquire::FunctionInterface::loadAndDeleteSettingFromStack**


         Since: 2.19.0
         :rtype: int
         :return: 
             - **mvIMPACT::acquire::DMR_NO_ERROR** if the setting is available.
             - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** or **mvIMPACT::acquire::TPROPHANDLING_ERROR** otherwise.

        :type storageFlags: int
        :param storageFlags: [in] The flags which define which information shall be stored and how this information shall be stored.
        """
        return lib_mvIMPACT_acquire.FunctionInterface_saveCurrentSettingOnStack(self, *args)

    def saveSetting(self, *args):
        r"""
         Stores the current settings.
         This function can be used to store the current settings either in a XML-file or
         (under Windows(C)) into the Registry. A setting contains all the values set
         for properties that control the overall way an image is acquired( e.g. the exposure time, etc.).

         To store a setting in a file the **mvIMPACT::acquire::sfFile** should be specified
         as part of *storageFlags*. To store a setting in a platform specific location
         such as the Registry under Windows(C) **mvIMPACT::acquire::sfNative** should be
         specified. Both flags can be combined. In that case the same setting will be stored in a
         file **AND** in a platform specific location if these location differ (platform dependent!).

         Warning: There has been an incompatible change when loading settings in version 2.9.0 and 2.11.0 of mvIMPACT Acquire as well as in version 2.28.0. See **mvIMPACT::acquire::FunctionInterface::loadSetting** for details.

         :rtype: int
         :return: 
             - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
             - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** or **mvIMPACT::acquire::TPROPHANDLING_ERROR** otherwise.

        :type name: string
        :param name: [in] The name or the full path under which this setting shall be stored
        :type storageFlags: int
        :param storageFlags: [in] The flags which define which information shall be stored and how this information shall be stored.
        :type scope: int
        :param scope: [in] Specifies where the information shall be stored.
        """
        return lib_mvIMPACT_acquire.FunctionInterface_saveSetting(self, *args)

    def saveSettingToDefault(self, *args):
        r"""
         Stores the current settings under a default location.
         Under Windows(C) this will be in the Registry. A setting contains all the values set
         for properties that control the overall way an image is acquired( e.g. the exposure time, etc.).

         Warning: There has been an incompatible change when loading settings in version 2.9.0 and 2.11.0 of mvIMPACT Acquire as well as in version 2.28.0. See **mvIMPACT::acquire::FunctionInterface::loadSetting** for details.

         :rtype: int
         :return: 
             - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
             - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** or **mvIMPACT::acquire::TPROPHANDLING_ERROR** otherwise.

        :type scope: int
        :param scope: [in] Specifies where the information shall be stored.
        """
        return lib_mvIMPACT_acquire.FunctionInterface_saveSettingToDefault(self, *args)

    def imageRequestSingle(self, *args):
        return lib_mvIMPACT_acquire.FunctionInterface_imageRequestSingle(self, *args)

    r""" \brief A list property \b (read-only) which returns the names of the settings available for this mvIMPACT.acquire.Device. See mvIMPACT.acquire.FunctionInterface.getAvailableSettings() """
    availableSettings = property (getAvailableSettings, None, None, None)
    r""" \brief A list property \b (read-only) which returns the names of the image request controls available for this mvIMPACT.acquire.Device. See mvIMPACT.acquire.FunctionInterface.getAvailableImageRequestControls() """
    availableImageRequestControls = property (getAvailableImageRequestControls, None, None, None)


# Register FunctionInterface in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.FunctionInterface_swigregister(FunctionInterface)

class Info(ComponentCollection):
    r"""
    A base class to access various general information about the device and its driver.
    This class contains a collection of properties providing various information about
    the device and its driver.

    Instances of this class can't be constructed directly. Use one of the derived types.
    """

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

    def __init__(self, pDev):
        r"""
         Constructs a new **mvIMPACT::acquire::Info** object.
        :type pDev: :py:class:`Device`
        :param pDev: A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        """
        lib_mvIMPACT_acquire.Info_swiginit(self, lib_mvIMPACT_acquire.new_Info(pDev))
    deviceDriverVersion = property(lib_mvIMPACT_acquire.Info_deviceDriverVersion_get, doc=r"""
    An integer property **(read-only)** containing the device driver version used by this device.
    This is the version of the underlying hardware driver. For device drivers that don't have another
    user mode driver below the interface driver this property will contain the same version information
    as the property **mvIMPACT::acquire::Info::driverVersion**.
    """)
    driverDate = property(lib_mvIMPACT_acquire.Info_driverDate_get, doc=r""" A string property **(read-only)** containing the date the device driver has been compiled.""")
    driverVersion = property(lib_mvIMPACT_acquire.Info_driverVersion_get, doc=r""" A string property **(read-only)** containing the version number of the device driver.""")
    state = property(lib_mvIMPACT_acquire.Info_state_get, doc=r"""
    An enumerated integer property **(read-only)** containing the current state of this device.
    This property e.g. provides information about the current state of the device. For USB devices this can e.g. indicate whether
    a device is currently plugged into the system or not.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDeviceState**.

    **GenICam/GenTL** **device** **specific**:
    In order to reduce the amount of network traffic to a minimum, this property will only be updated automatically
    for network devices if the property **mvIMPACT::acquire::Device::registerErrorEvent** is set to
    **mvIMPACT::acquire::bTrue** (which is the default behaviour). If the IP addresses stay the same the
    connection is automatically re-established then once the device is detected by the driver again.
    However if the IP address of the device and/or the network adapter of the system it is used from changes
    **mvIMPACT::acquire::DeviceManager::updateDeviceList()**
    must be called regardless of the value of **mvIMPACT::acquire::Device::registerErrorEvent** before a device
    that was lost can re-establish a connection to the capture driver.
    """)
    loadedSettings = property(lib_mvIMPACT_acquire.Info_loadedSettings_get, doc=r""" A string property **(read-only)** containing the name of the setting currently loaded.""")
    logFile = property(lib_mvIMPACT_acquire.Info_logFile_get, doc=r""" A string property **(read-only)** containing the name and the full path of the current log-file for this device.""")
    captureBufferAlignment = property(lib_mvIMPACT_acquire.Info_captureBufferAlignment_get, doc=r""" An integer property **(read-only)** containing the capture buffer alignment in bytes needed by this device driver.""")
    recommendedListsForUIs = property(lib_mvIMPACT_acquire.Info_recommendedListsForUIs_get, doc=r""" A string property **(read-only)** containing an array of full search paths to lists which are recommended to be displayed in a user interface that is created dynamically.""")
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_Info

# Register Info in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.Info_swigregister(Info)

class BasicDeviceSettings(ComponentCollection):
    r"""
    A base class for essential device related settings.
    This class acts as a base class for essential device related settings. It only contains
    features that are available for every device.

    Since: 1.12.58
    """

    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"""
         brief Constructs a new **mvIMPACT::acquire::BasicDeviceSettings** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.BasicDeviceSettings_swiginit(self, lib_mvIMPACT_acquire.new_BasicDeviceSettings(*args))
    basedOn = property(lib_mvIMPACT_acquire.BasicDeviceSettings_basedOn_get, doc=r"""
    A string property **(read-only)** containing the name of the setting this setting is based on.
    Since: 1.12.67
    """)
    imageRequestTimeout_ms = property(lib_mvIMPACT_acquire.BasicDeviceSettings_imageRequestTimeout_ms_get, doc=r"""
    An integer property defining the maximum time to wait for an image in ms.
    When this property is set to 0 the timeout never elapses. If the timeout this property
    defines elapses the currently processed request will be returned to the user even if no data
    has been captured so far. The result structure of the request object should be examined in that
    case. Also this should be considered as an error from the users point of view in which case he
    should clean up the acquisition queue by calling **mvIMPACT::acquire::FunctionInterface::imageRequestReset**.
    Afterwards the capture loop can be restarted.

    Notes: 
    It is crucial to understand that this is a timeout **PER REQUEST**! The timespan taken into account for the measurement
    starts when the driver begins to capture data into **this particular buffer**! So when queuing 4 buffers with a timeout of 3000
    ms each and no data being transmitted by the device for any reason will cause the last buffer to time out 3000*4 = 12000 ms AFTER
    the buffer has been queued and the acquisition has been started as the driver will wait for up to 3 seconds for each buffer that is
    being processed. When the device sends data this timeout does not affect the runtime behaviour at all. No additional delay is introduced
    by it when everything runs as planned.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_BasicDeviceSettings

# Register BasicDeviceSettings in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.BasicDeviceSettings_swigregister(BasicDeviceSettings)

class TriggerControl(ComponentCollection):
    r"""
    A class to configure the behaviour of trigger signals.
    Features in this class will open up a more flexible way to configure certain
    trigger events for devices then the previous features('triggerInterface',
    'triggerSource' and 'triggerMode' used.

    Notes: 
    Not ever device will support every property listed in this class for every trigger
    mode. Always call **mvIMPACT::acquire::Component::isValid** to check whether
    a feature is available or not before using it. Otherwise an exception will
    be generated.
    """

    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

    def getDescription(self):
        r""" Returns a name of the trigger being configured."""
        return lib_mvIMPACT_acquire.TriggerControl_getDescription(self)

    def triggerSoftware(self):
        r"""
        Generates of software trigger command.
        :rtype: int
        :return: 
            - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
            - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.
        """
        return lib_mvIMPACT_acquire.TriggerControl_triggerSoftware(self)
    triggerMode = property(lib_mvIMPACT_acquire.TriggerControl_triggerMode_get, doc=r""" Defines if the selected trigger is active.""")
    triggerSource = property(lib_mvIMPACT_acquire.TriggerControl_triggerSource_get, doc=r"""
    Defines the signal that will cause the trigger event.
    Currently this property will define a translation dictionary that can e.g. be queried via a call to
    **mvIMPACT::acquire::PropertyI64::getTranslationDict**. The resulting translation dictionary can be used
    to select the desired trigger source either via a string or the associated 64 bit integer value.
    """)
    triggerActivation = property(lib_mvIMPACT_acquire.TriggerControl_triggerActivation_get, doc=r"""
    An enumerated 64 bit integer property that defines the start condition for the selected trigger.
    Valid value will be 'RisingEdge', 'FallingEdge', 'AnyEdge', 'LevelLow' or 'LevelHigh'.
    """)
    triggerDivider = property(lib_mvIMPACT_acquire.TriggerControl_triggerDivider_get, doc=r"""
    An integer property used to divide the number of incoming trigger pulses by an integer factor.
    E.g. setting this value to 2 would generate 5 internal trigger events from a 10 Hz external signal.
    """)
    triggerDelayAbs_us = property(lib_mvIMPACT_acquire.TriggerControl_triggerDelayAbs_us_get, doc=r""" Specifies the absolute delay in microseconds (us) to apply after the trigger reception before effectively activating it.""")
    triggerDelayLines = property(lib_mvIMPACT_acquire.TriggerControl_triggerDelayLines_get, doc=r""" Specifies the absolute delay in lines to apply after the trigger reception before effectively activating it.""")
    triggerOverlap = property(lib_mvIMPACT_acquire.TriggerControl_triggerOverlap_get, doc=r"""
    Specifies the type trigger overlap permitted with the previous frame. This defines when a valid trigger will be accepted (or latched) for a new frame.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDeviceTriggerOverlap**.
    """)

    r""" \brief A string property \b (read-only) which holds the name of the trigger being configured. See mvIMPACT.acquire.TriggerControl.getDescription() """
    description = property (getDescription, None, None, None)

    __swig_destroy__ = lib_mvIMPACT_acquire.delete_TriggerControl

# Register TriggerControl in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.TriggerControl_swigregister(TriggerControl)

class ImageDestination(ComponentCollection):
    r"""
    Properties to define the format of resulting images.
    This class provides properties allowing the user to define how the resulting
    image should be created. Things like the width and height of the captured image
    can be defined here for example.
    """

    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"""
         brief Constructs a new **mvIMPACT::acquire::ImageDestination** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.ImageDestination_swiginit(self, lib_mvIMPACT_acquire.new_ImageDestination(*args))
    pixelFormat = property(lib_mvIMPACT_acquire.ImageDestination_pixelFormat_get, doc=r"""
    An enumerated integer property defining the pixel format of the resulting image.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TImageDestinationPixelFormat**.
    """)
    scalerMode = property(lib_mvIMPACT_acquire.ImageDestination_scalerMode_get, doc=r"""
    An integer property defining whether the image is scaled or not.
    Notes: 
    This feature is available for every device! However currently only **mvDELTA** / **mvSIGMA**
    devices provide hardware support for **REDUCING** the image size. In this case the scaled width
    and height must be divisible by 4. For every other device this
    will be done by a software filter and therefore will introduce additional CPU load. Increasing
    the image size will always be done in software. When using the scaler the property
    **mvIMPACT::acquire::Statistics::imageProcTime_s** can be used to observe the additional
    CPU time needed for the image processing.
    """)
    scalerInterpolationMode = property(lib_mvIMPACT_acquire.ImageDestination_scalerInterpolationMode_get, doc=r"""
    An integer property defining the interpolation method used when the scaler is active.
    Notes: 
    Whenever the property **mvIMPACT::acquire::ImageDestination::scalerMode** is set to
    **mvIMPACT::acquire::smOff** modifying or reading this property will have no effect.
    Call **Component::isVisible** to find out whether this property is currently active or not.


    Please see remarks under **mvIMPACT::acquire::ImageDestination::scalerMode**. The interpolation mode
    currently will only be used when scaling is **NOT** done by the hardware.
    """)
    scalerAoiEnable = property(lib_mvIMPACT_acquire.ImageDestination_scalerAoiEnable_get, doc=r"""
    A boolean property defining whether an AOI, rather than the whole image, will be used for scaling.
    Notes: 
    Whenever the property **mvIMPACT::acquire::ImageDestination::scalerAoiEnable** is set to
    **mvIMPACT::acquire::bTrue** the relevant AOI configuration properties will become visible.
    """)
    scalerAoiHeight = property(lib_mvIMPACT_acquire.ImageDestination_scalerAoiHeight_get, doc=r"""
    An integer property defining the height of the AOI in pixel to be used for scaling.
    Notes: 
    This property will be visible only when **mvIMPACT::acquire::ImageDestination::scalerAoiEnable**
    is set to **mvIMPACT::acquire::bTrue**.
    """)
    scalerAoiStartX = property(lib_mvIMPACT_acquire.ImageDestination_scalerAoiStartX_get, doc=r"""
    An integer property defining the X-offset of the AOI in pixel to be used for the calculation.
    Notes: 
    This property will be visible only when **mvIMPACT::acquire::ImageDestination::scalerAoiEnable**
    is set to **mvIMPACT::acquire::bTrue**.
    """)
    scalerAoiStartY = property(lib_mvIMPACT_acquire.ImageDestination_scalerAoiStartY_get, doc=r"""
    An integer property defining the Y-offset of the AOI in pixel to be used for the calculation.
    Notes: 
    This property will be visible only when **mvIMPACT::acquire::ImageDestination::scalerAoiEnable**
    is set to **mvIMPACT::acquire::bTrue**.
    """)
    scalerAoiWidth = property(lib_mvIMPACT_acquire.ImageDestination_scalerAoiWidth_get, doc=r"""
    An integer property defining the width of the AOI in pixel to be used for the calculation.
    Notes: 
    This property will be visible only when **mvIMPACT::acquire::ImageDestination::scalerAoiEnable**
    is set to **mvIMPACT::acquire::bTrue**.
    """)
    imageWidth = property(lib_mvIMPACT_acquire.ImageDestination_imageWidth_get, doc=r"""
    An integer property defining the width of the scaled image.
    Notes: 
    Whenever the property **mvIMPACT::acquire::ImageDestination::scalerMode** is set to
    **mvIMPACT::acquire::smOff** modifying or reading this property will have no effect.
    Call **Component::isVisible** to find out whether this property is currently active or not.


    Please see remarks under **mvIMPACT::acquire::ImageDestination::scalerMode**.
    """)
    imageHeight = property(lib_mvIMPACT_acquire.ImageDestination_imageHeight_get, doc=r"""
    An integer property defining the height of the scaled image.
    Notes: 
    Whenever the property **mvIMPACT::acquire::ImageDestination::scalerMode** is set to
    **mvIMPACT::acquire::smOff** modifying or reading this property will have no effect.
    Call **Component::isVisible** to find out whether this property is currently active or not.


    Please see remarks under **mvIMPACT::acquire::ImageDestination::scalerMode**.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_ImageDestination

# Register ImageDestination in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.ImageDestination_swigregister(ImageDestination)

class RequestInfoConfiguration(ComponentCollection):
    r"""
     Properties to configure which information shall be attached to the resulting images.
     This class provides properties allowing the user to define which additional information
     shall be attached to the resulting images. For example some devices can transmit the state
     of the digital I/Os at the time the exposure of an image has been started. Some information
     will always be attached to the resulting images other information will only be available
     if it has been explicitly enabled before.

     If: DOXYGEN_CPP_DOCUMENTATION {

     **EXAMPLE**:

     Enable the transmission of the ``LineStatusAll`` information in device interface layout
     **mvIMPACT::acquire::dilDeviceSpecific**:

    .. code-block:: c++

         //-----------------------------------------------------------------------------
         void fn( Device* pDev )
         //-----------------------------------------------------------------------------
         {
            RequestInfoConfiguration ric( pDev );
            if( !ric.lineStatusAll.isValid() )
            {
               // feature not supported
               return;
            }
            ric.lineStatusAll.write( bTrue );
            Request* pRequest = captureAnImage( pDev );
            printf( "%s: 0x%08x\n", pRequest-chunkLineStatusAll.name().c_str(), static_cast int ( pRequest-chunkLineStatusAll.read() ) );
         }
    }Else if: DOXYGEN_JAVA_DOCUMENTATION {

    .. code-block:: c++

         //-----------------------------------------------------------------------------
         public void fn( Device pDev )
         //-----------------------------------------------------------------------------
         {
            RequestInfoConfiguration ric = new RequestInfoConfiguration( pDev );
            if( !ric.lineStatusAll.isValid() )
            {
               // feature not supported
               return;
            }
            ric.getLineStatusAll().write( TBoolean.bTrue );
            Request pRequest = captureAnImage( pDev );
            System.out.println( String.format( "%s: 0x%08x\n", pRequest.getChunkLineStatusAll().name(), ( int )( pRequest.getChunkLineStatusAll().read() ) ) );
         }
    }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

    .. code-block:: c++

         def fn(pdev, pRequest):
           ric = acquire.RequestInfoConfiguration(pDev)
           if ric.lineStatusAll.isValid == False:
             # feature not supported
             return
           else:
             ric.lineStatusAll.write(acquire.bTrue)
             print(pRequest.chunkLineStatusAll.name() + ": 0x%x" %(pRequest.chunkLineStatusAll.read()))
    }
     E.g. for the **mvBlueCOUGAR-X/XD** series possible ``LineStatusAll`` values are

     - **0x11**, Out0 and In0 on (Out0 needs to be connected with In0 for this to work)
     - **0x33**, Out0, Out1, In0 and In1 on (Out0 and Out1 need to be connected with In0 and In1 for this to work)
     - **0x37**, Out0, Out1, Out2, In0 and In1 on (Out0 and Out1 need to be connected with In0 and In1 for this to work)
     - **0x3f**, Out0, Out1, Out2, Out3, In0 and In1 on (Out0 and Out1 need to be connected with in0 and in1 for this to work)

     Since: 2.10.0
    """

    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"""
         brief Constructs a new **mvIMPACT::acquire::RequestInfoConfiguration** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.RequestInfoConfiguration_swiginit(self, lib_mvIMPACT_acquire.new_RequestInfoConfiguration(*args))
    frameNr = property(lib_mvIMPACT_acquire.RequestInfoConfiguration_frameNr_get, doc=r"""
    An enumerated integer property which can be used to configure whether the frame number information shall be attached to the resulting **mvIMPACT::acquire::Request** objects.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.
    """)
    timeStamp_us = property(lib_mvIMPACT_acquire.RequestInfoConfiguration_timeStamp_us_get, doc=r"""
    An enumerated integer property which can be used to configure whether the time stamp(us) information shall be attached to the resulting **mvIMPACT::acquire::Request** objects.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.
    """)
    settingUsed = property(lib_mvIMPACT_acquire.RequestInfoConfiguration_settingUsed_get, doc=r"""
    An enumerated integer property which can be used to configure whether the 'setting used' information shall be attached to the resulting **mvIMPACT::acquire::Request** objects.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.
    """)
    frameID = property(lib_mvIMPACT_acquire.RequestInfoConfiguration_frameID_get, doc=r"""
    An enumerated integer property which can be used to configure whether the frame ID information shall be attached to the resulting **mvIMPACT::acquire::Request** objects.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.
    """)
    exposeStart_us = property(lib_mvIMPACT_acquire.RequestInfoConfiguration_exposeStart_us_get, doc=r"""
    An enumerated integer property which can be used to configure whether the exposure start(us) information shall be attached to the resulting **mvIMPACT::acquire::Request** objects.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.
    """)
    exposeTime_us = property(lib_mvIMPACT_acquire.RequestInfoConfiguration_exposeTime_us_get, doc=r"""
    An enumerated integer property which can be used to configure whether the exposure time(us) information shall be attached to the resulting **mvIMPACT::acquire::Request** objects.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.
    """)
    gain_dB = property(lib_mvIMPACT_acquire.RequestInfoConfiguration_gain_dB_get, doc=r"""
    An enumerated integer property which can be used to configure whether the gain(dB) information shall be attached to the resulting **mvIMPACT::acquire::Request** objects.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.
    """)
    videoChannel = property(lib_mvIMPACT_acquire.RequestInfoConfiguration_videoChannel_get, doc=r"""
    An enumerated integer property which can be used to configure whether the video channel information shall be attached to the resulting **mvIMPACT::acquire::Request** objects.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.
    """)
    missingData_pc = property(lib_mvIMPACT_acquire.RequestInfoConfiguration_missingData_pc_get, doc=r"""
    An enumerated integer property which can be used to configure whether the missing data information shall be attached to the resulting **mvIMPACT::acquire::Request** objects.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.
    """)
    transferDelay_us = property(lib_mvIMPACT_acquire.RequestInfoConfiguration_transferDelay_us_get, doc=r"""
    An enumerated integer property which can be used to configure whether the transfer delay(us) information shall be attached to the resulting **mvIMPACT::acquire::Request** objects.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.
    Notes: 
    - This feature currently is only available for **mvBlueFOX** devices
    """)
    imageAverage = property(lib_mvIMPACT_acquire.RequestInfoConfiguration_imageAverage_get, doc=r"""
    An enumerated integer property which can be used to configure whether the image average information shall be attached to the resulting **mvIMPACT::acquire::Request** objects.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.
    Notes: 
    - This feature currently is only available for **mvBlueFOX** devices
    """)
    IOStatesAtExposureStart = property(lib_mvIMPACT_acquire.RequestInfoConfiguration_IOStatesAtExposureStart_get, doc=r"""
    An enumerated integer property which can be used to configure whether the I/O states at exposure start information shall be attached to the resulting **mvIMPACT::acquire::Request** objects.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.
    Notes: 
    This feature currently is only available for **mvBlueFOX-MLC** devices.
    """)
    triggerCounterAcquisitionStart = property(lib_mvIMPACT_acquire.RequestInfoConfiguration_triggerCounterAcquisitionStart_get, doc=r"""
    An enumerated integer property which can be used to configure whether the trigger counter at acquisition start information shall be attached to the resulting **mvIMPACT::acquire::Request** objects.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.
    Notes: 
    - This feature currently is only available for **mvHYPERION** devices
    """)
    triggerCounterFrameStart = property(lib_mvIMPACT_acquire.RequestInfoConfiguration_triggerCounterFrameStart_get, doc=r"""
    An enumerated integer property which can be used to configure whether the trigger counter at frame start information shall be attached to the resulting **mvIMPACT::acquire::Request** objects.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.
    Notes: 
    - This feature currently is only available for **mvHYPERION** devices
    """)
    lineCounter = property(lib_mvIMPACT_acquire.RequestInfoConfiguration_lineCounter_get, doc=r"""
    An enumerated integer property which can be used to configure whether the line counter information shall be attached to the resulting **mvIMPACT::acquire::Request** objects.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.
    Notes: 
    - This feature currently is only available for **mvTITAN-CL**, **mvGAMMA-CL** and **mvTITAN-DIG** devices
    """)
    userData = property(lib_mvIMPACT_acquire.RequestInfoConfiguration_userData_get, doc=r"""
    An enumerated integer property which can be used to configure whether the user data information shall be attached to the resulting **mvIMPACT::acquire::Request** objects.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.
    Notes: 
    This feature currently is only available for **mvVirtual** devices.
    """)
    lineStatusAll = property(lib_mvIMPACT_acquire.RequestInfoConfiguration_lineStatusAll_get, doc=r"""
    An enumerated integer property which can be used to configure whether the line status all information shall be attached to the resulting **mvIMPACT::acquire::Request** objects.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.
    Notes: 
    - This feature may be available for GenICam compliant devices
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_RequestInfoConfiguration

# Register RequestInfoConfiguration in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.RequestInfoConfiguration_swigregister(RequestInfoConfiguration)

class WhiteBalanceSettings(ComponentCollection):
    r"""
    Properties for adjusting the colors during a Bayer conversion.
    This class provides properties to adjust the parameters needed for a
    Bayer conversion.

    Notes: 
    Objects of this class can't be constructed directly. Its parameters can
    be accessed via an instance of a class derived from **mvIMPACT::acquire::ImageProcessing**.
    """

    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
    WBAoiMode = property(lib_mvIMPACT_acquire.WhiteBalanceSettings_WBAoiMode_get, doc=r"""
    An enumerated integer property defining the which area of the image is used for the calculation of the parameters.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TAoiMode**.
    """)
    aoiHeight = property(lib_mvIMPACT_acquire.WhiteBalanceSettings_aoiHeight_get, doc=r"""
    An integer property defining the height of the AOI in pixel to be used for the calculation.
    Notes: 
    This property will be visible only when **mvIMPACT::acquire::WhiteBalanceSettings::WBAoiMode**
    is set to **mvIMPACT::acquire::amUseAoi**.
    """)
    aoiStartX = property(lib_mvIMPACT_acquire.WhiteBalanceSettings_aoiStartX_get, doc=r"""
    An integer property defining the X-offset of the AOI in pixel to be used for the calculation.
    Notes: 
    This property will be visible only when **mvIMPACT::acquire::WhiteBalanceSettings::WBAoiMode**
    is set to **mvIMPACT::acquire::amUseAoi**.
    """)
    aoiStartY = property(lib_mvIMPACT_acquire.WhiteBalanceSettings_aoiStartY_get, doc=r"""
    An integer property defining the Y-offset of the AOI in pixel to be used for the calculation.
    Notes: 
    This property will be visible only when **mvIMPACT::acquire::WhiteBalanceSettings::WBAoiMode**
    is set to **mvIMPACT::acquire::amUseAoi**.
    """)
    aoiWidth = property(lib_mvIMPACT_acquire.WhiteBalanceSettings_aoiWidth_get, doc=r"""
    An integer property defining the width of the AOI in pixel to be used for the calculation.
    Notes: 
    This property will be visible only when **mvIMPACT::acquire::WhiteBalanceSettings::WBAoiMode**
    is set to **mvIMPACT::acquire::amUseAoi**.
    """)
    totalGain = property(lib_mvIMPACT_acquire.WhiteBalanceSettings_totalGain_get, doc=r""" A float property defining the overall gain.""")
    redGain = property(lib_mvIMPACT_acquire.WhiteBalanceSettings_redGain_get, doc=r""" A float property defining the gain for the red channel.""")
    greenGain = property(lib_mvIMPACT_acquire.WhiteBalanceSettings_greenGain_get, doc=r""" A float property defining the gain for the green channel.""")
    blueGain = property(lib_mvIMPACT_acquire.WhiteBalanceSettings_blueGain_get, doc=r""" A float property defining the gain for the blue channel.""")
    WBResult = property(lib_mvIMPACT_acquire.WhiteBalanceSettings_WBResult_get, doc=r"""
    An enumerated integer property **(read-only)** containing the result of the last white balance calibration.
    After the **mvIMPACT::acquire::Device** has been initialized, the value of this property will be
    **mvIMPACT::acquire::bwbrUnknown**.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBayerWhiteBalanceResult**.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_WhiteBalanceSettings

# Register WhiteBalanceSettings in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.WhiteBalanceSettings_swigregister(WhiteBalanceSettings)

class GainOffsetKneeChannelParameters(ComponentCollection):
    r"""
    Properties for configuring settings belonging to a certain channel of the GainOffsetKnee filter.
    First the master offset will be added to all channels of the image, then each
    channels individual gain factor will be applied to the pixel of each channel and
    finally the channel specific offset will be added.

    Image: GainOffsetKnee.png

    Notes: 
    Objects of this class can't be constructed directly. Its parameters can
    be accessed via an instance of a class derived from **mvIMPACT::acquire::ImageProcessing**.
    """

    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
    gain = property(lib_mvIMPACT_acquire.GainOffsetKneeChannelParameters_gain_get, doc=r"""
    A float property that contains the channel specific gain to be applied to the selected channel of the image.
    This gain will be applied after the master offset but before the channel specific offset.
    """)
    offset_pc = property(lib_mvIMPACT_acquire.GainOffsetKneeChannelParameters_offset_pc_get, doc=r"""
    A float property that contains the channel specific offset (in percent) to be applied to the selected channel of the image.
    This offset will be applied after the channel specific gain.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_GainOffsetKneeChannelParameters

# Register GainOffsetKneeChannelParameters in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.GainOffsetKneeChannelParameters_swigregister(GainOffsetKneeChannelParameters)

class LUTParameters(ComponentCollection):
    r"""
    Properties for configuring settings belonging to a certain LUT (**L**ook **U**p **T**able) to be applied to a captured image.
    Notes: 
    Objects of this class can't be constructed directly. Its parameters can
    be accessed via an instance of a class derived from **mvIMPACT::acquire::ImageProcessing**.
    """

    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
    gamma = property(lib_mvIMPACT_acquire.LUTParameters_gamma_get, doc=r"""
     A float property which can be used to set the gamma value.
     Gamma correction is explained e.g. in this Wikipedia article: http://en.wikipedia.org/wiki/Gamma_correction.

     Notes: This property will be invisible when **mvIMPACT::acquire::ImageProcessing::LUTEnable** is set to
     **mvIMPACT::acquire::bFalse** or if **mvIMPACT::acquire::ImageProcessing::LUTMode** is **NOT** set to
     **mvIMPACT::acquire::LUTmGamma**.

     The gamma value will be used to calculate the corresponding input -> output transformation LUT.

     The following formula will be used:

    .. code-block:: c++

          ( ( 1 + gammaAlpha ) * inputValue^(1/gamma) ) - gammaAlpha
    """)
    gammaAlpha = property(lib_mvIMPACT_acquire.LUTParameters_gammaAlpha_get, doc=r"""
    A float property which can be used to set the gammaAlpha value.
    Refer to **mvIMPACT::acquire::LUTParameters::gamma** to see how this parameter affects the resulting
    LUT data.

    Notes: This property will be invisible when **mvIMPACT::acquire::ImageProcessing::LUTEnable** is set to
    **mvIMPACT::acquire::bFalse** or if **mvIMPACT::acquire::ImageProcessing::LUTMode** is **NOT** set to
    **mvIMPACT::acquire::LUTmGamma**.
    """)
    gammaMode = property(lib_mvIMPACT_acquire.LUTParameters_gammaMode_get, doc=r"""
    An enumerated integer property which can be used to configure the LUT(**L**ook **U**p **T**able) gamma mode.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TLUTGammaMode**.

    Notes: This property will be invisible when **mvIMPACT::acquire::ImageProcessing::LUTEnable** is set to
    **mvIMPACT::acquire::bFalse** or if **mvIMPACT::acquire::ImageProcessing::LUTMode** is **NOT** set to
    **mvIMPACT::acquire::LUTmGamma**.
    """)
    gammaStartThreshold = property(lib_mvIMPACT_acquire.LUTParameters_gammaStartThreshold_get, doc=r"""
    An integer property which can be used to define a start threshold above which the gamma correction formula shall be used in **mvIMPACT::acquire::LUTParameters::gammaMode** **mvIMPACT::acquire::LUTgmLinearStart**.
    Values below that threshold will be calculated using linear interpolation.

    Notes: This property will be invisible when **mvIMPACT::acquire::ImageProcessing::LUTEnable** is set to
    **mvIMPACT::acquire::bFalse** or if **mvIMPACT::acquire::ImageProcessing::LUTMode** is **NOT** set to
    **mvIMPACT::acquire::LUTmGamma** or if **mvIMPACT::acquire::LUTParameters::gammaMode** is **NOT** set to
    **mvIMPACT::acquire::LUTgmLinearStart**.
    """)
    gammaInverter = property(lib_mvIMPACT_acquire.LUTParameters_gammaInverter_get, doc=r"""
    An enumerated integer property defining whether the calculated gamma correction function shall be inverted or not
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.

    Notes: This property will be invisible when **mvIMPACT::acquire::ImageProcessing::LUTEnable** is set to
    **mvIMPACT::acquire::bFalse** or if **mvIMPACT::acquire::ImageProcessing::LUTMode** is **NOT** set to
    **mvIMPACT::acquire::LUTmGamma**.

    This property is mainly provided for compatibility reasons since the original implementation of
    the mvIMPACT Acquire framework and the implementation inside MATRIX VISION GmbH GenICam devices introduced later
    differ. The default behaviour of the mvIMPACT Acquire results in the reverse function of the gamma function
    inside the device firmware thus the gamma value specified here results in the same response as if applying
    (1/gamma value) to a device. So a gamma value of 2.2 with the inverter switched off this would result in the same
    response as a gamma value of 0.45 with the inverter switched on. In order not to change the default behaviour of this filter
    the default value for this property will be **mvIMPACT::acquire::bTrue** and can be set to
    **mvIMPACT::acquire::bFalse** to achieve the same behaviour as implemented for GenICam devices and specified in
    the SFNC (GenICam Standard Features Naming Convention).

    Since: 2.38.0
    """)
    valueCount = property(lib_mvIMPACT_acquire.LUTParameters_valueCount_get, doc=r"""
     An integer property to define the number of sampling points for interpolated LUT transformations.
     Notes: This property will be invisible when **mvIMPACT::acquire::ImageProcessing::LUTEnable** is set to
     **mvIMPACT::acquire::bFalse** or if **mvIMPACT::acquire::ImageProcessing::LUTMode** is **NOT** set to
     **mvIMPACT::acquire::LUTmInterpolated**.

     At least 2 sampling points are needed, the max. number of sampling points is defined by the bit depth of the input
     image, thus a 8 bit input image can have no more than 2^8 (256) sampling points. if the max. number of sampling points
     is used, the behaviour is the same a when working with **mvIMPACT::acquire::ImageProcessing::LUTMode** set to
     **mvIMPACT::acquire::LUTmDirect**.

     **EXAMPLE**

     Assuming 4 sampling points in **mvIMPACT::acquire::LUTimThreshold** mode for an 8 to 8 bit transformation where the following
     values are used:


     -----------------------
     |index|input value|output value|
     |0|0|64|
     |1|128|255|
     |2|192|0|
     |3|255|0|


     This will result in the following transfer function characteristic:

     Image: LUT_ThresholdInterpolation_4SamplingPoints.png

     If: DOXYGEN_CPP_DOCUMENTATION {
     **The** following C++ code would be needed to achieve this behaviour for mono video sources:

    .. code-block:: c++

         //-----------------------------------------------------------------------------
         void fn( ImageProcessing ip, TLUTImplemention LUTImplementation )
         //-----------------------------------------------------------------------------
         {
           ip.LUTEnable.write( bTrue );
           ip.LUTMode.write( LUTmInterpolated );
           ip.LUTImplementation.write( LUTImplementation );
           ip.LUTInterpolationMode.write( LUTimThreshold );
           switch( LUTImplementation )
           {
             case LUTiHardware:
               ip.LUTMappingHardware.write( LUTm8To8 );
               break;
             case LUTiSoftware:
               ip.LUTMappingSoftware.write( LUTm8To8 );
               break;
            }
            LUTParameters LUTAccess = ip.getLUTParameter( 0 );
            LUTAccess.valueCount.write( 4 );
            vectorint v(4);
            v[0] = 0;
            v[1] = 128;
            v[2] = 192;
            v[3] = 255;
            LUTAccess.inputValues.write( v );
            v[0] = 64;
            v[1] = 255;
            v[2] = 0;
            v[3] = 0;
            LUTAccess.outputValues.write( v );
         }
    }Else if: DOXYGEN_JAVA_DOCUMENTATION {

    .. code-block:: c++

         //-----------------------------------------------------------------------------
         public void fn( ImageProcessing ip, final int LUTImplementation )
         //-----------------------------------------------------------------------------
         {
           ip.getLUTEnable().write( TBoolean.bTrue );
           ip.getLUTMode().write( TLUTMode.LUTmInterpolated );
           ip.getLUTImplementation().write( LUTImplementation );
           ip.getLUTInterpolationMode().write( TLUTInterpolationMode.LUTimThreshold );
           if( LUTImplementation == TLUTImplementation.LUTiHardware )
           {
             ip.getLUTMappingHardware().write( TLUTMapping.LUTm8To8 );
           }
           else if( LUTImplementation == TLUTImplementation.LUTiSoftware )
           {
             ip.getLUTMappingSoftware().write( TLUTMapping.LUTm8To8 );
           }
           LUTParameters LUTAccess = ip.getLUTParameter( 0 );
           LUTAccess.getValueCount().write( 4 );
           {
             IntVector v = new IntVector();
             v.add( 0 );
             v.add( 128 );
             v.add( 192 );
             v.add( 255 );
             LUTAccess.getInputValues().write( v );
           }
           {
             IntVector v = new IntVector();
             v.add( 64 );
             v.add( 255 );
             v.add( 0 );
             v.add( 0 );
             LUTAccess.getOutputValues().write( v );
           }
         }
    }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

    .. code-block:: c++

         This sample assumes a valid reference to a mvIMPACT::acquire::ImageProcessing object has been obtained.
         def fn(ip, LUTImplementation):
           ip.LUTEnable.write(acquire.bTrue)
           ip.LUTMode.write(acquire.LUTmInterpolated)
           ip.LUTImplementation.write(LUTImplementation)
           ip.LUTInterpolationMode.write(LUTimThreshold)
           if LUTImplementation == LUTiHardware:
               ip.LUTMappingHardware.write(acquire.LUTm8To8)
           elif LUTImplementation == LUTiSoftware:
               ip.LUTMappingSoftware.write(acquire.LUTm8To8)

           LUTAccess = ip.getLUTParameter(0)
           LUTAccess.valueCount.write(4)
           v = []
           v[0] = 0
           v[1] = 128
           v[2] = 192
           v[3] = 255
           LUTAccess.inputValues.write(v)

           v[0] = 64
           v[1] = 255
           v[2] = 0
           v[3] = 0
           LUTAccess.outputValues.write(v)
    }
     Assuming 3 sampling points in **mvIMPACT::acquire::LUTimLinear** mode for an 8 to 8 bit transformation where the following
     values are used:


     |index|input value|output value|
     |0|0|64|
     |1|128|255|
     |2|255|0|


     This will result in the following transfer function characteristic:

     Image: LUT_linearInterpolation_3SamplingPoints.png

     Assuming 4 sampling points in **mvIMPACT::acquire::LUTimCubic** mode for an 8 to 8 bit transformation where the following
     values are used:


     |index|input value|output value|
     |0|0|0|
     |1|128|255|
     |2|192|192|
     |3|255|0|


     This will result in the following transfer function characteristic:

     Image: LUT_CubicInterpolation_4SamplingPoints.png
    """)
    inputValues = property(lib_mvIMPACT_acquire.LUTParameters_inputValues_get, doc=r"""
    An integer property to define the input values for sampling points for interpolated LUT transformations.
    Notes: This property will be invisible when **mvIMPACT::acquire::ImageProcessing::LUTEnable** is set to
    **mvIMPACT::acquire::bFalse** or if **mvIMPACT::acquire::ImageProcessing::LUTMode** is **NOT** set to
    **mvIMPACT::acquire::LUTmInterpolated**.

    The number of values stored by this property can be changed by writing to the property **mvIMPACT::acquire::LUTParameters::valueCount**.
    The documentation of this property also provides some example values and resulting transfer characteristics.
    """)
    outputValues = property(lib_mvIMPACT_acquire.LUTParameters_outputValues_get, doc=r"""
    An integer property to define the output values for sampling points for interpolated LUT transformations.
    Notes: This property will be invisible when **mvIMPACT::acquire::ImageProcessing::LUTEnable** is set to
    **mvIMPACT::acquire::bFalse** or if **mvIMPACT::acquire::ImageProcessing::LUTMode** is **NOT** set to
    **mvIMPACT::acquire::LUTmInterpolated**.

    The number of values stored by this property can be changed by writing to the property **mvIMPACT::acquire::LUTParameters::valueCount**.
    The documentation of this property also provides some example values and resulting transfer characteristics.
    """)
    directValues = property(lib_mvIMPACT_acquire.LUTParameters_directValues_get, doc=r"""
    An integer property which can be used to directly define a LUT.
    Notes: This property will be invisible when **mvIMPACT::acquire::ImageProcessing::LUTEnable** is set to
    **mvIMPACT::acquire::bFalse** or if **mvIMPACT::acquire::ImageProcessing::LUTMode** is **NOT** set to
    **mvIMPACT::acquire::LUTmDirect**.

    This property will provide a complete LUT thus e.g. in a LUT mapping to a 10 bit output this property will store 2^10 (1024)
    values that can be accessed and modified by the user.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_LUTParameters

# Register LUTParameters in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.LUTParameters_swigregister(LUTParameters)

class MirrorParameters(ComponentCollection):
    r"""
    Properties for configuring settings belonging to the mirror filter that processes a certain channel of a captured image.
    Properties in this class will only have influence on the capture process if
    **mvIMPACT::acquire::ImageProcessing::mirrorOperationMode** is set to **mvIMPACT::acquire::momChannelBased**.

    Notes: 
    Objects of this class can't be constructed directly. Its parameters can
    be accessed via an instance of a class derived from **mvIMPACT::acquire::ImageProcessing**.
    """

    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
    mirrorMode = property(lib_mvIMPACT_acquire.MirrorParameters_mirrorMode_get, doc=r"""
    An enumerated integer property defining the mirror mode to be applied to this channel of the image.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TMirrorMode**.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_MirrorParameters

# Register MirrorParameters in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.MirrorParameters_swigregister(MirrorParameters)

class ImageProcessing(ComponentCollection):
    r"""
    Base class for image processing related properties.
    This class provides access to properties, which define how the image shall
    be processed after it has been captured but before it will be handed back to
    the user.
    """

    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"""
        *Overload 1:*
         Constructs a new **mvIMPACT::acquire::ImageProcessing** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::ImageProcessing** from an existing one.
        :type src: :py:class:`ImageProcessing`
        :param src: [in] A constant reference to the **mvIMPACT::acquire::ImageProcessing** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.ImageProcessing_swiginit(self, lib_mvIMPACT_acquire.new_ImageProcessing(*args))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_ImageProcessing
    colorProcessing = property(lib_mvIMPACT_acquire.ImageProcessing_colorProcessing_get, doc=r"""
    An enumerated integer property defining what kind of color processing shall be applied to the raw image data.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TColorProcessingMode**.
    """)
    bayerConversionMode = property(lib_mvIMPACT_acquire.ImageProcessing_bayerConversionMode_get, doc=r"""
    An enumerated integer property defining what kind of algorithm shall be used during Bayer to RGB conversion.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBayerConversionMode**.
    """)
    adaptiveEdgeSensingPlusSharpenThreshold = property(lib_mvIMPACT_acquire.ImageProcessing_adaptiveEdgeSensingPlusSharpenThreshold_get, doc=r"""
    An integer property defining the max. brightness level difference for which sharpening is not applied during AdaptiveEdgeSensingPlus deBayering.
    Valid values for this property are between 0 and 2^(bits per pixel).

    Since: 2.26.0
    """)
    adaptiveEdgeSensingPlusSharpenGain = property(lib_mvIMPACT_acquire.ImageProcessing_adaptiveEdgeSensingPlusSharpenGain_get, doc=r"""
    A floating point property defining the intensity of the sharpening during AdaptiveEdgeSensingPlus deBayering.
    Valid values for this property are between 0. and 100. (percent).

    Since: 2.26.0
    """)
    whiteBalance = property(lib_mvIMPACT_acquire.ImageProcessing_whiteBalance_get, doc=r"""
    An integer property defining the parameter set to be used to perform the white balance correction.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TWhiteBalanceParameter**.
    """)
    whiteBalanceCalibration = property(lib_mvIMPACT_acquire.ImageProcessing_whiteBalanceCalibration_get, doc=r"""
    An enumerated integer property defining the mode used for white balance calibration.
    This property can be used to define the way a white balance calibration shall be performed.
    Currently only the **mvIMPACT::acquire::wbcmNextFrame** mode is supported,
    but new modes might appear in later revisions of the interface.

    When this property is set to **mvIMPACT::acquire::wbcmNextFrame** the next
    image captured will be used as a reference to calculate the gain factors for the
    *red*, *green* and *blue* channel. So make sure when the next image is captured the camera
    looks on a plain white or slightly grey surface in order to obtain correct results. After
    the calibration has been done, the property will be reset to **mvIMPACT::acquire::wbcmOff**
    again.

    Notes: 
    Performing this kind of white balance calibration will only affect Bayer color sensors and will
    only have any visual effect on the image if one of the user definable parameter sets has been
    selected before. This can be done by modifying the property **mvIMPACT::acquire::ImageProcessing::whiteBalance**.
    Afterwards the calculated factors will be stored in the **mvIMPACT::acquire::WhiteBalanceSettings** selected.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TWhiteBalanceCalibrationMode**.
    """)
    filter = property(lib_mvIMPACT_acquire.ImageProcessing_filter_get, doc=r"""
    An enumerated integer property defining the filter to be applied to the image before it is transferred to the user.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TImageProcessingFilter**.
    """)
    mirrorOperationMode = property(lib_mvIMPACT_acquire.ImageProcessing_mirrorOperationMode_get, doc=r"""
    An enumerated integer property defining the general mode the mirror filter will work in.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TMirrorOperationMode**.
    """)
    mirrorModeGlobal = property(lib_mvIMPACT_acquire.ImageProcessing_mirrorModeGlobal_get, doc=r"""
    An enumerated integer property defining the mirror mode to be applied to ALL channels of the image.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TMirrorMode**.

    Notes: This property will only be visible, when **mvIMPACT::acquire::ImageProcessing::mirrorOperationMode** is set
    to **mvIMPACT::acquire::momGlobal**.
    """)
    polarizedDataExtractionEnable = property(lib_mvIMPACT_acquire.ImageProcessing_polarizedDataExtractionEnable_get, doc=r"""
    An enumerated integer property defining whether the polarization data extraction filter shall be active or not.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.

    Since: 2.29.0
    """)
    polarizedDataExtractionMode = property(lib_mvIMPACT_acquire.ImageProcessing_polarizedDataExtractionMode_get, doc=r"""
    An enumerated integer property defining in which mode the polarization data extraction filter shall be operated in.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TPolarizedDataExtractionMode**.

    Since: 2.29.0
    """)
    polarizedDataExtractionInterpolationMode = property(lib_mvIMPACT_acquire.ImageProcessing_polarizedDataExtractionInterpolationMode_get, doc=r"""
    An enumerated integer property defining the interpolation mode the polarization data extraction filter shall be operated in.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode**.

    Notes: This property will only be available when the polarization data extraction mode is either horizontal, vertical or single.

    Since: 2.29.0
    """)
    polarizedDataExtractionChannelIndex = property(lib_mvIMPACT_acquire.ImageProcessing_polarizedDataExtractionChannelIndex_get, doc=r"""
    An integer property defining the channel within the processing window of the polarization data extraction filter.
    This channel will only be taken into account when **mvIMPACT::acquire::ImageProcessing::polarizedDataExtractionMode** is set to
    **mvIMPACT::acquire::prmExtractSingle**.

    Since: 2.29.0
    """)
    polarizedDataExtractionLowerLimit = property(lib_mvIMPACT_acquire.ImageProcessing_polarizedDataExtractionLowerLimit_get, doc=r"""
    An integer property defining the lower limit of the grey value of a pixel to be taken into account within the processing window of the polarization data extraction filter.
    This limit will only be taken into account when **mvIMPACT::acquire::ImageProcessing::polarizedDataExtractionMode** is set to
    **mvIMPACT::acquire::prmMeanValue**.

    Since: 2.29.0
    """)
    polarizedDataExtractionUpperLimit = property(lib_mvIMPACT_acquire.ImageProcessing_polarizedDataExtractionUpperLimit_get, doc=r"""
    An integer property defining the upper limit of the grey value of a pixel to be taken into account within the processing window of the polarization data extraction filter.
    This limit will only be taken into account when **mvIMPACT::acquire::ImageProcessing::polarizedDataExtractionMode** is set to
    **mvIMPACT::acquire::prmMeanValue**.

    Since: 2.29.0
    """)
    defectivePixelsFilterMode = property(lib_mvIMPACT_acquire.ImageProcessing_defectivePixelsFilterMode_get, doc=r"""
    An enumerated integer property defining the operation mode of the defective pixels filter.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDefectivePixelsFilterMode**.
    """)
    defectivePixelsFilterLeakyPixelDeviation_ADCLimit = property(lib_mvIMPACT_acquire.ImageProcessing_defectivePixelsFilterLeakyPixelDeviation_ADCLimit_get, doc=r"""
    An integer property defining the max. allowed offset from the average grey value for a pixel during calibration.
    When this filter is calibrated each pixel producing a grey value higher than the average grey value plus
    the value of this property will be considered as a leaky pixel and therefore will be replaced by
    a value depending on the operation mode of the filter.
    """)
    defectivePixelsFilterColdPixelDeviation_pc = property(lib_mvIMPACT_acquire.ImageProcessing_defectivePixelsFilterColdPixelDeviation_pc_get, doc=r"""
    An integer property defining the max. allowed deviation for a pixel in per cent from the average grey value.
    If this filter is active every pixel that during the calibration produces a grey value which is
    lower than the average grey value of the image minus the allowed deviation in per cent will be
    considered as a cold pixel and therefore will be replaced by a value depending on the operation
    mode of the filter.
    """)
    defectivePixelsMaxDetectionCount = property(lib_mvIMPACT_acquire.ImageProcessing_defectivePixelsMaxDetectionCount_get, doc=r"""
    An integer property defining maximum the number of pixels considered as being defective during consecutive calibration runs.
    With this property it is possible to define an upper limit for the number of detected defective pixels. This is not to be meant
    as an error checking mechanism for sensors reporting more defective pixels but to allow an application to keep the length of the
    list of defective pixels within reasonable boundaries. The more pixels a sensor has the higher a reasonable value might be. Set this
    to a value suitable for your application to protect the algorithm from huge lists due to incorrect calibration environments (too much light,
    not enough light, ...).

    When after a calibration this value and the value of the **mvIMPACT::acquire::ImageProcessing::defectivePixelsFound** property are the
    same this indicates a problem. There are several possible reasons for this:

    - the lighting conditions or calibration parameters have not been set up correctly (fix your setup then)
    - the sensor is damaged (replace the device then)
    - the sensor has more defective pixels then indicated by the value of this property but which are still valid according to the specification of the sensor manufacturer (adjust the value of this property accordingly then)

    When reducing this value at runtime excess pixels will be dropped from the current list of defective pixels if the new maximum list length is smaller then the amount of
    defective pixels currently detected.

    Some devices might offer to store defective pixels inside the device in an mvIMPACT Acquire compatible format by calling **mvIMPACT::acquire::ImageProcessing::defectivePixelWriteToDevice**.
    However the device might not be able to store all these pixels due to a lack of storage space. Therefore always check the return value of the function!

    Notes: 
    In order to get rid of currently detected pixels an application must set the property
    **mvIMPACT::acquire::ImageProcessing::defectivePixelsFilterMode** to **mvIMPACT::acquire::dpfmResetCalibration**
    and then capture a fresh image. Only then all currently detected pixels will be discarded.

    Since: 2.37.0
    """)
    defectivePixelsFound = property(lib_mvIMPACT_acquire.ImageProcessing_defectivePixelsFound_get, doc=r"""
    An integer property **(read-only)** containing the number of pixels considered as being defective with respect to the calibration runs executed after the last reset of the calibration data.
    Notes: 
    In order to collect **ALL** defective pixels the list of detected pixels is not emptied each time a new calibration
    is started. In order to get rid of currently detected pixels an application must set the property
    **mvIMPACT::acquire::ImageProcessing::defectivePixelsFilterMode** to **mvIMPACT::acquire::dpfmResetCalibration**
    and then capture a fresh image. Only then all currently detected pixels will be discarded.

    Since: 2.5.9
    """)
    defectivePixelOffsetX = property(lib_mvIMPACT_acquire.ImageProcessing_defectivePixelOffsetX_get, doc=r"""
    An integer property defining a list of X-offsets of all pixels currently treated as defective.
    All these pixels will be replaced depending on the selected algorithm in **mvIMPACT::acquire::ImageProcessing::defectivePixelsFilterMode**.

    Notes: 
    In order to collect **ALL** defective pixels the list of detected pixels is not emptied each time a new calibration
    is started. In order to get rid of currently detected pixels an application must set the property
    **mvIMPACT::acquire::ImageProcessing::defectivePixelsFilterMode** to **mvIMPACT::acquire::dpfmResetCalibration**
    and then capture a fresh image. Only then all currently detected pixels will be discarded.

    Since: 2.17.1
    """)
    defectivePixelOffsetY = property(lib_mvIMPACT_acquire.ImageProcessing_defectivePixelOffsetY_get, doc=r"""
    An integer property defining a list of Y-offsets of all pixels currently treated as defective.
    All these pixels will be replaced depending on the selected algorithm in **mvIMPACT::acquire::ImageProcessing::defectivePixelsFilterMode**.

    Notes: 
    In order to collect **ALL** defective pixels the list of detected pixels is not emptied each time a new calibration
    is started. In order to get rid of currently detected pixels an application must set the property
    **mvIMPACT::acquire::ImageProcessing::defectivePixelsFilterMode** to **mvIMPACT::acquire::dpfmResetCalibration**
    and then capture a fresh image. Only then all currently detected pixels will be discarded.

    Since: 2.17.1
    """)
    defectivePixelReadFromDevice = property(lib_mvIMPACT_acquire.ImageProcessing_defectivePixelReadFromDevice_get, doc=r"""
    Calling this method will download defective pixels from the device.
    Notes: 
    In order to collect **ALL** defective pixels the list of detected pixels is not emptied each time a download from the device is executed.
    In order to get rid of currently detected pixels an application must set the property
    **mvIMPACT::acquire::ImageProcessing::defectivePixelsFilterMode** to **mvIMPACT::acquire::dpfmResetCalibration**
    and then capture a fresh image. Only then all currently detected pixels will be discarded.


    This feature will only be supported by some devices providing a special interface inside their firmware.

    Since: 2.17.1

    Calling this method will return

    - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
    - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise. Most likely mvIMPACT::acquire::DMR_FEATURE_NOT_AVAILABLE if the device does not support this feature.
    """)
    defectivePixelWriteToDevice = property(lib_mvIMPACT_acquire.ImageProcessing_defectivePixelWriteToDevice_get, doc=r"""
    Calling this method will upload defective pixels from the device.
    Notes: 
    This will **NOT** automatically store this data in non-volatile memory on the device!
    A call to **mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl::mvDefectivePixelDataSave** might be needed!


    This feature will only be supported by some devices providing a special interface inside their firmware.

    Since: 2.17.1

    Calling this method will return

    - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
    - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise. Most likely mvIMPACT::acquire::DMR_FEATURE_NOT_AVAILABLE if the device does not support this feature.
    """)
    flatFieldFilterMode = property(lib_mvIMPACT_acquire.ImageProcessing_flatFieldFilterMode_get, doc=r"""
    An enumerated integer property defining the operation mode of the flat field correction filter.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TFlatFieldFilterMode**.
    """)
    flatFieldFilterCorrectionMode = property(lib_mvIMPACT_acquire.ImageProcessing_flatFieldFilterCorrectionMode_get, doc=r"""
    An enumerated integer property defining the correction mode of the flat field correction filter.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TFlatFieldFilterCorrectionMode**.
    """)
    flatFieldFilterCorrectionAoiMode = property(lib_mvIMPACT_acquire.ImageProcessing_flatFieldFilterCorrectionAoiMode_get, doc=r"""
    An enumerated integer property defining the correction AOI mode of the flat field correction filter.
    When using an AOI only the AOI region is corrected by this filter.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TAoiMode**.

    Since: 2.31.0
    """)
    flatFieldFilterCorrectionAoiOffsetX = property(lib_mvIMPACT_acquire.ImageProcessing_flatFieldFilterCorrectionAoiOffsetX_get, doc=r"""
    An integer property defining the correction AOI's X-offset of the flat field correction filter.

    Since: 2.31.0
    """)
    flatFieldFilterCorrectionAoiOffsetY = property(lib_mvIMPACT_acquire.ImageProcessing_flatFieldFilterCorrectionAoiOffsetY_get, doc=r"""
    An integer property defining the correction AOI's Y-offset of the flat field correction filter.

    Since: 2.31.0
    """)
    flatFieldFilterCorrectionAoiWidth = property(lib_mvIMPACT_acquire.ImageProcessing_flatFieldFilterCorrectionAoiWidth_get, doc=r"""
    An integer property defining the correction AOI's width of the flat field correction filter.

    Since: 2.31.0
    """)
    flatFieldFilterCorrectionAoiHeight = property(lib_mvIMPACT_acquire.ImageProcessing_flatFieldFilterCorrectionAoiHeight_get, doc=r"""
    An integer property defining the correction AOI's height of the flat field correction filter.

    Since: 2.31.0
    """)
    flatFieldFilterCalibrationImageCount = property(lib_mvIMPACT_acquire.ImageProcessing_flatFieldFilterCalibrationImageCount_get, doc=r""" An integer property defining the number of consecutive images to take into account during the calibration of the flat field filter.""")
    flatFieldFilterCalibrationAoiMode = property(lib_mvIMPACT_acquire.ImageProcessing_flatFieldFilterCalibrationAoiMode_get, doc=r"""
    An enumerated integer property defining the correction AOI mode of the flat field correction filter.
    When using an AOI only the AOI region is taken into consideration during calibration by this filter.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TAoiMode**.

    Since: 2.31.0
    """)
    flatFieldFilterCalibrationAoiOffsetX = property(lib_mvIMPACT_acquire.ImageProcessing_flatFieldFilterCalibrationAoiOffsetX_get, doc=r"""
    An integer property defining the calibration AOI's X-offset of the flat field correction filter.

    Since: 2.31.0
    """)
    flatFieldFilterCalibrationAoiOffsetY = property(lib_mvIMPACT_acquire.ImageProcessing_flatFieldFilterCalibrationAoiOffsetY_get, doc=r"""
    An integer property defining the calibration AOI's Y-offset of the flat field correction filter.

    Since: 2.31.0
    """)
    flatFieldFilterCalibrationAoiWidth = property(lib_mvIMPACT_acquire.ImageProcessing_flatFieldFilterCalibrationAoiWidth_get, doc=r"""
    An integer property defining the calibration AOI's width of the flat field correction filter.

    Since: 2.31.0
    """)
    flatFieldFilterCalibrationAoiHeight = property(lib_mvIMPACT_acquire.ImageProcessing_flatFieldFilterCalibrationAoiHeight_get, doc=r"""
    An integer property defining the calibration AOI's height of the flat field correction filter.

    Since: 2.31.0
    """)
    darkCurrentFilterMode = property(lib_mvIMPACT_acquire.ImageProcessing_darkCurrentFilterMode_get, doc=r"""
    An enumerated integer property defining the operation mode of the dark current filter.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDarkCurrentFilterMode**.
    """)
    darkCurrentFilterCalibrationImageCount = property(lib_mvIMPACT_acquire.ImageProcessing_darkCurrentFilterCalibrationImageCount_get, doc=r""" An integer property defining the number of consecutive images to take into account during calibration of the dark current filter.""")
    gainOffsetKneeEnable = property(lib_mvIMPACT_acquire.ImageProcessing_gainOffsetKneeEnable_get, doc=r"""
    An enumerated integer property which can be used to enable the Gain, Offset, Knee filter.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.
    """)
    gainOffsetKneeMasterOffset_pc = property(lib_mvIMPACT_acquire.ImageProcessing_gainOffsetKneeMasterOffset_pc_get, doc=r"""
    A float property that contains master offset(in percent).
    This offset will be applied before the channel specific gain.
    """)
    LUTEnable = property(lib_mvIMPACT_acquire.ImageProcessing_LUTEnable_get, doc=r"""
    An enumerated integer property which can be used to enable LUT (**L**ook **U**p **T**able) transformations.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.
    """)
    LUTMode = property(lib_mvIMPACT_acquire.ImageProcessing_LUTMode_get, doc=r"""
    An enumerated integer property which can be used to configure the LUT (**L**ook **U**p **T**able) transformation mode.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TLUTMode**.

    Notes: This property will be invisible when **mvIMPACT::acquire::ImageProcessing::LUTEnable** is set to
    **mvIMPACT::acquire::bFalse**.
    """)
    LUTInterpolationMode = property(lib_mvIMPACT_acquire.ImageProcessing_LUTInterpolationMode_get, doc=r"""
    An enumerated integer property which can be used to configure the LUT (**L**ook **U**p **T**able) interpolation mode.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TLUTInterpolationMode**.

    Notes: This property will be invisible when **mvIMPACT::acquire::ImageProcessing::LUTEnable** is set to
    **mvIMPACT::acquire::bFalse** or if **mvIMPACT::acquire::ImageProcessing::LUTMode** is **NOT** set to
    **mvIMPACT::acquire::LUTmInterpolated**.
    """)
    LUTImplementation = property(lib_mvIMPACT_acquire.ImageProcessing_LUTImplementation_get, doc=r"""
    An enumerated integer property which can be used to configure the LUT (**L**ook **U**p **T**able) implementation.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TLUTImplementation**.

    Notes: This property will be invisible when **mvIMPACT::acquire::ImageProcessing::LUTEnable** is set to
    **mvIMPACT::acquire::bFalse**.
    """)
    LUTMappingHardware = property(lib_mvIMPACT_acquire.ImageProcessing_LUTMappingHardware_get, doc=r"""
    An enumerated integer property which can be used to configure the LUT (**L**ook **U**p **T**able) mapping mode for LUT transformations done by the hardware.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TLUTMapping**.

    Notes: This property will be invisible when **mvIMPACT::acquire::ImageProcessing::LUTEnable** is set to
    **mvIMPACT::acquire::bFalse** or if **mvIMPACT::acquire::ImageProcessing::LUTImplementation** is **NOT** set to
    **mvIMPACT::acquire::LUTiHardware**.
    """)
    LUTMappingSoftware = property(lib_mvIMPACT_acquire.ImageProcessing_LUTMappingSoftware_get, doc=r"""
    An enumerated integer property which can be used to configure the LUT (**L**ook **U**p **T**able) mapping mode for LUT transformations done optimized software algorithms.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TLUTMapping**.

    Notes: This property will be invisible when **mvIMPACT::acquire::ImageProcessing::LUTEnable** is set to
    **mvIMPACT::acquire::bFalse** or if **mvIMPACT::acquire::ImageProcessing::LUTImplementation** is **NOT** set to
    **mvIMPACT::acquire::LUTiSoftware**.
    """)
    tapSortEnable = property(lib_mvIMPACT_acquire.ImageProcessing_tapSortEnable_get, doc=r"""
    An enumerated integer property which can be used to enable/disable automatic data re-ordering from image sources delivering data from multiple taps that require re-ordering to reconstruct the image.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.
    """)
    channelSplitEnable = property(lib_mvIMPACT_acquire.ImageProcessing_channelSplitEnable_get, doc=r"""
    An enumerated integer property which can be used to enable/disable automatic data re-ordering or extraction from multi-channel images.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.
    """)
    channelSplitMode = property(lib_mvIMPACT_acquire.ImageProcessing_channelSplitMode_get, doc=r"""
    An enumerated integer property which can be used to define how data from multi-channel images shall be re-ordered.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TChannelSplitMode**.
    """)
    channelSplitChannelIndex = property(lib_mvIMPACT_acquire.ImageProcessing_channelSplitChannelIndex_get, doc=r"""
    An integer property which can be used to define which channel of the image shall be extracted.
    This property will only be visible if **mvIMPACT::acquire::ImageProcessing::channelSplitMode** is set
    to **mvIMPACT::acquire::csmExtractSingle**.
    """)
    channelSplitDeinterlaceEnable = property(lib_mvIMPACT_acquire.ImageProcessing_channelSplitDeinterlaceEnable_get, doc=r"""
    An enumerated integer property which can be used to enable/disable data re-ordering for interlaced images.
    Enabling this feature will cause interlaced images in a way that the 2 fields will be display next to each other. This
    will modify the original image in an image with twice the width but half the height.

    Notes: 
    Right now this property will only result in correct results for images, that are line wise interlaced, thus
    some special sensors that e.g. transfer Bayer interlaced data (2 lines field 0, 2 lines field even, etc.)
    can not be re-arranged in a meaningful way.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.
    """)
    colorTwistInputCorrectionMatrixEnable = property(lib_mvIMPACT_acquire.ImageProcessing_colorTwistInputCorrectionMatrixEnable_get, doc=r"""
    An enumerated integer property which can be used to enable/disable the color twist input correction matrix.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.

    Since: 2.2.2.
    """)
    colorTwistInputCorrectionMatrixMode = property(lib_mvIMPACT_acquire.ImageProcessing_colorTwistInputCorrectionMatrixMode_get, doc=r"""
    An enumerated integer property which can be used to select an input color correction matrix.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode**.

    Since: 2.2.2.
    """)
    colorTwistInputCorrectionMatrixRow0 = property(lib_mvIMPACT_acquire.ImageProcessing_colorTwistInputCorrectionMatrixRow0_get, doc=r"""
    The first row of the input color correction matrix.
    This property stores the first row of a user defined 3x3 input color correction matrix if
    **mvIMPACT::acquire::ImageProcessing::colorTwistInputCorrectionMatrixMode** is set to
    **mvIMPACT::acquire::cticmmUser**. For other values of **mvIMPACT::acquire::ImageProcessing::colorTwistInputCorrectionMatrixMode**
    modifying this property will have no effect.

    Since: 2.2.2.
    """)
    colorTwistInputCorrectionMatrixRow1 = property(lib_mvIMPACT_acquire.ImageProcessing_colorTwistInputCorrectionMatrixRow1_get, doc=r"""
    The second row of the input color correction matrix.
    This property stores the second row of a user defined 3x3 input color correction matrix if
    **mvIMPACT::acquire::ImageProcessing::colorTwistInputCorrectionMatrixMode** is set to
    **mvIMPACT::acquire::cticmmUser**. For other values of **mvIMPACT::acquire::ImageProcessing::colorTwistInputCorrectionMatrixMode**
    modifying this property will have no effect.

    Since: 2.2.2.
    """)
    colorTwistInputCorrectionMatrixRow2 = property(lib_mvIMPACT_acquire.ImageProcessing_colorTwistInputCorrectionMatrixRow2_get, doc=r"""
    The third row of the input color correction matrix.
    This property stores the third row of a user defined 3x3 input color correction matrix if
    **mvIMPACT::acquire::ImageProcessing::colorTwistInputCorrectionMatrixMode** is set to
    **mvIMPACT::acquire::cticmmUser**. For other values of **mvIMPACT::acquire::ImageProcessing::colorTwistInputCorrectionMatrixMode**
    modifying this property will have no effect.

    Since: 2.2.2.
    """)
    colorTwistEnable = property(lib_mvIMPACT_acquire.ImageProcessing_colorTwistEnable_get, doc=r"""
    An enumerated integer property which can be used to enable/disable the color twist matrix.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.

    The color twist filter can be used to apply a linear transformation to a 3 channel image. Each pixel will
    at first be multiplied by a 3x3 matrix and afterwards an offset triplet can be added.

    Since: 2.2.2.
    """)
    colorTwistRow0 = property(lib_mvIMPACT_acquire.ImageProcessing_colorTwistRow0_get, doc=r"""
    The first row of the color twist matrix.
    This property stores 4 values. The first 3 components for the first row of the 3x4 matrix, the last component is the
    offset of this row.

    Since: 2.2.2.
    """)
    colorTwistRow1 = property(lib_mvIMPACT_acquire.ImageProcessing_colorTwistRow1_get, doc=r"""
    The second row of the color twist matrix.
    This property stores 4 values. The first 3 components for the second row of the 3x4 matrix, the last component is the
    offset of this row.

    Since: 2.2.2.
    """)
    colorTwistRow2 = property(lib_mvIMPACT_acquire.ImageProcessing_colorTwistRow2_get, doc=r"""
    The third row of the color twist matrix.
    This property stores 4 values. The first 3 components for the third row of the 3x4 matrix, the last component is the
    offset of this row.

    Since: 2.2.2.
    """)
    colorTwistOutputCorrectionMatrixEnable = property(lib_mvIMPACT_acquire.ImageProcessing_colorTwistOutputCorrectionMatrixEnable_get, doc=r"""
    An enumerated integer property which can be used to enable/disable the color twist output correction matrix.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.

    Since: 2.2.2.
    """)
    colorTwistOutputCorrectionMatrixMode = property(lib_mvIMPACT_acquire.ImageProcessing_colorTwistOutputCorrectionMatrixMode_get, doc=r"""
    An enumerated integer property which can be used to select an output color correction matrix.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode**.

    Since: 2.2.2.
    """)
    colorTwistOutputCorrectionMatrixRow0 = property(lib_mvIMPACT_acquire.ImageProcessing_colorTwistOutputCorrectionMatrixRow0_get, doc=r"""
    The first row of the output color correction matrix.
    This property stores the first row of a user defined 3x3 output color correction matrix if
    **mvIMPACT::acquire::ImageProcessing::colorTwistOutputCorrectionMatrixMode** is set to
    **mvIMPACT::acquire::ctocmmUser**. For other values of **mvIMPACT::acquire::ImageProcessing::colorTwistOutputCorrectionMatrixMode**
    modifying this property will have no effect.

    Since: 2.2.2.
    """)
    colorTwistOutputCorrectionMatrixRow1 = property(lib_mvIMPACT_acquire.ImageProcessing_colorTwistOutputCorrectionMatrixRow1_get, doc=r"""
    The second row of the output color correction matrix.
    This property stores the second row of a user defined 3x3 output color correction matrix if
    **mvIMPACT::acquire::ImageProcessing::colorTwistOutputCorrectionMatrixMode** is set to
    **mvIMPACT::acquire::ctocmmUser**. For other values of **mvIMPACT::acquire::ImageProcessing::colorTwistOutputCorrectionMatrixMode**
    modifying this property will have no effect.

    Since: 2.2.2.
    """)
    colorTwistOutputCorrectionMatrixRow2 = property(lib_mvIMPACT_acquire.ImageProcessing_colorTwistOutputCorrectionMatrixRow2_get, doc=r"""
    The third row of the output color correction matrix.
    This property stores the third row of a user defined 3x3 output color correction matrix if
    **mvIMPACT::acquire::ImageProcessing::colorTwistOutputCorrectionMatrixMode** is set to
    **mvIMPACT::acquire::ctocmmUser**. For other values of **mvIMPACT::acquire::ImageProcessing::colorTwistOutputCorrectionMatrixMode**
    modifying this property will have no effect.

    Since: 2.2.2.
    """)
    colorTwistResultingMatrixRow0 = property(lib_mvIMPACT_acquire.ImageProcessing_colorTwistResultingMatrixRow0_get, doc=r"""
    The first row of the resulting color twist matrix.
    This property will store the first row of the 3x4 resulting color twist matrix. This matrix
    is created by multiplying the input correction matrix by the color twist matrix by the output correction matrix.
    Only active matrices will be used to calculate the resulting matrix.

    Since: 2.2.2.
    """)
    colorTwistResultingMatrixRow1 = property(lib_mvIMPACT_acquire.ImageProcessing_colorTwistResultingMatrixRow1_get, doc=r"""
    The second row of the resulting color twist matrix.
    This property will store the second row of the 3x4 resulting color twist matrix. This matrix
    is created by multiplying the input correction matrix by the color twist matrix by the output correction matrix.
    Only active matrices will be used to calculate the resulting matrix.

    Since: 2.2.2.
    """)
    colorTwistResultingMatrixRow2 = property(lib_mvIMPACT_acquire.ImageProcessing_colorTwistResultingMatrixRow2_get, doc=r"""
    The third row of the resulting color twist matrix.
    This property will store the third row of the 3x4 resulting color twist matrix. This matrix
    is created by multiplying the input correction matrix by the color twist matrix by the output correction matrix.
    Only active matrices will be used to calculate the resulting matrix.

    Since: 2.2.2.
    """)
    formatReinterpreterEnable = property(lib_mvIMPACT_acquire.ImageProcessing_formatReinterpreterEnable_get, doc=r"""
    An enumerated integer property which can be used to enable/disable the format reinterpreter filter.
    This filter can be used if a device transmits data in a non-compliant or incorrect format. Using this filter the incoming
    data will simply be treated as a different pixel format then. This will **NOT** copy or modify the pixel data but will only
    adjust some of the elements describing the buffer (e.g. the pixel format and width). When e.g. setting this filter to treat
    mono data as RGB data, this will result in buffers with a width divided by 3 but RGB pixels instead of mono pixel afterwards.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.

    Since: 2.10.1
    """)
    formatReinterpreterMode = property(lib_mvIMPACT_acquire.ImageProcessing_formatReinterpreterMode_get, doc=r"""
    An enumerated integer property which can be used to configure the format reinterpreter filter.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TImageBufferFormatReinterpreterMode**.

    Since: 2.10.1
    """)
    formatReinterpreterBayerMosaicParity = property(lib_mvIMPACT_acquire.ImageProcessing_formatReinterpreterBayerMosaicParity_get, doc=r"""
    An enumerated integer property defining the new Bayer parity of this buffer.
    After applying the format reinterpreter this will be the new Bayer parity of the buffer when the filter is operated
    in one of the ``Mono`` ``To`` ``Mono`` modes.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBayerMosaicParity**.

    Since: 2.31.0
    """)
    rotationEnable = property(lib_mvIMPACT_acquire.ImageProcessing_rotationEnable_get, doc=r"""
    An enumerated integer property which can be used to enable/disable the rotation filter.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.

    Since: 2.13.2
    """)
    rotationAngle = property(lib_mvIMPACT_acquire.ImageProcessing_rotationAngle_get, doc=r"""
    The counterclockwise angle at which the image will be rotated.
    This property will store the counterclockwise angle at which the image will be rotated.

    Since: 2.13.2
    """)

    def setSaturation(self, K):
        r"""
         Sets the saturation by using the color twist matrix.
         The following saturation formula is used:

        .. code-block:: c++

              [0.299 + 0.701*K       , 0.587*(1-K) , 0.114*(1-K)     ]
              [0.299*(1-K) + 0.701*K , 0.587       , 0.114*(1-K)     ]
              [0.299*(1-K) + 0.701*K , 0.587*(1-K) , 0.114 + 0.886*K ]

         K is the saturation factor
         K > 1 increases saturation
         K = 1 means no change
         0 < K < 1 decreases saturation
         K = 0 produces B&W
         K < 0 inverts color

         Notes: 
         To enable/disable the saturation the application must write to **mvIMPACT::acquire::ImageProcessing::colorTwistEnable**.

        :type K: float
        :param K: [in] The saturation value.
        """
        return lib_mvIMPACT_acquire.ImageProcessing_setSaturation(self, K)

    def getGainOffsetKneeParameter(self, index):
        r"""
         Returns a reference to a set of user definable parameters to configure a certain channel of the GainOffsetKnee filter.
         If: DOXYGEN_CPP_DOCUMENTATION {
         If *nr* is invalid(too large) a STL out_of_range exception
         will be thrown.
         }

         :rtype: :py:class:`GainOffsetKneeChannelParameters`
         :return: A reference to one of the parameter sets for the GainOffsetKnee filter that
             can be altered by the user.

        :type index: int
        :param index: [in] The index of the gain, offset, knee parameter set to be returned
        """
        return lib_mvIMPACT_acquire.ImageProcessing_getGainOffsetKneeParameter(self, index)

    def getGainOffsetKneeParameterCount(self):
        r""" Returns the number of available user definable parameter sets for the GainOffsetKnee filter."""
        return lib_mvIMPACT_acquire.ImageProcessing_getGainOffsetKneeParameterCount(self)

    def getMirrorParameter(self, index):
        r"""
         Returns a reference to a set of user definable parameters to configure mirror filter related features.
         If: DOXYGEN_CPP_DOCUMENTATION {
         If *nr* is invalid(too large) a STL out_of_range exception
         will be thrown.
         }

         :rtype: :py:class:`MirrorParameters`
         :return: A reference to one of the parameter sets for mirror filter related features that
             can be altered by the user.

        :type index: int
        :param index: [in] The index of the mirror parameter set to be returned
        """
        return lib_mvIMPACT_acquire.ImageProcessing_getMirrorParameter(self, index)

    def getMirrorParameterCount(self):
        r""" Returns the number of available user definable parameter sets mirror filter related operations."""
        return lib_mvIMPACT_acquire.ImageProcessing_getMirrorParameterCount(self)

    def getLUTParameter(self, index):
        r"""
         Returns a reference to a set of user definable parameters to configure LUT (**L**ook **U**p **T**able) operations.
         If: DOXYGEN_CPP_DOCUMENTATION {
         If *nr* is invalid(too large) a STL out_of_range exception
         will be thrown.
         }

         :rtype: :py:class:`LUTParameters`
         :return: A reference to one of the parameter sets for LUT (**L**ook **U**p **T**able) operations that
             can be altered by the user.

        :type index: int
        :param index: [in] The index of the LUT parameter set to be returned
        """
        return lib_mvIMPACT_acquire.ImageProcessing_getLUTParameter(self, index)

    def getLUTParameterCount(self):
        r""" Returns the number of available user definable parameter sets for LUT (**L**ook **U**p **T**able) operations."""
        return lib_mvIMPACT_acquire.ImageProcessing_getLUTParameterCount(self)

    def getWBUserSetting(self, index):
        r"""
         Returns a reference to a set of user definable parameters to perform a white balance correction.
         Pass '0' for the setting that is activated by setting the property **mvIMPACT::acquire::ImageProcessing::whiteBalance**
         to **mvIMPACT::acquire::wbpUser1**, '1' for
         **mvIMPACT::acquire::wbpUser2** and so on.

         If: DOXYGEN_CPP_DOCUMENTATION {
         If *nr* is invalid(too large) a STL out_of_range exception
         will be thrown.
         }

         :rtype: :py:class:`WhiteBalanceSettings`
         :return: A reference to one of the parameter sets for white balance correction that
             can be altered by the user.

        :type index: int
        :param index: [in] The index of the white balance parameter set to be returned
        """
        return lib_mvIMPACT_acquire.ImageProcessing_getWBUserSetting(self, index)

    def getWBUserSettingsCount(self):
        r""" Returns the number of available user definable parameter sets for white balance correction."""
        return lib_mvIMPACT_acquire.ImageProcessing_getWBUserSettingsCount(self)

    r""" \brief An integer property \b (read-only) which holds the number of available user definable parameter sets for white balance correction. See mvIMPACT.acquire.ImageProcessing.getWBUserSettingsCount() """
    WBUserSettingsCount = property (getWBUserSettingsCount, None, None, None)
    r""" \brief An integer property \b (read-only) which holds the number of available user definable parameter sets for the GainOffsetKnee filter. See mvIMPACT.acquire.ImageProcessing.getGainOffsetKneeParameterCount() """
    gainOffsetKneeParameterCount = property (getGainOffsetKneeParameterCount, None, None, None)
    r""" \brief An integer property \b (read-only) which holds the number of available user definable parameter sets for LUT (<b>L</b>ook <b>U</b>p <b>T</b>able) operations. See mvIMPACT.acquire.ImageProcessing.getLUTParameterCount() """
    LUTParameterCount = property (getLUTParameterCount, None, None, None)


# Register ImageProcessing in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.ImageProcessing_swigregister(ImageProcessing)

class WhiteBalancer(object):
    r"""
    Convenience class to provide an easy way for a more precise white balance calibration.
    A convenience function which will be used to do a white balance calibration
    with more than 8bit image data to increase the precision of the calculated
    gain values.

    Notes: 
    Since a homogeneous grey image is needed for the processing, it is necessary
    that the camera is not configured to a triggered mode and a reasonable
    exposure time.
    """

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

    @staticmethod
    def highQualityWhiteBalance(pDev):
        return lib_mvIMPACT_acquire.WhiteBalancer_highQualityWhiteBalance(pDev)

    def __init__(self):
        lib_mvIMPACT_acquire.WhiteBalancer_swiginit(self, lib_mvIMPACT_acquire.new_WhiteBalancer())
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_WhiteBalancer

# Register WhiteBalancer in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.WhiteBalancer_swigregister(WhiteBalancer)

def WhiteBalancer_highQualityWhiteBalance(pDev):
    return lib_mvIMPACT_acquire.WhiteBalancer_highQualityWhiteBalance(pDev)

class Statistics(ComponentCollection):
    r"""
    Contains basic statistical information.
    This class contains basic statistical information about the **mvIMPACT::acquire::Device** and the
    the current image acquisition progress.
    """

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

    def __init__(self, pDev):
        lib_mvIMPACT_acquire.Statistics_swiginit(self, lib_mvIMPACT_acquire.new_Statistics(pDev))

    def reset(self):
        r"""
        Resets all statistical properties.
        :rtype: int
        :return: 
            - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
            - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.
        """
        return lib_mvIMPACT_acquire.Statistics_reset(self)
    captureTime_s = property(lib_mvIMPACT_acquire.Statistics_captureTime_s_get, doc=r"""
    A float property **(read-only)** containing the overall time an image request spent in the device drivers processing chain.
    This time is **NOT** the reciprocal of the frame rate, but usually a much longer period of time as it includes the time
    elapsed from sending the request into the capture queue until the buffer has been placed back into one of the result queues again.
    This time increases with the amount of requests being used.
    """)
    bandwidthConsumed = property(lib_mvIMPACT_acquire.Statistics_bandwidthConsumed_get, doc=r"""
    A float property **(read-only)** containing the current bandwidth consumed by this device in KB/s based on the average buffer size and the timestamps delivered from the device driver.
    Since: 2.12.3
    """)
    errorCount = property(lib_mvIMPACT_acquire.Statistics_errorCount_get, doc=r""" An integer property **(read-only)** containing the overall count of image requests which returned with an error since the **mvIMPACT::acquire::Device** has been opened OR since the last call to **mvIMPACT::acquire::Statistics::reset()**.""")
    abortedRequestsCount = property(lib_mvIMPACT_acquire.Statistics_abortedRequestsCount_get, doc=r""" An integer property **(read-only)** containing the overall count of image requests which have been aborted since the **mvIMPACT::acquire::Device** has been opened OR since the last call to **mvIMPACT::acquire::Statistics::reset()**.""")
    timedOutRequestsCount = property(lib_mvIMPACT_acquire.Statistics_timedOutRequestsCount_get, doc=r""" An integer property **(read-only)** containing the overall count of image requests which have timed out since the **mvIMPACT::acquire::Device** has been opened OR since the last call to **mvIMPACT::acquire::Statistics::reset()**.""")
    framesPerSecond = property(lib_mvIMPACT_acquire.Statistics_framesPerSecond_get, doc=r""" A float property **(read-only)** containing the current number of frames captured per second.""")
    frameCount = property(lib_mvIMPACT_acquire.Statistics_frameCount_get, doc=r"""
    An integer property **(read-only)** containing the overall count of images captured since the **mvIMPACT::acquire::Device** has been opened OR since the last call to **mvIMPACT::acquire::Statistics::reset()**.
    This counter is incremented regardless of the result a request is returned with thus also e.g. if a request did time out, was aborted(e.g. due to a call to **mvIMPACT::acquire::FunctionInterface::imageRequestReset** or **mvIMPACT::acquire::FunctionInterface::acquisitionStop)** or the data was not completely captured.
    """)
    imageProcTime_s = property(lib_mvIMPACT_acquire.Statistics_imageProcTime_s_get, doc=r"""
    An integer property **(read-only)** containing the time (in seconds) needed to process the image data internally.
    This time might be interesting e.g. if the image data is transformed into a color
    image by the driver (e.g. when working with Bayer mosaic cameras) or if any other processing function is applied to the
    image before it is transferred to the user.
    """)
    formatConvertTime_s = property(lib_mvIMPACT_acquire.Statistics_formatConvertTime_s_get, doc=r"""
    An integer property **(read-only)** containing the time (in seconds) needed to convert the image data delivered by the hardware and/or active internal driver filter nodes to the format specified by **mvIMPACT::acquire::ImageDestination::pixelFormat** internally.
    This time will be almost 0 when no custom destination pixel format has been specified and if a custom destination format
    was selected and this format differs from the pixel format that is transferred by the hardware this time will be a part
    (or all, but never more) than the time reported by **mvIMPACT::acquire::Statistics::imageProcTime_s**.

    Since: 1.12.58
    """)
    queueTime_s = property(lib_mvIMPACT_acquire.Statistics_queueTime_s_get, doc=r"""
    A float property **(read-only)** containing the average time (in seconds) a **mvIMPACT::acquire::Request** object spends in the request queue of the device.
    This is the time between a call to **mvIMPACT::acquire::FunctionInterface::imageRequestSingle()** and the time the driver actually uses this buffer
    to capture data into it or to forward it into a kernel driver.
    """)
    lostImagesCount = property(lib_mvIMPACT_acquire.Statistics_lostImagesCount_get, doc=r"""
    An integer property **(read-only)** containing the number of images that have been lost from a continuous image stream coming from a video signal source.
    Notes: 
    For some devices this value is based on an assumption so it's by no means absolutely accurate, but when this
    value starts to increase this might indicate that a problem is present.

    Possible causes (among others) might be:
    - the capture device or device driver can't cope with the amount of data the video signal source is delivering in the current mode of operation
    - the capture device or device driver can't transfer all the data to the host PC because of bus bandwidth shortages
    - the capture device or device driver image request queue ran low because the system is busy doing other things or because of a bug
    in the application


    This feature is supported by every device driver. If a device does not seem to support this feature (calling **mvIMPACT::acquire::Component::isValid** returns false)
    a driver update will fix this.
    """)
    framesIncompleteCount = property(lib_mvIMPACT_acquire.Statistics_framesIncompleteCount_get, doc=r"""
    An integer property **(read-only)** containing the overall count of image requests which haven't been captured completely since the **mvIMPACT::acquire::Device** has been opened.
    This value is a good indicator for bandwidth problems on the device to host connection.

    Notes: 
    This feature is supported by every device driver. If a device does not seem to support this feature (calling **mvIMPACT::acquire::Component::isValid** returns false)
    a driver update will fix this.
    """)
    missingDataAverage_pc = property(lib_mvIMPACT_acquire.Statistics_missingDataAverage_pc_get, doc=r"""
    A float property **(read-only)** containing the average amount of data missing in frames that haven't been captured completely since the **mvIMPACT::acquire::Device** has been opened OR since the last call to **mvIMPACT::acquire::Statistics::reset()**.
    This value is a good indicator for bandwidth problems on the device to host connection.

    Notes: 
    This feature is supported by every device driver. If a device does not seem to support this feature (calling **mvIMPACT::acquire::Component::isValid** returns false)
    a driver update will fix this.
    """)
    retransmitCount = property(lib_mvIMPACT_acquire.Statistics_retransmitCount_get, doc=r"""
    A 64 bit integer property **(read-only)** containing the number of retransmit requests issued due to temporary bus bandwidth shortages or other transmission problems since this **mvIMPACT::acquire::Device** has been opened OR since the last call to **mvIMPACT::acquire::Statistics::reset()**.
    This value can be an indicator for transmission problems because of bad signal quality or bus
    bandwidth shortages in the system.
    Ideally this property should stay 0 all the time if the system can cope with the amount of data transferred and the signal
    quality is good. However it might increase slowly and still every frame will be flawless as the driver internally was
    able to restore the lost data by re-requesting it from the video signal source again.

    Notes: 
    This feature is supported by every device driver. If a device does not seem to support this feature (calling **mvIMPACT::acquire::Component::isValid** returns false)
    a driver update will fix this.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_Statistics

# Register Statistics in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.Statistics_swigregister(Statistics)

class FullSettingsBase(object):
    r"""
    A base class that provides access to the most common settings for a device.
    Use one of the classes derived from this class to get access to all the available
    settings.
    """

    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"""
         brief Constructs a new **mvIMPACT::acquire::FullSettingsBase** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.FullSettingsBase_swiginit(self, lib_mvIMPACT_acquire.new_FullSettingsBase(*args))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_FullSettingsBase
    imageProcessing = property(lib_mvIMPACT_acquire.FullSettingsBase_imageProcessing_get, doc=r""" Image processing related properties.""")
    imageDestination = property(lib_mvIMPACT_acquire.FullSettingsBase_imageDestination_get, doc=r""" Properties to define the result images format.""")
    basedOn = property(lib_mvIMPACT_acquire.FullSettingsBase_basedOn_get, doc=r""" A string property **(read-only)** containing the name of the setting this setting is based on.""")

# Register FullSettingsBase in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.FullSettingsBase_swigregister(FullSettingsBase)

class SystemSettings(ComponentCollection):
    r"""
    A base class for accessing settings that control the overall behaviour of a device driver.
    Instances of this class can't be constructed directly. Use one of the derived types.
    """

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

    def __init__(self, pDev):
        r"""
         Constructs a new **mvIMPACT::acquire::SystemSettings** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        """
        lib_mvIMPACT_acquire.SystemSettings_swiginit(self, lib_mvIMPACT_acquire.new_SystemSettings(pDev))
    requestCount = property(lib_mvIMPACT_acquire.SystemSettings_requestCount_get, doc=r"""
    An integer property defining the number of requests allocated by the driver.
    Each request object can be used to capture data into. Multiple requests can be processed
    by a device driver as background tasks.

    Setting this property to a value at least allowing a driver to capture data for up to 500ms without user interaction (thus 0.5 times the expected frame rate) is highly
    recommended. Increasing this value will NOT introduce additional latency to your application. The only drawback will be additional RAM consumption by the driver but
    applications that do not need to copy the request buffers can even benefit from that as the overall memory fragmentation is likely to go down then.
    Values smaller than 3 most likely result in undesired behaviour and should be avoided unless absolutely needed.

    Notes: For performance reasons this value can be increased at any time(only exception: Working with the interface layout
    **mvIMPACT::acquire::dilGenICam** while streaming is active) but can only be
    decreased when no request object is currently locked by the application and no requests has been
    queued for acquisition. So modifying this value might require the application to call **mvIMPACT::acquire::FunctionInterface::imageRequestReset**
    and several calls to **mvIMPACT::acquire::Request::unlock** before.

    There are not too many reasons to modify the default request count suggested by the device driver. Good reasons include:

    - a single image is huge compared to the overall system memory(e.g. a single image has 200MB while the system itself only
    has about 2GB of RAM. Here it might make sense to reduce the number of capture buffers to 1 or 2. Please note that in such a
    scenario double buffering or live display when one buffer is constantly blocked by the display engine can become a challenge!
    - the frame rate is high(larger than 100 frames per second) and no frames shall be lost. Here it might make sense to set
    the number of capture buffers to something like frame rate divided by 2 to 5 as a rule of thumb.

    See also: 
    **mvIMPACT::acquire::FunctionInterface::requestCount**
    """)
    acquisitionMode = property(lib_mvIMPACT_acquire.SystemSettings_acquisitionMode_get, doc=r"""
    An enumerated integer property defining the acquisition mode of the device.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TAcquisitionMode**.
    """)
    acquisitionIdleTimeMax_ms = property(lib_mvIMPACT_acquire.SystemSettings_acquisitionIdleTimeMax_ms_get, doc=r"""
    An integer property defining the maximum time in ms the driver waits for new requests being queued until streaming by the device will automatically be stopped.
    This property defines the maximum time in milliseconds the driver waits for new **mvIMPACT::acquire::Request** objects being
    queued by calling **mvIMPACT::acquire::FunctionInterface::imageRequestSingle** once the driver will automatically send an
    acquisition stop command to a streaming device (such as a GigE Vision or USB3 Vision device) when the driver's request queue has run empty (thus the
    driver has no more buffers to capture data into).

    This property will only be taken into account when **mvIMPACT::acquire::Device::acquisitionStartStopBehaviour** has been set to
    **mvIMPACT::acquire::assbDefault**.

    Notes: 
    This property will not be available for every device. Right now only devices operated through the *GenTL* driver package will support
    this feature.

    Since: 2.4.1
    """)
    imageProcessingMode = property(lib_mvIMPACT_acquire.SystemSettings_imageProcessingMode_get, doc=r"""
     An enumerated integer property influencing the behaviour of the internal image processing pipeline.
     Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TImageProcessingMode**.

     Notes: 
     This property will only be available if **mvIMPACT::acquire::Device::userControlledImageProcessingEnable** has been
     set to **mvIMPACT::acquire::bTrue** before the device is opened.

    See also: 
    **mvIMPACT::acquire::Device::userControlledImageProcessingEnable**

    **mvIMPACT::acquire::Request::hasProcessingBeenSkipped**

     Since: 2.14.0
    """)
    imageProcessingOptimization = property(lib_mvIMPACT_acquire.SystemSettings_imageProcessingOptimization_get, doc=r"""
    An enumerated integer property influencing the behaviour of the internal image processing algorithms.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TImageProcessingOptimization**.

    Since: 2.12.2
    """)
    featurePollingEnable = property(lib_mvIMPACT_acquire.SystemSettings_featurePollingEnable_get, doc=r"""
     An enumerated integer property defining whether features defining a polling time shall be updated automatically or not.
     Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.

    See also: mvIMPACT::acquire::SystemSettings::featurePollingInterval_ms
    """)
    featurePollingInterval_ms = property(lib_mvIMPACT_acquire.SystemSettings_featurePollingInterval_ms_get, doc=r"""
    An integer property defining the polling interval in ms the driver waits for each iteration before running through update loop again.
    Some features define a so called ``polling`` ``time``. This is a recommendation by the device/driver stating that this property
    might change it's value without user interaction act a certain rate (e.g. the device temperature could be one example for a
    feature with such a behaviour). When **mvIMPACT::acquire::SystemSettings::featurePollingEnable** is set to
    **mvIMPACT::acquire::bTrue** a thread will check every ``featurePollingInterval_ms`` if features need to be updated. This will
    only cause communication with a device for each feature who's polling time has elapsed.

    Notes: 
    This property will not be available for every device. Right now only devices operated through the *GenTL* driver package will support
    this feature.

    Since: 2.18.3
    """)
    methodPollingInterval_ms = property(lib_mvIMPACT_acquire.SystemSettings_methodPollingInterval_ms_get, doc=r"""
    An integer property defining the polling interval in ms the driver waits during each iteration before checking a methods execution state again.
    When working with a GenICam compliant device, GenICam method objects need to be checked for their completion status every now
    and then. This parameter defines how often this shall be done.

    Notes: 
    This property will not be available for every device. Right now only devices operated through the *GenTL* driver package will support
    this feature.

    Since: 2.18.3
    """)
    methodPollingMaxRetryCount = property(lib_mvIMPACT_acquire.SystemSettings_methodPollingMaxRetryCount_get, doc=r"""
     An integer property defining the polling interval in ms the driver waits during each iteration before checking a methods execution state again.
     When working with a GenICam compliant device, GenICam method objects need to be checked for their completion status every now
     and then. This parameter defines how often this shall be done at all. A method is checked for completion
    ``methodPollingMaxRetryCount`` * ``methodPollingInterval_ms`` at max. Until then either the device starts to inform the driver
     that it needs more time **OR** the execution of the method has completed successfully **or** an error will be generated.

     Notes: 
     This property will not be available for every device. Right now only devices operated through the *GenTL* driver package will support
     this feature.

     Since: 2.18.3
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_SystemSettings

# Register SystemSettings in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.SystemSettings_swigregister(SystemSettings)

class ImageMemoryManager(ComponentCollection):
    r"""
    An interface class to access DMA memory related properties(**Device** specific interface layout only).
    This class can be used to configure the way the device works with DMA memory.
    This is an advanced feature and shall only be used if necessary or to
    fine tune an application to achieve optimal performance.

    All frame grabbers belonging to the mvTITAN, mvGAMMA, mvSIGMA and mvDELTA series use a special,
    preallocated block of memory(DMA memory) as target for fast image transfer. The total size of
    this block has to be set during driver installation. The memory is claimed from the operating
    system during startup and is shared between all installed devices.

    The memory size needed to achieve optimal performance depends on the image size to grab, the queue depth
    and the mode the memory manager is operated in.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TMemoryManagerMode**
    and can be selected by modifying the property **mvIMPACT::acquire::ImageMemoryManager::mode**.

    Notes: This class is currently available for frame grabber devices only.
    This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
    **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

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

    def __init__(self, pDev):
        r"""
         Constructs a new **mvIMPACT::acquire::ImageMemoryManager** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        """
        lib_mvIMPACT_acquire.ImageMemoryManager_swiginit(self, lib_mvIMPACT_acquire.new_ImageMemoryManager(pDev))
    mode = property(lib_mvIMPACT_acquire.ImageMemoryManager_mode_get, doc=r"""
    An enumerated integer property containing the mode the memory manager is currently operated in.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TMemoryManagerMode**.
    """)
    allocatedDMAMemory_bytes = property(lib_mvIMPACT_acquire.ImageMemoryManager_allocatedDMAMemory_bytes_get, doc=r""" An integer property **(read-only)** containing the size of the allocated DMA memory (in bytes).""")
    usedDMAMemory_bytes = property(lib_mvIMPACT_acquire.ImageMemoryManager_usedDMAMemory_bytes_get, doc=r""" An integer property **(read-only)** containing the size of the DMA memory (in bytes) currently used by the device.""")
    usedBlocks = property(lib_mvIMPACT_acquire.ImageMemoryManager_usedBlocks_get, doc=r""" An integer property **(read-only)** containing the number of individual blocks of DMA memory currently used by the device.""")
    poolMode = property(lib_mvIMPACT_acquire.ImageMemoryManager_poolMode_get, doc=r"""
    An enumerated integer property containing the mode the memory managers memory pool is currently operated in.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TMemoryManagerPoolMode**.
    """)
    poolBlockSize_bytes = property(lib_mvIMPACT_acquire.ImageMemoryManager_poolBlockSize_bytes_get, doc=r""" An integer property defining the size (in bytes) to use for each block of DMA memory.""")
    poolBlockCount = property(lib_mvIMPACT_acquire.ImageMemoryManager_poolBlockCount_get, doc=r""" An integer property **(read-only)** containing the number of individual blocks of DMA memory currently available when using the current pool block size and pool mode.""")
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_ImageMemoryManager

# Register ImageMemoryManager in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.ImageMemoryManager_swigregister(ImageMemoryManager)

class InfoBlueDevice(Info):
    r"""
    A more specific class to query information about a **mvBlueDevice** device and its driver(**Device** specific interface layout only).
    This class contains a collection of properties providing various information about
    a **mvBlueDevice** device and its driver.

    Notes: This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
    **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

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

    def __init__(self, pDev):
        r"""
         Constructs a new **mvIMPACT::acquire::InfoBlueDevice** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        """
        lib_mvIMPACT_acquire.InfoBlueDevice_swiginit(self, lib_mvIMPACT_acquire.new_InfoBlueDevice(pDev))
    sensorXRes = property(lib_mvIMPACT_acquire.InfoBlueDevice_sensorXRes_get, doc=r"""
    An integer property **(read-only)** containing the horizontal resolution of the camera sensor.
    If the device has more than one sensor head, and all these sensor heads can be accessed using the current interface,
    this property will contain as many values as the devices offers sensor heads.
    """)
    sensorYRes = property(lib_mvIMPACT_acquire.InfoBlueDevice_sensorYRes_get, doc=r"""
    An integer property **(read-only)** containing the vertical resolution of the camera sensor.
    If the device has more than one sensor head, and all these sensor heads can be accessed using the current interface,
    this property will contain as many values as the devices offers sensor heads.
    """)
    sensorColorMode = property(lib_mvIMPACT_acquire.InfoBlueDevice_sensorColorMode_get, doc=r"""
    An enumerated integer property **(read-only)** containing the type of the sensor (color/mono/...)(if known).
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TInfoSensorColorMode**.

    Notes: 
    If nothing is known about this feature, this property will contain **mvIMPACT::acquire::iscmUnknown**.

    If the device has more than one sensor head, and all these sensor heads can be accessed using the current interface,
    this property will contain as many values as the devices offers sensor heads.
    """)
    sensorType = property(lib_mvIMPACT_acquire.InfoBlueDevice_sensorType_get, doc=r"""
    An enumerated integer property **(read-only)** containing the type of sensor chip of the camera (if known).
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TInfoSensorType**.

    This usually will either be **mvIMPACT::acquire::istCCD** or **mvIMPACT::acquire::istCMOS**.

    If the device has more than one sensor head, and all these sensor heads can be accessed using the current interface,
    this property will contain as many values as the devices offers sensor heads.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_InfoBlueDevice

# Register InfoBlueDevice in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.InfoBlueDevice_swigregister(InfoBlueDevice)

class InfoBlueCOUGAR(InfoBlueDevice):
    r"""
    A more specific class to query information about a **mvBlueCOUGAR** devices and its driver(**Device** specific interface layout only).
    This class contains a collection of properties providing various information about
    a **mvBlueCOUGAR** devices and its driver.

    Notes: This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
    **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

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

    def __init__(self, pDev):
        r"""
         Constructs a new **mvIMPACT::acquire::InfoBlueCOUGAR** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        """
        lib_mvIMPACT_acquire.InfoBlueCOUGAR_swiginit(self, lib_mvIMPACT_acquire.new_InfoBlueCOUGAR(pDev))
    deviceFPGAVersion = property(lib_mvIMPACT_acquire.InfoBlueCOUGAR_deviceFPGAVersion_get, doc=r"""
    A 64 bit integer property **(read-only)** containing the current FPGA version of this device.
    Notes: 
    This feature is only supported by **mvBlueCOUGAR-S** devices.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_InfoBlueCOUGAR

# Register InfoBlueCOUGAR in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.InfoBlueCOUGAR_swigregister(InfoBlueCOUGAR)

class InfoBlueFOX(InfoBlueDevice):
    r"""
    A more specific class to query information about a **mvBlueFOX** device and its driver(**Device** specific interface layout only).
    This class contains a collection of properties providing various information about
    a **mvBlueFOX** device and its driver.

    Notes: This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
    **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

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

    def __init__(self, pDev):
        r"""
         Constructs a new **mvIMPACT::acquire::InfoBlueFOX** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        """
        lib_mvIMPACT_acquire.InfoBlueFOX_swiginit(self, lib_mvIMPACT_acquire.new_InfoBlueFOX(pDev))
    firmwareVersion = property(lib_mvIMPACT_acquire.InfoBlueFOX_firmwareVersion_get, doc=r""" An integer property **(read-only)** containing the firmware version of this device.""")
    sensorFPGAVersion = property(lib_mvIMPACT_acquire.InfoBlueFOX_sensorFPGAVersion_get, doc=r"""
    An integer property **(read-only)** containing the FPGA version of the camera(if known).
    Notes: 
    If nothing is known about this feature, this property will contain '-1'.
    """)
    sensorCaps = property(lib_mvIMPACT_acquire.InfoBlueFOX_sensorCaps_get, doc=r"""
    An integer property **(read-only)** containing a bit mask containing information about the sensors capabilities(if known).
    Notes: 
    If nothing is known about this feature, this property will contain '-1'.
    """)
    deviceSensorRevision = property(lib_mvIMPACT_acquire.InfoBlueFOX_deviceSensorRevision_get, doc=r"""
    A 64 bit integer property **(read-only)** containing the current revision of the sensor head of this device.
    Notes: 
    This feature is currently not supported by all sensors. If a sensor can't provide this information, the value
    of this property will remain 0 at all time.

    Since: 1.12.65
    """)
    userEEPROMSize = property(lib_mvIMPACT_acquire.InfoBlueFOX_userEEPROMSize_get, doc=r"""
    An integer property **(read-only)** containing the size of the user EEPROM that can be accessed using the I2C access features of **mvIMPACT::acquire::I2CControl**.
    Notes: 
    The size may vary depending on the product. Even different products with the same sensor might report
    different values here.


    The user EEPROM uses a virtual I2C address of 0x1A2 for write access and 0x1A3 for read access.
    """)
    deviceTemperature = property(lib_mvIMPACT_acquire.InfoBlueFOX_deviceTemperature_get, doc=r"""
    A float property **(read-only)** containing the temperature of the selected temperature sensor on the device in degrees Celsius.
    Notes: 
    This property will not be available for every mvBlueFOX. Right now this feature is only implemented for
    202d version of the mvBlueFOX.

    Since: 1.12.62
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_InfoBlueFOX

# Register InfoBlueFOX in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.InfoBlueFOX_swigregister(InfoBlueFOX)

class DigitalInput(object):
    r"""
    A class to represent a digital input pin(**Device** specific interface layout only).
    Notes: This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
    **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

    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

    def get(self):
        r"""
        Returns the current state of this input pin.
        :rtype: boolean
        :return: 
            - true if the current state of this pin is considered as 'logic 1'
            - false otherwise
        """
        return lib_mvIMPACT_acquire.DigitalInput_get(self)

    def getDescription(self):
        r"""
        Returns a description for this digital input.
        This might contain connector descriptions or other information like
        e.g. 'Trigger-In(J8.4/J8.5)', which means, this is the trigger input
        of connector *J8* pins *4* and *5*.
        """
        return lib_mvIMPACT_acquire.DigitalInput_getDescription(self)

    r""" \brief A string property \b (read-only) which holds a description for this digital input. See mvIMPACT.acquire.DigitalInput.getDescription() """
    description = property (getDescription, None, None, None)
    r""" \brief A bool property \b (read-only) which defines the output state of this digital input. See mvIMPACT.acquire.DigitalInput.get()"""
    state = property (get, None, None, None)

    __swig_destroy__ = lib_mvIMPACT_acquire.delete_DigitalInput

# Register DigitalInput in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.DigitalInput_swigregister(DigitalInput)

class DigitalOutput(object):
    r"""
    A class to represent a digital output pin(**Device** specific interface layout only).
    Notes: This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
    **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

    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

    def flip(self):
        r"""
        Inverts the current state of the digital output and returns the previous state.
        :rtype: boolean
        :return: 
            - true if the previous state of this pin was considered as 'logic 1'
            - false otherwise
        """
        return lib_mvIMPACT_acquire.DigitalOutput_flip(self)

    def get(self):
        r"""
        Returns the current state of this output pin.
        :rtype: boolean
        :return: 
            - true if the current state of this pin is considered as 'logic 1'
            - false otherwise
        """
        return lib_mvIMPACT_acquire.DigitalOutput_get(self)

    def getIsWriteable(self):
        r"""
        Checks if the caller has write/modify access to this digital output.
        Some devices will offer access to digital outputs, but these outputs can't be switched manually.
        E.g. a device might offer a digital output that can only be configured to stay either high or
        low during frame exposure but can't be switched to high at a certain user defined moment. For
        such an output, this function will return false.

        If the user calls a function belonging to this class that would modify the state of the
        associated digital output, an exception will be raised.

        :rtype: boolean
        :return: 
            - true if the caller is allowed to call write/modify operation for this component.
            - false otherwise.
        """
        return lib_mvIMPACT_acquire.DigitalOutput_getIsWriteable(self)

    def set(self):
        r""" Sets the output pin to 'logic 1'."""
        return lib_mvIMPACT_acquire.DigitalOutput_set(self)

    def reset(self):
        r""" Sets the output pin to 'logic 0'."""
        return lib_mvIMPACT_acquire.DigitalOutput_reset(self)

    def getDescription(self):
        r"""
        Returns a description for this digital output.
        This might contain connector descriptions or other information like
        e.g. 'CC1(J1)', which means, this is the CameraLink(R) control
        channel 1 of connector *J1*.
        """
        return lib_mvIMPACT_acquire.DigitalOutput_getDescription(self)

    def setState(self, boState):
        return lib_mvIMPACT_acquire.DigitalOutput_setState(self, boState)

    r""" \brief A string property \b (read-only) which holds a description for this digital output. See mvIMPACT.acquire.DigitalOutput.getDescription() """
    description = property (getDescription, None, None, None)
    r""" \brief A bool property which defines the output state of this digital output. See mvIMPACT.acquire.DigitalOutput.get(), mvIMPACT.acquire.DigitalOutput.set() and mvIMPACT.acquire.DigitalOutput.reset()"""
    state = property (get, setState, None, None)
    r""" \brief A bool property \b (read-only) which checks if the caller has write/modify access to this digital output. See mvIMPACT.acquire.DigitalOutput.getIsWriteable() """
    isWriteable = property (getIsWriteable, None, None, None)

    __swig_destroy__ = lib_mvIMPACT_acquire.delete_DigitalOutput

# Register DigitalOutput in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.DigitalOutput_swigregister(DigitalOutput)

class SyncOutput(ComponentCollection):
    r"""
    A class to represent a sync. output pin(**Device** specific interface layout only).
    Instances of this class can be used to define and generate sync. signals
    at the corresponding outputs of the device.

    Notes: 
    Instances of this class can't be constructed directly, but must be obtained
    via the device specific class derived from **mvIMPACT::acquire::IOSubSystem**.
    This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
    **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

    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
    frequency_Hz = property(lib_mvIMPACT_acquire.SyncOutput_frequency_Hz_get, doc=r""" A float property defining the frequency(in Hertz) for the sync. signal generated by this pin.""")
    lowPart_pc = property(lib_mvIMPACT_acquire.SyncOutput_lowPart_pc_get, doc=r""" A float property defining the width in percent the sync. signal stays low during one period. The output signal generated will be a square pulse.""")

    def getDescription(self):
        r"""
        Returns a description for this sync. output.
        This might contain connector descriptions or other information like
        e.g. 'VD-OUT(J9.24)', which means, this is the VD output at connector J9
        pin 24.
        """
        return lib_mvIMPACT_acquire.SyncOutput_getDescription(self)

    r""" \brief A string property \b (read-only) which holds a description for this sync. See mvIMPACT.acquire.SyncOutput.getDescription() """
    description = property (getDescription, None, None, None)

    __swig_destroy__ = lib_mvIMPACT_acquire.delete_SyncOutput

# Register SyncOutput in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.SyncOutput_swigregister(SyncOutput)

class RTCtrProgramStep(ComponentCollection):
    r"""
    A class to represent one step of a real time control(**RTCtr)** program (**Device** specific interface layout only).
    An object of this class represents a single instruction in a program represented
    by an **mvIMPACT::acquire::RTCtrProgram**. **mvIMPACT::acquire::RTCtrProgramStep** object can't be constructed
    directly, but must be accessed via the function
    **mvIMPACT::acquire::RTCtrProgram::programStep** of the program they belong
    to.

    The instruction this **mvIMPACT::acquire::RTCtrProgramStep** will executed when the program is
    executed is defined by the property **mvIMPACT::acquire::RTCtrProgramStep::opCode**. Depending
    on the value of this property certain other parameters will influence the
    behaviour of this instruction.

    Notes: This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
    **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

    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
    address = property(lib_mvIMPACT_acquire.RTCtrProgramStep_address_get, doc=r"""
    An integer property, which defines the absolute jump address within this **mvIMPACT::acquire::RTCtrProgram**.
    This property only is taken into account, if **mvIMPACT::acquire::RTCtrProgramStep::opCode** is set to **mvIMPACT::acquire::rtctrlProgJumpLoc**.
    """)
    frameID = property(lib_mvIMPACT_acquire.RTCtrProgramStep_frameID_get, doc=r"""
    An integer property, which defines the frame ID of the triggered image **mvIMPACT::acquire::RTCtrProgram**.
    This property only is taken into account, if **mvIMPACT::acquire::RTCtrProgramStep::opCode** is set to **mvIMPACT::acquire::rtctrlProgTriggerSet**.
    """)
    clocks_us = property(lib_mvIMPACT_acquire.RTCtrProgramStep_clocks_us_get, doc=r"""
    An integer property, which defines the waiting time **mvIMPACT::acquire::RTCtrProgram**.
    This property only is taken into account, if **mvIMPACT::acquire::RTCtrProgramStep::opCode** is set to **mvIMPACT::acquire::rtctrlProgWaitClocks**.
    """)
    digitalInputs = property(lib_mvIMPACT_acquire.RTCtrProgramStep_digitalInputs_get, doc=r"""
    An enumerated integer property to define for which digital input state this program step waits for.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDigIOState**.

    This property only is taken into account, if **mvIMPACT::acquire::RTCtrProgramStep::opCode** is set to **mvIMPACT::acquire::rtctrlProgWaitDigin**.
    """)
    digitalOutputs = property(lib_mvIMPACT_acquire.RTCtrProgramStep_digitalOutputs_get, doc=r"""
    An enumerated integer property to define how to set the digital outputs of this device.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDigIOState**.

    This property only is taken into account, if **mvIMPACT::acquire::RTCtrProgramStep::opCode** is set to **mvIMPACT::acquire::rtctrlProgSetDigout**.
    """)
    sensorHeads = property(lib_mvIMPACT_acquire.RTCtrProgramStep_sensorHeads_get, doc=r"""
    An enumerated integer property to define which sensor heads to trigger (for devices with more than one sensor head).
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDigIOState**.

    This property only is taken into account, if **mvIMPACT::acquire::RTCtrProgramStep::opCode** is set to **mvIMPACT::acquire::rtctrlProgTriggerSet**
    or **mvIMPACT::acquire::rtctrlProgTriggerReset**.
    """)
    opCode = property(lib_mvIMPACT_acquire.RTCtrProgramStep_opCode_get, doc=r"""
    An enumerated integer property defining the general purpose of this **mvIMPACT::acquire::RTCtrProgramStep** object.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TRTProgOpCodes**.
    """)
    controllerRegister = property(lib_mvIMPACT_acquire.RTCtrProgramStep_controllerRegister_get, doc=r"""
    An integer property, which defines the index of the controller register to refer in this **mvIMPACT::acquire::RTCtrProgramStep**.
    This property only is taken into account, if **mvIMPACT::acquire::RTCtrProgramStep::opCode** is set to
    **mvIMPACT::acquire::rtctrlProgRegisterSet**, **mvIMPACT::acquire::rtctrlProgRegisterAdd**,
    **mvIMPACT::acquire::rtctrlProgRegisterSub**, **mvIMPACT::acquire::rtctrlProgJumpLocOnZero**
    or **mvIMPACT::acquire::rtctrlProgJumpLocOnNotZero**.

    Notes: 
    This feature will not be available for every device offering a HRTC. It will be available if the translation
    dictionary of the property **mvIMPACT::acquire::RTCtrProgramStep::opCode** contains
    **mvIMPACT::acquire::rtctrlProgRegisterSet**, **mvIMPACT::acquire::rtctrlProgRegisterAdd**,
    **mvIMPACT::acquire::rtctrlProgRegisterSub**, **mvIMPACT::acquire::rtctrlProgJumpLocOnZero**
    or **mvIMPACT::acquire::rtctrlProgJumpLocOnNotZero**.

    Read the properties translation dictionary with
    the functions **mvIMPACT::acquire::PropertyIPulseStartTrigger::getTranslationDictString** and
    **mvIMPACT::acquire::PropertyIPulseStartTrigger::getTranslationDictValue**.
    If: DOXYGEN_CPP_DOCUMENTATION {
    C++ offers the more efficient function **mvIMPACT::acquire::PropertyIPulseStartTrigger::getTranslationDict**
    in addition to the functions mentioned above.
    }
    """)
    registerValue = property(lib_mvIMPACT_acquire.RTCtrProgramStep_registerValue_get, doc=r"""
    An integer property, which defines the a value to associate with a register access in this **mvIMPACT::acquire::RTCtrProgramStep**.
    This property only is taken into account, if **mvIMPACT::acquire::RTCtrProgramStep::opCode** is set to
    **mvIMPACT::acquire::rtctrlProgRegisterSet**, **mvIMPACT::acquire::rtctrlProgRegisterAdd**
    or **mvIMPACT::acquire::rtctrlProgRegisterSub**.

    Notes: 
    This feature will not be available for every device offering a HRTC. It will be available if the translation
    dictionary of the property **mvIMPACT::acquire::RTCtrProgramStep::opCode** contains
    **mvIMPACT::acquire::rtctrlProgRegisterSet**, **mvIMPACT::acquire::rtctrlProgRegisterAdd**,
    or **mvIMPACT::acquire::rtctrlProgRegisterSub**.

    Read the properties translation dictionary with
    the functions **mvIMPACT::acquire::PropertyIPulseStartTrigger::getTranslationDictString** and
    **mvIMPACT::acquire::PropertyIPulseStartTrigger::getTranslationDictValue**.
    If: DOXYGEN_CPP_DOCUMENTATION {
    C++ offers the more efficient function **mvIMPACT::acquire::PropertyIPulseStartTrigger::getTranslationDict**
    in addition to the functions mentioned above.
    }
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_RTCtrProgramStep

# Register RTCtrProgramStep in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.RTCtrProgramStep_swigregister(RTCtrProgramStep)

class RTCtrProgram(ComponentCollection):
    r"""
     A class to represent real time control programs(**Device** specific interface layout only).
     Real time control programs can be used to control the way how an when images
     are exposed and transmitted to the user.

     An **mvIMPACT::acquire::RTCtrProgram** e.g. can be used to achieve a constant frame rate with
     a desired frequency. This can be done e.g. by triggering the camera with a constant frequency.

     If: DOXYGEN_CPP_DOCUMENTATION {
     An appropriate signal for triggering the camera can be generated as follows:

    .. code-block:: c++

         #include mvIMPACT_CPP/mvIMPACT_acquire.h

         using namespace mvIMPACT::acquire;

         void runAt10Hz( Device* pBF )
         {
           CameraSettingsBlueFOX bfs( pBF );
           IOSubSystemBlueFOX bfIOs( pBF );
           // define a HRTC program that results in a define image frequency
           // the hardware real time controller shall be used to trigger an image
           bfs.triggerSource.write( ctsRTCtrl );
           // when the hardware real time controller switches the trigger signal to
           // high the exposure of the image shall start
           bfs.triggerMode.write( ctmOnRisingEdge );

           // error checks
           if( bfIOs.RTCtrProgramCount() == 0 )
           {
             // no HRTC controllers available (this never happens for the mvBlueFOX)
             return;
           }

           RTCtrProgram* pRTCtrlProgram = bfIOs.getRTCtrProgram( 0 );
           if( !pRTCtrlProgram )
           {
             // this only should happen if the system is short of memory
             return;
           }

           // start of the program

           // we need 5 steps for the program
           pRTCtrlProgram-setProgramSize(5);

           // wait a certain amount of time to achieve the desired frequency
           int progStep = 0;
           RTCtrProgramStep* pRTCtrlStep = 0;
           pRTCtrlStep = pRTCtrlProgram-programStep( progStep++ );
           pRTCtrlStep-opCode.write( rtctrlProgWaitClocks );
           pRTCtrlStep-clocks_us.write( 99900 );

           // trigger an image
           pRTCtrlStep = pRTCtrlProgram-programStep( progStep++ );
           pRTCtrlStep-opCode.write( rtctrlProgTriggerSet );

           // high time for the trigger signal (should not be smaller than 100 us)
           pRTCtrlStep = pRTCtrlProgram-programStep( progStep++ );
           pRTCtrlStep-opCode.write( rtctrlProgWaitClocks );
           pRTCtrlStep-clocks_us.write( 100 );

           // end trigger signal
           pRTCtrlStep = pRTCtrlProgram-programStep( progStep++ );
           pRTCtrlStep-opCode.write( rtctrlProgTriggerReset );

           // restart the program
           pRTCtrlStep = pRTCtrlProgram-programStep( progStep++ );
           pRTCtrlStep-opCode.write( rtctrlProgJumpLoc );
           pRTCtrlStep-address.write( 0 );

           // start the program
           pRTCtrlProgram-mode.write( rtctrlModeRun );

           // Now this camera will deliver images at exactly 10 Hz ( 1 / ( 99900 us + 100us ) )
           // when it is constantly feed with image requests.
         }
    }Else if: DOXYGEN_JAVA_DOCUMENTATION {

    .. code-block:: c++

         //=============================================================================
         public static void runAt10Hz( Device pBF )
         //=============================================================================
         {
           CameraSettingsBlueFOX bfs = new CameraSettingsBlueFOX( pBF );
           IOSubSystemBlueFOX bfIOs = new IOSubSystemBlueFOX( pBF );
           // define a HRTC program that results in a define image frequency
           // the hardware real time controller shall be used to trigger an image
           bfs.getTriggerSource().write( TCameraTriggerSource.ctsRTCtrl );
           // when the hardware real time controller switches the trigger signal to
           // high the exposure of the image shall start
           bfs.getTriggerMode().write( TCameraTriggerMode.ctmOnRisingEdge );

           // error checks
           if( bfIOs.RTCtrProgramCount() == 0 )
           {
             // no HRTC controllers available (this never happens for the mvBlueFOX)
             return;
           }

           RTCtrProgram pRTCtrlProgram = bfIOs.getRTCtrProgram( 0 );
           if( pRTCtrlProgram == null )
           {
             // this only should happen if the system is short of memory
             return;
           }

           // start of the program

           // we need 5 steps for the program
           pRTCtrlProgram.setProgramSize(5);

           // wait a certain amount of time to achieve the desired frequency
           int progStep = 0;
           RTCtrProgramStep pRTCtrlStep = null;
           pRTCtrlStep = pRTCtrlProgram.programStep( progStep++ );
           pRTCtrlStep.getOpCode().write( TRTProgOpCodes.rtctrlProgWaitClocks );
           pRTCtrlStep.getClocks_us().write( 99900 );

           // trigger an image
           pRTCtrlStep = pRTCtrlProgram.programStep( progStep++ );
           pRTCtrlStep.getOpCode().write( TRTProgOpCodes.rtctrlProgTriggerSet );

           // high time for the trigger signal (should not be smaller than 100 us)
           pRTCtrlStep = pRTCtrlProgram.programStep( progStep++ );
           pRTCtrlStep.getOpCode().write( TRTProgOpCodes.rtctrlProgWaitClocks );
           pRTCtrlStep.getClocks_us().write( 100 );

           // end trigger signal
           pRTCtrlStep = pRTCtrlProgram.programStep( progStep++ );
           pRTCtrlStep.getOpCode().write( TRTProgOpCodes.rtctrlProgTriggerReset );

           // restart the program
           pRTCtrlStep = pRTCtrlProgram.programStep( progStep++ );
           pRTCtrlStep.getOpCode().write( TRTProgOpCodes.rtctrlProgJumpLoc );
           pRTCtrlStep.getAddress().write( 0 );

           // start the program
           pRTCtrlProgram.getMode().write( TRTCtrlModes.rtctrlModeRun );

           // Now this camera will deliver images at exactly 10 Hz ( 1 / ( 99900 us + 100us ) )
           // when it is constantly feed with image requests.
         }
    }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

    .. code-block:: c++

         def runAt10Hz(pBF):
            bfs = acquire.CameraSettingsBlueFOX(pBF)
            bfIOs = acquire.IOSubSystemBlueFOX(pBF)
            # define a HRTC program that results in a define image frequency
            # the hardware real time controller shall be used to trigger an image
            bfs.triggerSource.write(acquire.ctsRTCtrl)
            # when the hardware real time controller switches the trigger signal to
            # high the exposure of the image shall start
            bfs.triggerMode.write(acquire.ctmOnRisingEdge)

            # error checks
            if bfIOs.RTCtrProgramCount == 0:
                # no HRTC controllers available (this never happens for the mvBlueFOX)
                return

           pRTCtrlProgram = bfIOs.getRTCtrProgram(0)
           if pRTCtrlProgram == None:
              # this only should happen if the system is short of memory
              return

           # start of the program
           # we need 5 steps for the program
           pRTCtrlProgram.setProgramSize(5)
           # wait a certain amount of time to achieve the desired frequency
           progStep = 0
           pRTCtrlStep = None
           pRTCtrlStep = pRTCtrlProgram.programStep(progStep)
           pRTCtrlStep.opCode.write(acquire.rtctrlProgWaitClocks)
           pRTCtrlStep.clocks_us.write(99900)

           # trigger an image
           progStep = progStep + 1
           pRTCtrlStep = pRTCtrlProgram.programStep(progStep)
           pRTCtrlStep.opCode.write(acquire.rtctrlProgTriggerSet)

           # high time for the trigger signal (should not be smaller than 100 us)
           progStep = progStep + 1
           pRTCtrlStep = pRTCtrlProgram.programStep(progStep)
           pRTCtrlStep.opCode.write(acquire.rtctrlProgWaitClocks)
           pRTCtrlStep.clocks_us.write(100)

           # end trigger signal
           progStep = progStep + 1
           pRTCtrlStep = pRTCtrlProgram.programStep(progStep)
           pRTCtrlStep.opCode.write(acquire.rtctrlProgTriggerReset)

           # restart the program
           progStep = progStep + 1
           pRTCtrlStep = pRTCtrlProgram.programStep(progStep)
           pRTCtrlStep.opCode.write(acquire.rtctrlProgJumpLoc)
           pRTCtrlStep.address.write(0)

           # start the program
           pRTCtrlProgram.mode.write(acquire.rtctrlModeRun)

           # Now this camera will deliver images at exactly 10 Hz (1 / (99900 us + 100us))
           # when it is constantly feed with image requests.
    }

     Once this program has been defined it can be executed by setting the *mode*
     property to **mvIMPACT::acquire::rtctrlModeRun**. As in this example we do not
     wait for an external signal the property **triggerMode**
     must be set to a value demanding an external signal
     (e.g. **mvIMPACT::acquire::ctmOnHighLevel** ; You will find a summary of the valid
     trigger modes in the sensor specific data in the "Sensor data" chapter of the
     specific product manual. **triggerMode** must be set to **mvIMPACT::acquire::ctsRTCtrl**
     to inform the driver that the signal generate by the real time program shall
     be used as the trigger signal.

     Notes: 
     **mvIMPACT::acquire::RTCtrProgram** objects can't be created directly! To access an **mvIMPACT::acquire::RTCtrProgram**
     associated with a certain device create an instance of an object derived from
     **mvIMPACT::acquire::IOSubSystem** and then use the function
     **mvIMPACT::acquire::IOSubSystem::RTCtrProgramCount()** to find out if there are
     hardware real time controller machines available for this device and if so how
     many of them can be accessed. Pointers to the machines then can be obtained by calling the
     function **mvIMPACT::acquire::IOSubSystem::getRTCtrProgram()** with the number of the
     controller (zero based) to be modified.

     This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
     **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

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

    def __init__(self, src):
        r"""
         Constructs a new **mvIMPACT::acquire::RTCtrProgram** from an existing one.
        :type src: :py:class:`RTCtrProgram`
        :param src: [in] A constant reference to the **mvIMPACT::acquire::RTCtrProgram** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.RTCtrProgram_swiginit(self, lib_mvIMPACT_acquire.new_RTCtrProgram(src))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_RTCtrProgram

    def setProgramSize(self, newSize):
        r"""
         A function to define the number of instructions this program should consist of.
        :type newSize: int
        :param newSize: [in] The new number of program instructions
        """
        return lib_mvIMPACT_acquire.RTCtrProgram_setProgramSize(self, newSize)

    def getProgramSize(self):
        r"""
        Returns the number of program instructions for this program.
        :rtype: int
        :return: The number of program instructions for this program.
        """
        return lib_mvIMPACT_acquire.RTCtrProgram_getProgramSize(self)

    def programStep(self, nr):
        r"""
         Returns a pointer to a program instruction of the program.
         If: DOXYGEN_CPP_DOCUMENTATION {
         If *nr* is invalid(too large) a STL out_of_range exception
         will be thrown.
         }

         :rtype: :py:class:`RTCtrProgramStep`
         :return: A pointer to a program instruction of the program.

        :type nr: int
        :param nr: [in] The index of the program instruction to obtain.
        """
        return lib_mvIMPACT_acquire.RTCtrProgram_programStep(self, nr)
    mode = property(lib_mvIMPACT_acquire.RTCtrProgram_mode_get, doc=r"""
    An enumerated integer property defining the current state this program is into.
    In order to affect the behaviour of the image acquisition an **mvIMPACT::acquire::RTCtrProgram** must be in
    running mode. Apart from that the property **triggerSource** must be set
    appropriately.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TRTCtrlModes**.
    """)
    filename = property(lib_mvIMPACT_acquire.RTCtrProgram_filename_get, doc=r"""
     A string property storing the filename for this program.
     **mvIMPACT::acquire::RTCtrProgram** s can be stored and loaded from/to XML files.
     To do this, this property must be set to the desired filename.
     See also: 
     **mvIMPACT::acquire::RTCtrProgram::load**,
    **mvIMPACT::acquire::RTCtrProgram::save**
    """)
    programState = property(lib_mvIMPACT_acquire.RTCtrProgram_programState_get, doc=r""" A string property **(read-only)** containing information about the current state of the program.""")

    def load(self):
        r"""
        Loads an existing program specified by the property **mvIMPACT::acquire::RTCtrProgram::fileName**.
        The default file extension for these programs is '*.rtp'. If the user doesn't
        specify this file extension, it is appended automatically. Only
        files of this type can be loaded by this function.
        :rtype: int
        :return: 
            - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
            - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.
        """
        return lib_mvIMPACT_acquire.RTCtrProgram_load(self)

    def save(self):
        r"""
        Stores the current state of the program under the name specified by the property **mvIMPACT::acquire::RTCtrProgram::filename**.
        The default file extension for files stored using this function is '*.rtp'. If
        the user doesn't specify this file extension, it is appended automatically. Only
        files of this type can be loaded by the function **mvIMPACT::acquire::RTCtrProgram::load**.
        :rtype: int
        :return: 
            - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
            - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.
        """
        return lib_mvIMPACT_acquire.RTCtrProgram_save(self)

    r""" \brief An integer property \b (read-only) which holds the number program instructions for this program. See mvIMPACT.acquire.RTCtrProgram.getProgramSize() """
    programSize = property (getProgramSize, setProgramSize, None, None)


# Register RTCtrProgram in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.RTCtrProgram_swigregister(RTCtrProgram)

class PulseStartConfiguration(ComponentCollection):
    r"""
    A class to configure the creation of digital signals passed to one or more of the digital outputs of a device(**Device** specific interface layout only).
    Notes: This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
    **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

    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

    def number(self):
        r""" Returns the internal number associated with this pulse start configuration."""
        return lib_mvIMPACT_acquire.PulseStartConfiguration_number(self)
    pulseStartTrigger = property(lib_mvIMPACT_acquire.PulseStartConfiguration_pulseStartTrigger_get, doc=r"""
    An enumerated integer property that will define how/when a digital signal is generated by the device.
    When certain digital output signals

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TPulseStartTrigger**.

    Notes: 
    Not every device will offer the same options.
    Check for valid modes by reading the properties translation dictionary with
    the functions **mvIMPACT::acquire::PropertyIPulseStartTrigger::getTranslationDictString** and
    **mvIMPACT::acquire::PropertyIPulseStartTrigger::getTranslationDictValue**.
    If: DOXYGEN_CPP_DOCUMENTATION {
    C++ offers the more efficient function **mvIMPACT::acquire::PropertyIPulseStartTrigger::getTranslationDict**
    in addition to the functions mentioned above.
    }
    """)
    digitalSignal = property(lib_mvIMPACT_acquire.PulseStartConfiguration_digitalSignal_get, doc=r"""
    An enumerated property to define one or more signals that will trigger the creation of the associated output signals.
    This property will be visible and thus active when **mvIMPACT::acquire::PulseStartConfiguration::digitalSignal** is switched
    to **mvIMPACT::acquire::pstDigitalSignal**.

    Depending on the device one or more signals can be defined as 'active for output signal creation'. When more than one signal can be
    defined, calling **mvIMPACT::acquire::PropertyIDigitalSignal::allowsValueCombinations** will return true.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDigitalSignal**.

    **mvHYPERION** **specific**:
    Currently when more than one signal can be defined here, these signals will have an 'or relationship', which means that when any of these
    signals is detected, it will trigger the creation of the associated output signals.

    The following signals are defined:


      |enum Value
      |Associated signal
    |
    -

      |mvIMPACT::acquire::dsSignal1
      |Line Valid(J1)
    |

      |mvIMPACT::acquire::dsSignal2
      |Line Valid(J2)
    |

      |mvIMPACT::acquire::dsSignal3
      |Frame Valid(J1)
    |

      |mvIMPACT::acquire::dsSignal4
      |Frame Valid(J2)
    |

      |mvIMPACT::acquire::dsSignal5
      |Trigger-In(J3.4/J3.5)
    |

      |mvIMPACT::acquire::dsSignal6
      |Sync-In(J3.6/J3.7)
    |

      |mvIMPACT::acquire::dsSignal7
      |Trigger-In(J4.4/J4.5)
    |

      |mvIMPACT::acquire::dsSignal8
      |Sync-In(J4.6/J4.7)
    |

      |mvIMPACT::acquire::dsSignal9
      |DigIn0(J6.9)
    |

      |mvIMPACT::acquire::dsSignal10
      |DigIn1(J6.10)
    |

      |mvIMPACT::acquire::dsSignal11
      |DigIn2(J6.11)
    |

      |mvIMPACT::acquire::dsSignal12
      |DigIn3(J6.12)
    |
    """)
    divider = property(lib_mvIMPACT_acquire.PulseStartConfiguration_divider_get, doc=r"""
    An integer property defining a factor by which the external input signal shall divided.
    Every *divider-value* pulse will be used then. All others will be skipped.
    """)
    frequency_Hz = property(lib_mvIMPACT_acquire.PulseStartConfiguration_frequency_Hz_get, doc=r"""
    A float property defining the frequency in Hz. for the creation of the output signals associated with configuration.
    This property will be visible and thus active when **mvIMPACT::acquire::PulseStartConfiguration::digitalSignal** is switched
    to **mvIMPACT::acquire::pstPeriodically**.
    """)
    triggerMoment = property(lib_mvIMPACT_acquire.PulseStartConfiguration_triggerMoment_get, doc=r"""
    An enumerated integer property defining the exact moment when this pulse start configuration shall be triggered.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TTriggerMoment**.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PulseStartConfiguration

# Register PulseStartConfiguration in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PulseStartConfiguration_swigregister(PulseStartConfiguration)

class IOSubSystem(object):
    r"""
    A base class to handle digital inputs and outputs(**Device** specific interface layout only).
    This class can't be instantiated by the user, but acts as a base class for
    hardware specific classes. Please use a device specific class suitable for the device
    you are working with instead. The documentation of the device specific class will also
    contain some example code.

    Notes: This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
    **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

    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__ = lib_mvIMPACT_acquire.delete_IOSubSystem

    def getPulseStartConfiguration(self, nr):
        r"""
         Returns a pointer to a **mvIMPACT::acquire::PulseStartConfiguration** associated with this device.
         If: DOXYGEN_CPP_DOCUMENTATION {
         If *nr* is invalid(too large) a STL out_of_range exception
         will be thrown.
         }

        :type nr: int
        :param nr: [in] The number of the pulse start configuration to return
        """
        return lib_mvIMPACT_acquire.IOSubSystem_getPulseStartConfiguration(self, nr)

    def getPulseStartConfigurationCount(self):
        r""" Returns the number of **mvIMPACT::acquire::PulseStartConfiguration** objects available for the **mvIMPACT::acquire::Device** associated with this object."""
        return lib_mvIMPACT_acquire.IOSubSystem_getPulseStartConfigurationCount(self)

    def getRTCtrProgram(self, nr):
        r"""
         Returns a pointer to a **mvIMPACT::acquire::RTCtrProgram** associated with this device.
         If: DOXYGEN_CPP_DOCUMENTATION {
         If *nr* is invalid(too large) a STL out_of_range exception
         will be thrown.
         }

        :type nr: int
        :param nr: [in] The number of the real time controller program to return
        """
        return lib_mvIMPACT_acquire.IOSubSystem_getRTCtrProgram(self, nr)

    def getRTCtrProgramCount(self):
        r""" Returns the number of **mvIMPACT::acquire::RTCtrProgram** s available for the **mvIMPACT::acquire::Device** associated with this object."""
        return lib_mvIMPACT_acquire.IOSubSystem_getRTCtrProgramCount(self)

    def getInputCount(self):
        r""" Returns the number of **mvIMPACT::acquire::DigitalInput** s available for the **mvIMPACT::acquire::Device** associated with this object."""
        return lib_mvIMPACT_acquire.IOSubSystem_getInputCount(self)

    def readInputRegister(self):
        r"""
        Returns the current state of the digital input register.
        This function can be used to read all digital inputs as a single value. Each
        bit represents the status of one digital output pin.

        **EXAMPLE**

        A value of '3' returned by this function means that digital inputs 0 and 1 are
        currently have a voltage considered as logical '1' applied to them.
        """
        return lib_mvIMPACT_acquire.IOSubSystem_readInputRegister(self)

    def getInput(self, nr):
        r"""
         Returns a const pointer to a **mvIMPACT::acquire::DigitalInput** object.

         If: DOXYGEN_CPP_DOCUMENTATION {
         If *nr* references an invalid pin a STL out_of_range exception
         will be thrown.
         }

         Notes: 
         The possibility to access the digital inputs of a device as single objects is
         just provided for convenience. The same thing can be achieved by calling the
         function **mvIMPACT::acquire::IOSubSystem::readInputRegister**.

        :type nr: int
        :param nr: [in] The number of the digital input.
        """
        return lib_mvIMPACT_acquire.IOSubSystem_getInput(self, nr)

    def getOutput(self, nr):
        r"""
         Returns a pointer to a **mvIMPACT::acquire::DigitalOutput** object.
         If: DOXYGEN_CPP_DOCUMENTATION {
         If *nr* references an invalid pin a STL out_of_range exception
         will be thrown.
         }

         Notes: 
         The possibility to access the digital outputs of a device as single objects is
         just provided for convenience. The same thing can be achieved by calling the function
         **mvIMPACT::acquire::IOSubSystem::writeOutputRegister** with the corresponding bit mask.

        :type nr: int
        :param nr: [in] The number of the digital output.
        """
        return lib_mvIMPACT_acquire.IOSubSystem_getOutput(self, nr)

    def getOutputCount(self):
        r""" Returns the number of digital outputs available for the **mvIMPACT::acquire::Device** associated with this object."""
        return lib_mvIMPACT_acquire.IOSubSystem_getOutputCount(self)

    def readOutputRegister(self):
        r"""
        Returns the current state of the digital output register.
        This function can be used to read all digital outputs as a single value. Each
        bit represents the status of one digital output pin.

        **EXAMPLE**

        A value of '3' returned by this function means that digital output 0 and 1 are
        currently set to high.
        """
        return lib_mvIMPACT_acquire.IOSubSystem_readOutputRegister(self)

    def writeOutputRegister(self, *args):
        r"""
         Alters the state of the digital output register.
         This function can be used to alter the state of certain (or all) digital outputs
         with a single function call. By working with the parameter *mask* certain bits
         can remain unaffected.

         **EXAMPLE**

         If the previous state of a digital output register was '5', which means that outputs
         0 and 2 are set to high a call to
         **mvIMPACT::acquire::IOSubSystem::writeOutputRegister** with
         *value* set to 2 and *mask* set to 3 would result in '6' as the new value for the
         output register. Pin 2 will remain unaffected, as *mask* states just to modify
         pin 0 and 1 ( 3 = 00000011 binary ).

        .. code-block:: c++

             currentValue = 5, mask = 3, value = 2
             ( currentValue  ~mask ) | value - new Value
             ( 00000101b(current value)  11111100(~mask) ) | 00000010(value) - 0000110(new value of the register)

        :type value: int
        :param value: [in] The value to be applied to the output register
        :type mask: int
        :param mask: [in] The mask to specify which pins to modify. A bit set to '1' in this parameter means that the state of this output has to adopt its style according to the value in *value*.
        """
        return lib_mvIMPACT_acquire.IOSubSystem_writeOutputRegister(self, *args)

    r""" \brief An integer property \b (read-only) which holds the number of mvIMPACT.acquire.DigitalInput s available for the mvIMPACT.acquire.Device associated with this object. See mvIMPACT.acquire.IOSubSystem.getInputCount() """
    inputCount = property (getInputCount, None, None, None)
    r""" \brief An integer property \b (read-only) which holds the number of digital outputs available for the mvIMPACT.acquire.Device associated with this object. See mvIMPACT.acquire.IOSubSystem.getOutputCount() """
    outputCount = property (getOutputCount, None, None, None)
    r""" \brief An integer property \b (read-only) which holds the number of mvIMPACT.acquire.PulseStartConfiguration objects available for the mvIMPACT.acquire.Device associated with this object. See mvIMPACT.acquire.IOSubSystem.getPulseStartConfigurationCount() """
    pulseStartConfigurationCount = property (getPulseStartConfigurationCount, None, None, None)
    r""" \brief An integer property \b (read-only) which holds the number of mvIMPACT.acquire.RTCtrProgram s available for the mvIMPACT.acquire.Device associated with this object. See mvIMPACT.acquire.IOSubSystem.getRTCtrProgramCount() """
    RTCtrProgramCount = property (getRTCtrProgramCount, None, None, None)


# Register IOSubSystem in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.IOSubSystem_swigregister(IOSubSystem)

class IOSubSystemBlueFOX(IOSubSystem):
    r"""
     A class to handle the digital inputs and outputs for **mvBlueFOX** USB cameras(**Device** specific interface layout only).
     If: DOXYGEN_CPP_DOCUMENTATION {
     A sample to show how to work with this class and the mvBlueFOX (Creating and instance
     of this class for another device might raise an exception):

    .. code-block:: c++

         #include iostream
         #include mvIMPACT_CPP/mvIMPACT_acquire.h

         using namespace std;
         using namespace mvIMPACT::acquire;

         void doSomeIOStuff( Device* pBF )
         {
           IOSubSystemBlueFOX bfIOs( pBF );
           cout < "output 0 was " < bfIOs.output(0)-get() < " and is now(after flipping) ";
           bfIOs.output(0)-flip();
           cout < bfIOs.output(0)-get() < endl;
           cout < "input threshold(" < bfIOs.digitalInputThreshold.readS() < ") set to " < bfdit10V < endl;
           if( bfIOs.digitalInputThreshold.isWriteable() ) // mvBlueFOX-M doesn't support modifying the input threshold
           {
             bfIOs.digitalInputThreshold.write( bfdit10V );
             cout < "input threshold is now " < bfIOs.digitalInputThreshold.readS() < endl;
           }
           cout < "input 0 is " < bfIOs.input(0)-get() < endl;
           cout < "press ENTER." < endl;
           cin.get();
           cout < "input 0 is " < bfIOs.input(0)-get() < endl;
           cout < "press ENTER." < endl;
           cin.get();
           cout < "input 0 is " < bfIOs.input(0)-get() < endl;
           // switch on digital out 0 and 1 ( 3 = 00000011 binary )
           bfIOs.writeOutputRegister( 3 );
           cout < "outputs: " < bfIOs.readOutputRegister() < ", inputs: " < bfIOs.readInputRegister();
           // the next line will reset bit 0 only, resulting in output 1 to remain high
           // as the mask parameter of '1' defines that only the LSB of the register will be
           // affected by the first parameter of the function call
           bfIOs.writeOutputRegister( 0, 1 );
           cout < "outputs: " < bfIOs.readOutputRegister() < ", inputs " < bfIOs.readInputRegister() < endl;
         }
    }Else if: DOXYGEN_JAVA_DOCUMENTATION {

    .. code-block:: c++

          public static void doSomeIOStuff( Device pBF )
          {
            IOSubSystemBlueFOX bfIOs = new mvIMPACT.acquire.IOSubSystemBlueFOX( pBF );
            System.out.println( "output 0 was " + bfIOs.output(0).get() + " and is now(after flipping) ");
            bfIOs.output(0).flip();
            System.out.println( bfIOs.output(0).get() );
            System.out.println( "input threshold(" + bfIOs.getDigitalInputThreshold().readS() + ") set to " + TBlueFOXDigitalInputThreshold .bfdit10V );
            if( bfIOs.getDigitalInputThreshold().isWriteable() ) // mvBlueFOX-M doesn't support modifying the input threshold
            {
              bfIOs.getDigitalInputThreshold().write( TBlueFOXDigitalInputThreshold .bfdit10V );
              System.out.println( "input threshold is now " + bfIOs.getDigitalInputThreshold().readS() );
            }
            System.out.println( "input 0 is " + bfIOs.input(0).get());
            System.out.println( "press ENTER." );
            waitForENTER();
            System.out.println( "input 0 is " + bfIOs.input(0).get() );
            System.out.println( "press ENTER." );
            waitForENTER();
            System.out.println( "input 0 is " + bfIOs.input(0).get() );
            // switch on digital out 0 and 1 ( 3 = 00000011 binary )
            bfIOs.writeOutputRegister( 3 );
            System.out.println( "outputs: " + bfIOs.readOutputRegister() + ", inputs: " + bfIOs.readInputRegister());
            // the next line will reset bit 0 only, resulting in output 1 to remain high
            // as the mask parameter of '1' defines that only the LSB of the register will be
            // affected by the first parameter of the function call
            bfIOs.writeOutputRegister( 0, 1 );
            System.out.println( "outputs: " + bfIOs.readOutputRegister() + ", inputs " + bfIOs.readInputRegister() );
          }
    }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

    .. code-block:: c++

         def doSomeIOStuff(pBF):
           bfIOs = acquire.IOSubSystemBlueFOX(pBF)
           print("output 0 was " + str(bfIOs.getOutput(0).get()) + " and is now(after flipping) ")
           bfIOs.getOutput(0).flip()
           print(bfIOs.getOutput(0).get())
           print("input threshold(" + bfIOs.digitalInputThreshold.readS() + ") set to " + str(acquire.bfdit10V))
           if(bfIOs.digitalInputThreshold.isWriteable): # mvBlueFOX-M doesn't support modifying the input threshold
             bfIOs.digitalInputThreshold.write(acquire.bfdit10V)
             print("input threshold is now " + bfIOs.digitalInputThreshold.readS())

           print("input 0 is " + str(bfIOs.getInput(0).get()))
           time.sleep(5) # wait for 5 seconds
           print("input 0 is " + str(bfIOs.getInput(0).get()))
           time.sleep(5) # wait for 5 seconds
           print("input 0 is " + str(bfIOs.getInput(0).get()))
           # switch on digital out 0 and 1 (3 = 00000011 binary)
           bfIOs.writeOutputRegister(3)
           print("outputs: " + str(bfIOs.readOutputRegister()) + ", inputs: " + str(bfIOs.readInputRegister()))
           # the next line will reset bit 0 only, resulting in output 1 to remain high
           # as the mask parameter of '1' defines that only the LSB of the register will be
           # affected by the first parameter of the function call
           bfIOs.writeOutputRegister(0, 1)
           print("outputs: " + str(bfIOs.readOutputRegister()) + ", inputs " + str(bfIOs.readInputRegister()))
    }

     Notes: 
     The **mvBlueFOX** defines an additional property **mvIMPACT::acquire::CameraSettingsBlueFOX::flashMode**.
     This might affect the state of the digital outputs as well.

     If a digital output is defined to be 'logic 0' but the flash mode is switched on
     for the same digital output, the output will be high during the expose time of
     the camera sensor. If a digital output is defined to be 'logic 1' the output will
     be high all the time.

     This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
     **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

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

    def __init__(self, pDev):
        r"""
         Constructs a new **mvIMPACT::acquire::IOSubSystemBlueFOX** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        """
        lib_mvIMPACT_acquire.IOSubSystemBlueFOX_swiginit(self, lib_mvIMPACT_acquire.new_IOSubSystemBlueFOX(pDev))

    def readInputRegisterAtomic(self):
        r"""
        Returns the current state of the digital input register.
        This function can be used to read all digital inputs as a single value **at** the same time. Each
        bit represents the status of one digital output pin.

        **EXAMPLE**

        A value of '3' returned by this function means that digital inputs 0 and 1 are
        currently have a voltage considered as logical '1' applied to them.
        """
        return lib_mvIMPACT_acquire.IOSubSystemBlueFOX_readInputRegisterAtomic(self)

    def readOutputRegisterAtomic(self):
        r"""
        Returns the current state of the digital output register.
        This function can be used to read all digital outputs as a single value **at** the same time. Each
        bit represents the status of one digital output pin.

        **EXAMPLE**

        A value of '3' returned by this function means that digital output 0 and 1 are
        currently set to high.
        """
        return lib_mvIMPACT_acquire.IOSubSystemBlueFOX_readOutputRegisterAtomic(self)

    def writeOutputRegister(self, *args):
        r"""
         Alters the state of the digital output register.
         This function can be used to alter the state of certain (or all) digital outputs
         with a single function call. By working with the parameter *mask* certain bits
         can remain unaffected.

         **EXAMPLE**

         If the previous state of a digital output register was '5', which means that outputs
         0 and 2 are set to high a call to
         **mvIMPACT::acquire::IOSubSystem::writeOutputRegister** with
         *value* set to 2 and *mask* set to 3 would result in '6' as the new value for the
         output register. Pin 2 will remain unaffected, as *mask* states just to modify
         pin 0 and 1 ( 3 = 00000011 binary ).

        :type value: int
        :param value: [in] The value to be applied to the output register
        :type mask: int
        :param mask: [in] The mask to specify which pins to modify. A bit set to '1' in this parameter means that the state of this output has to adopt its style according to the value in *value*.
        """
        return lib_mvIMPACT_acquire.IOSubSystemBlueFOX_writeOutputRegister(self, *args)

    def writeOutputRegisterAtomic(self, *args):
        r"""
         Alters the state of the digital output register.
         This function can be used to alter the state of certain (or all) digital outputs
         with a single function call **at** the same time. By working with the parameter *mask*
         certain bits can remain unaffected.

         **EXAMPLE**

         If the previous state of a digital output register was '5', which means that outputs
         0 and 2 are set to high a call to
         **mvIMPACT::acquire::IOSubSystem::writeOutputRegister** with
         *value* set to 2 and *mask* set to 3 would result in '6' as the new value for the
         output register. Pin 2 will remain unaffected, as *mask* states just to modify
         pin 0 and 1 ( 3 = 00000011 binary ).

        :type value: int
        :param value: [in] The value to be applied to the output register
        :type mask: int
        :param mask: [in] The mask to specify which pins to modify. A bit set to '1' in this parameter means that the state of this output has to adopt its style according to the value in *value*.
        """
        return lib_mvIMPACT_acquire.IOSubSystemBlueFOX_writeOutputRegisterAtomic(self, *args)
    digitalInputThreshold = property(lib_mvIMPACT_acquire.IOSubSystemBlueFOX_digitalInputThreshold_get, doc=r"""
    An enumerated integer property defining the threshold for the digital inputs in Volt.
    If a voltage applied to the digital input lies above the threshold this pin
    will be considered as 'logic 1' otherwise it will be considered as 'logic 0'.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBlueFOXDigitalInputThreshold**.

    Notes: 
    This property is **read-only** for **mvBlueFOX-M** devices and will always be 2V.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_IOSubSystemBlueFOX

# Register IOSubSystemBlueFOX in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.IOSubSystemBlueFOX_swigregister(IOSubSystemBlueFOX)

class IOSubSystemCommon(IOSubSystem):
    r"""
     A base class to handle the digital inputs and outputs for devices (**Device** specific interface layout only).
     This class provides a convenient basic access to the digital inputs and
     outputs of almost every device supported by this interface.

     Notes: 
     This class may **NOT** be used for mvBlueFOX devices.


     The number of digital inputs and outputs available will vary significantly
     from device to device. Some devices might not even have digital inputs and/or
     digital outputs. Therefore it's crucial to check for available pins before
     using them. The corresponding functions to do that can be found in the
     base class **mvIMPACT::acquire::IOSubSystem**.

    If: DOXYGEN_CPP_DOCUMENTATION {

    .. code-block:: c++

         #include mvIMPACT_CPP/mvIMPACT_acquire.h
         #include iostream

         using namespace std;
         using namespace mvIMPACT::acquire;

         // lists all available digital inputs and outputs and their description
         void listIOPins( Device* pDev )
         {
           IOSubSystemCommon io( pDev );
           unsigned int iCnt = io.getInputCount();
           cout < "available digital inputs: " < iCnt < endl;
           for( unsigned int d=0; diCnt; d++ )
           {
             out < io.input(d)-getDescription() < endl;
           }
           unsigned int oCnt = io.getOutputCount();
           cout < "available digital outputs: " < oCnt < endl;
           for( unsigned int e=0; eoCnt; e++ )
           {
             DigitalOutput* pOutput = io.output(e);
             out < "setting " < pOutput-getDescription() < " to high" < endl;
             // set this output to logic '1'
             pOutput-set();
           }
         }
    }Else if: DOXYGEN_JAVA_DOCUMENTATION {

    .. code-block:: c++

         import mvIMPACT.acquire.*;

         //-----------------------------------------------------------------------------
         public class CameraDescriptionManagerExample
         //-----------------------------------------------------------------------------
         {
           //=============================================================================
           //=== Static member functions =================================================
           //=============================================================================
           static
           {
             try
             {
               System.loadLibrary( "mvIMPACT_Acquire.java" );
             }
             catch( UnsatisfiedLinkError e )
             {
               System.err.println( "Native code library failed to load. Make sure the 'mvIMPACT_Acquire.java' library can be found in the systems search path.\n" + e );
               System.exit( 1 );
             }
           }

           //-----------------------------------------------------------------------------
           public static void main( String[] args )
           //-----------------------------------------------------------------------------
           {
             DeviceManager devMgr = new DeviceManager();
             Device pDev = mvIMPACT.acquire.examples.helper.DeviceAccess.getDeviceFromUserInput( devMgr );
             if( pDev == null )
             {
               System.out.print( "Unable to continue!" );
               mvIMPACT.acquire.examples.helper.DeviceAccess.waitForENTER();
               System.exit( 1 );
             }

             System.out.println( "Initialising the device. This might take some time..." );
             try
             {
               pDev.open();
             }
             catch( ImpactAcquireException e )
             {
               // this e.g. might happen if the same device is already opened in another process...
               System.out.println( "An error occurred while opening device " + pDev.getSerial().read() +
                                   "(error code: " + e.getMessage() + ")." );
               mvIMPACT.acquire.examples.helper.DeviceAccess.waitForENTER();
               System.exit( 1 );
             }

             try
             {
               // the next line will raise an exception if this device is not a frame grabber
               IOSubSystemFrameGrabber io = new IOSubSystemFrameGrabber( pDev );
               final long iCnt = io.getInputCount();
               System.out.println( String.format( "Available digital inputs: %d", iCnt ) );
               for( long d=0; diCnt; d++ )
               {
                 System.out.println( io.input( d ).getDescription() );
               }
               final long oCnt = io.getOutputCount();
               System.out.println( String.format( "Available digital outputs: %d", oCnt ) );
               // set all available digital outputs to high
               for( long e=0; eoCnt; e++ )
               {
                 DigitalOutput pOutput = io.output( e );
                 System.out.println( "setting " + pOutput.getDescription() + " to high" );
                 pOutput.set();
               }
             }
             catch( ImpactAcquireException e )
             {
               System.out.println( "An error occurred: " + e.getMessage() + "." );
               mvIMPACT.acquire.examples.helper.DeviceAccess.waitForENTER();
               System.exit( 1 );
             }
           }
         }
    }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

    .. code-block:: c++

         def listIOPins(pDev):
           io = acquire.IOSubSystemCommon(pDev)
           iCnt = io.getInputCount()
           print("available digital inputs: " + str(iCnt))
           for d in range(iCnt):
               print(io.getInput(d).getDescription())

           oCnt = io.getOutputCount()
           print("available digital outputs: " + str(oCnt))
           for e in range(oCnt):
               pOutput = io.getOutput(e)
               print("setting " + pOutput.getDescription() + " to high")
               # set this output to logic '1'
               pOutput.state = True
    }

     This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
     **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

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

    def __init__(self, pDev):
        r"""
         Constructs a new **mvIMPACT::acquire::IOSubSystemCommon** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        """
        lib_mvIMPACT_acquire.IOSubSystemCommon_swiginit(self, lib_mvIMPACT_acquire.new_IOSubSystemCommon(pDev))

    def writeOutputRegister(self, *args):
        r"""
         Alters the state of the digital output register.
         This function can be used to alter the state of certain (or all) digital outputs
         with a single function call. By working with the parameter *mask* certain bits
         can remain unaffected.

         **EXAMPLE**

         If the previous state of a digital output register was '5', which means that outputs
         0 and 2 are set to high a call to
         **mvIMPACT::acquire::IOSubSystem::writeOutputRegister** with
         *value* set to 2 and *mask* set to 3 would result in '6' as the new value for the
         output register. Pin 2 will remain unaffected, as *mask* states just to modify
         pin 0 and 1 ( 3 = 00000011 binary ).

        :type value: int
        :param value: [in] The value to be applied to the output register
        :type mask: int
        :param mask: [in] The mask to specify which pins to modify. A bit set to '1' in this parameter means that the state of this output has to adopt its style according to the value in *value*.
        """
        return lib_mvIMPACT_acquire.IOSubSystemCommon_writeOutputRegister(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_IOSubSystemCommon

# Register IOSubSystemCommon in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.IOSubSystemCommon_swigregister(IOSubSystemCommon)

class OutputSignalGeneratorBlueDevice(object):
    r"""
    A class to create complex digital output signals(**Device** specific interface layout only).
    Instances of this class can be used to create more complex digital output
    related signals like a single pulse or sequence of pulses on a certain pin
    as a reaction on a signal on one of the digital inputs of a device.

    The availability of the features provided by this class heavily depends on the
    used capture device. Therefore it's crucial to check if a desired feature is available
    at all. This class either provides the functions needed for these checks or its
    functions will return appropriate error codes.

    Notes: This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
    **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

    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"""
        *Overload 1:*
         Constructs a new **mvIMPACT::acquire::OutputSignalGeneratorBlueDevice** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::OutputSignalGeneratorBlueDevice** from and existing one.
        :type src: :py:class:`OutputSignalGeneratorBlueDevice`
        :param src: [in] A constant reference to the **mvIMPACT::acquire::OutputSignalGeneratorBlueDevice** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.OutputSignalGeneratorBlueDevice_swiginit(self, lib_mvIMPACT_acquire.new_OutputSignalGeneratorBlueDevice(*args))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_OutputSignalGeneratorBlueDevice

    def undefineSignal(self, pOutput):
        r"""
         Removes the signal definition from the specified output pin.
         Whenever a signal has been defined for a a certain digital output
         pin, this pin can no longer controlled using the corresponding functions
         in the class **mvIMPACT::acquire::DigitalOutput**. This function removes the
         signal definition and hands back manual control of that digital output to the user.
         :rtype: int
         :return: 
             - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
             - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.

        :type pOutput: :py:class:`DigitalOutput`
        :param pOutput: [in] A pointer to a **mvIMPACT::acquire::DigitalOutput** object obtained from an instance of the class **mvIMPACT::acquire::IOSubSystemCommon** for this device.
        """
        return lib_mvIMPACT_acquire.OutputSignalGeneratorBlueDevice_undefineSignal(self, pOutput)

    def canCreateExposeActiveSignal(self, pOutput):
        r"""
         Checks whether the specified output can be used to create an inverted expose active signal.
        :type pOutput: :py:class:`DigitalOutput`
        :param pOutput: [in] A pointer to a **mvIMPACT::acquire::DigitalOutput** object obtained from an instance of the class **mvIMPACT::acquire::IOSubSystemCommon** for this device.
        """
        return lib_mvIMPACT_acquire.OutputSignalGeneratorBlueDevice_canCreateExposeActiveSignal(self, pOutput)

    def canInvertSignal(self, pOutput):
        r"""
         Checks whether the specified output can be used to create an inverted version of a certain signal.
        :type pOutput: :py:class:`DigitalOutput`
        :param pOutput: [in] A pointer to a **mvIMPACT::acquire::DigitalOutput** object obtained from an instance of the class **mvIMPACT::acquire::IOSubSystemCommon** for this device.
        """
        return lib_mvIMPACT_acquire.OutputSignalGeneratorBlueDevice_canInvertSignal(self, pOutput)

    def getOutputMode(self, pOutput):
        r"""
         Returns the current mode a digital output is operated in. If the mode is not selectable for the current output an exception will be raised.
        :type pOutput: :py:class:`DigitalOutput`
        :param pOutput: [in] A pointer to a **mvIMPACT::acquire::DigitalOutput** object obtained from an instance of the class **mvIMPACT::acquire::IOSubSystemCommon** for this device.
        """
        return lib_mvIMPACT_acquire.OutputSignalGeneratorBlueDevice_getOutputMode(self, pOutput)

    def isOutputModeActive(self, pOutput, mode):
        r"""
         Checks whether the specified output is currently operated in a certain mode.
        :type pOutput: :py:class:`DigitalOutput`
        :param pOutput: [in] A pointer to a **mvIMPACT::acquire::DigitalOutput** object obtained from an instance of the class **mvIMPACT::acquire::IOSubSystemCommon** for this device.
        :type mode: int
        :param mode: [in] The mode the specified output shall be checked for.
        """
        return lib_mvIMPACT_acquire.OutputSignalGeneratorBlueDevice_isOutputModeActive(self, pOutput, mode)

    def isSignalInverted(self, pOutput):
        r"""
         Checks whether the specified output will currently invert a certain internal signal.
        :type pOutput: :py:class:`DigitalOutput`
        :param pOutput: [in] A pointer to a **mvIMPACT::acquire::DigitalOutput** object obtained from an instance of the class **mvIMPACT::acquire::IOSubSystemCommon** for this device.
        """
        return lib_mvIMPACT_acquire.OutputSignalGeneratorBlueDevice_isSignalInverted(self, pOutput)

    def setOutputMode(self, pOutput, mode, boInverted=False):
        r"""
         This function will configure the digital output to operate in a certain mode.
         After calling this function the digital output will be operated in the mode specified by
         *mode*.

         Valid values for *constant* are defined by the enum **mvIMPACT::acquire::TDeviceDigitalOutputMode**.

         :rtype: int
         :return: 
             - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
             - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.

        :type pOutput: :py:class:`DigitalOutput`
        :param pOutput: [in] A pointer to a **mvIMPACT::acquire::DigitalOutput** object obtained from an instance of the class **mvIMPACT::acquire::IOSubSystemCommon** for this device.
        :type mode: int
        :param mode: [in] The mode the specified output shall be operated in. If the mode passed to the function is not available for the output or the device an exception will be raised.
        :type boInverted: boolean
        :param boInverted: [in] Set this parameter to true, to invert the exposure signal
        """
        return lib_mvIMPACT_acquire.OutputSignalGeneratorBlueDevice_setOutputMode(self, pOutput, mode, boInverted)

# Register OutputSignalGeneratorBlueDevice in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.OutputSignalGeneratorBlueDevice_swigregister(OutputSignalGeneratorBlueDevice)

class IOSubSystemFrameGrabber(IOSubSystemCommon):
    r"""
    A class to handle the digital inputs and outputs for frame grabber devices(**Device** specific interface layout only).
    This class provides a convenient basic access to the digital inputs and
    outputs of a frame grabber device.

    Notes: 
    The number of digital inputs and outputs available will vary significantly
    from device to device. Some devices might not even have digital inputs and/or
    digital outputs. Therefore it's crucial to check for available pins before
    using them. The corresponding functions to do that can be found in the
    base class **mvIMPACT::acquire::IOSubSystem**.

    To create more complex digital output related signals the class
    **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber** should be used.

    This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
    **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

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

    def __init__(self, pDev):
        r"""
         Constructs a new **mvIMPACT::acquire::IOSubSystemFrameGrabber** object.
        :type pDev: :py:class:`Device`
        :param pDev: A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        """
        lib_mvIMPACT_acquire.IOSubSystemFrameGrabber_swiginit(self, lib_mvIMPACT_acquire.new_IOSubSystemFrameGrabber(pDev))

    def getHDOutputCount(self):
        r""" Returns the number of available HD output pins for the **mvIMPACT::acquire::Device** associated with this object."""
        return lib_mvIMPACT_acquire.IOSubSystemFrameGrabber_getHDOutputCount(self)

    def HDOutput(self, nr):
        r"""
         Returns a pointer to a **mvIMPACT::acquire::SyncOutput** object that represents a HD output for this device.
         *nr* **MUST** be a valid number ( larger or equal than 0 and smaller than the
         value returned by **mvIMPACT::acquire::IOSubSystemFrameGrabber::getHDOutputCount**.

         If: DOXYGEN_CPP_DOCUMENTATION {
         If *nr* references an invalid pin a STL out_of_range exception
         will be thrown.
         }

         :rtype: :py:class:`SyncOutput`
         :return: A pointer to a **mvIMPACT::acquire::SyncOutput** object.

        :type nr: int
        :param nr: [in] The number of the HD output to return.
        """
        return lib_mvIMPACT_acquire.IOSubSystemFrameGrabber_HDOutput(self, nr)

    def getVDOutputCount(self):
        r""" Returns the number of available VD output pins for the **mvIMPACT::acquire::Device** associated with this object."""
        return lib_mvIMPACT_acquire.IOSubSystemFrameGrabber_getVDOutputCount(self)

    def VDOutput(self, nr):
        r"""
         Returns a pointer to a **mvIMPACT::acquire::SyncOutput** object that represents a VD output for this device.
         *nr* **MUST** be a valid number ( larger or equal than 0 and smaller than the
         value returned by **mvIMPACT::acquire::IOSubSystemFrameGrabber::getVDOutputCount**.
         If: DOXYGEN_CPP_DOCUMENTATION {
         If *nr* references an invalid pin a STL out_of_range exception
         will be thrown.
         }

         :rtype: :py:class:`SyncOutput`
         :return: A pointer to a **mvIMPACT::acquire::SyncOutput** object.

        :type nr: int
        :param nr: [in] The number of the VD output to return.
        """
        return lib_mvIMPACT_acquire.IOSubSystemFrameGrabber_VDOutput(self, nr)
    syncOutputMode = property(lib_mvIMPACT_acquire.IOSubSystemFrameGrabber_syncOutputMode_get, doc=r"""
    An enumerated integer property defining the current mode for sync. signal creation.
    Sometimes it's desired to create a signal to sync. cameras connected to a capture device.
    E.g. when capturing 3 monochrome cameras in parallel these should be synchronized. Therefore
    some devices can create HD and VD signals that synchronize the connected cameras.

    To create sync. signals this property must be set either to **mvIMPACT::acquire::dsomNonInterlaced**
    or **mvIMPACT::acquire::dsomInterlaced**.

    In interlaced mode only the frequency of the VD signals can be modified, while in non-interlaced
    mode the width (in percent) the signal stays low can be modified as well.

    Now e.g. to sync. two or more CCIR compliant cameras connected to a capture device that can
    create sync. signals, the HD signals must be generated with a CCIR compliant frequency.
    The function **mvIMPACT::acquire::IOSubSystemFrameGrabber::HDOutput** can be used to access the
    desired output pin. Then its property **mvIMPACT::acquire::SyncOutput::frequency_Hz** is
    set to 15625 Hz (CCIR standard). The remaining values can be left untouched. The capture device
    will no generate HD signals with the desired frequency and VD outputs with the frequency
    stored by the property **mvIMPACT::acquire::SyncOutput::frequency_Hz** belonging to the
    pointer to the object returned by a call to **mvIMPACT::acquire::IOSubSystemFrameGrabber::VDOutput**.
    """)

    r""" \brief An integer property \b (read-only) which holds the number of available HD output pins for the mvIMPACT.acquire.Device associated with this object. See mvIMPACT.acquire.IOSubSystemFrameGrabber.getHDOutputCount() """
    hDOutputCount = property (getHDOutputCount, None, None, None)
    r""" \brief An integer property \b (read-only) which holds the number of available VD output pins for the mvIMPACT.acquire.Device associated with this object. See mvIMPACT.acquire.IOSubSystemFrameGrabber.getVDOutputCount() """
    vDOutputCount = property (getVDOutputCount, None, None, None)

    __swig_destroy__ = lib_mvIMPACT_acquire.delete_IOSubSystemFrameGrabber

# Register IOSubSystemFrameGrabber in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.IOSubSystemFrameGrabber_swigregister(IOSubSystemFrameGrabber)

class OutputSignalGeneratorFrameGrabber(object):
    r"""
     A class to create complex digital output signals(**Device** specific interface layout only).
     Instances of this class can be used to create more complex digital output
     related signals like a single pulse or sequence of pulses on a certain pin
     as a reaction on a signal on one of the digital inputs of a device.

     The availability of the features provided by this class heavily depends on the
     used capture device. Therefore it's crucial to check if a desired feature is available
     at all. This class either provides the functions needed for these checks or its
     functions will return appropriate error codes.

     Notes: 
     If the property **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::controlMode**
     is not available **NO** feature of this class can be used.


     If the translation dictionary of **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::controlMode**
     does not contain **mvIMPACT::acquire::docmRTC** the function
     **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::defineLineScanPulse** will **NOT**
     be available.


     Calling unsupported functions or accessing unsupported features will raise an exception.

     Pointers to **mvIMPACT::acquire::DigitalOutput** objects **MUST** be obtained
     by an instance to a **mvIMPACT::acquire::IOSubSystemFrameGrabber** object of the
     same device.

    If: DOXYGEN_CPP_DOCUMENTATION {

    .. code-block:: c++

         #include mvIMPACT_CPP/mvIMPACT_acquire.h
         #include iostream
         #include vector

         using namespace std;
         using namespace mvIMPACT::acquire;

         //-----------------------------------------------------------------------------
         int main( int argc, char* argv[] )
         //-----------------------------------------------------------------------------
         {
           DeviceManager devMgr;
           Device* pDev = getValidDevicePointerFromSomewhere( devMgr );
           // The next line will raise an exception if the device is not operated
           // in interface layout 'dilDeviceSpecific' or is not a frame grabber! This
           // should therefore be wrapped in an exception handler if in doubt!
           IOSubSystemFrameGrabber io( pDev );
           unsigned int iCnt = io.getInputCount();
           cout < "available digital inputs: " < iCnt < endl;
           for( unsigned int d=0; diCnt; d++ )
           {
             cout < io.input( d )-getDescription() < endl;
           }
           unsigned int oCnt = io.getOutputCount();
           cout < "available digital outputs: " < oCnt < endl;
           // set all available digital outputs to high
           for( unsigned int e=0; eoCnt; e++ )
           {
             DigitalOutput* pOutput = io.output( e );
             cout < "setting " < pOutput-getDescription() < " to high" < endl;
             pOutput-set();
           }

           // check there is at least one digital output
           if( oCnt  0 )
           {
             OutputSignalGeneratorFrameGrabber osg( pDev );
             // check if this device supports enhanced signal creation at all
             if( osg.controlMode.isValid() )
             {
               // define a simple pulse on the first digital output detected.
               // this pulse will be low after 100 us for
               // 200us and then switches back to high.
               osg.definePulse( io.output( 0 ), 0, 100, 200 );

               // define a more complex pulse
               vectorint v;
               v.push_back( 100 );
               v.push_back( 299 );
               v.push_back( 666 );
               osg.definePulseSequence( io.output( 0 ), 0, v );
               osg.controlMode.write( docmSoftware );
               osg.imageTrigger.write( ditAfterDigOutSignals );

               // check if line scan pulse creation is supported by this device
               vectorpair<string, TDigitalOutputControlMode  dict;
               osg.controlMode.getTranslationDict( dict );
               unsigned int dictSize = osg.controlMode.dictSize();
               for( unsigned int i=0; idictSize; i++ )
               {
                 if( dict[i].second == docmRTC )
                 {
                   // supported - define some signal
                   cout < "checkGrabberInterface: This device supports RTC control signal creation." < endl;
                   osg.controlMode.write( docmRTC );
                   osg.defineLineScanPulse( io.output( 0 ), dsosePeriodically, 100, 100, 1, 1 );
                 }
               }
             }
           }
           return 0;
         }
    }Else if: DOXYGEN_JAVA_DOCUMENTATION {

    .. code-block:: c++

         import mvIMPACT.acquire.*;

         //-----------------------------------------------------------------------------
         public class OutputSignalGeneratorExample
         //-----------------------------------------------------------------------------
         {
           //=============================================================================
           //=== Static member functions =================================================
           //=============================================================================
           static
           {
             try
             {
               System.loadLibrary( "mvIMPACT_Acquire.java" );
             }
             catch( UnsatisfiedLinkError e )
             {
               System.err.println( "Native code library failed to load. Make sure the 'mvIMPACT_Acquire.java' library can be found in the systems search path.\n" + e );
               System.exit( 1 );
             }
           }

           //-----------------------------------------------------------------------------
           public static void main( String[] args )
           //-----------------------------------------------------------------------------
           {
             DeviceManager devMgr = new DeviceManager();
             Device pDev = mvIMPACT.acquire.examples.helper.DeviceAccess.getDeviceFromUserInput( devMgr );
             if( pDev == null )
             {
               System.out.print( "Unable to continue!" );
               mvIMPACT.acquire.examples.helper.DeviceAccess.waitForENTER();
               System.exit( 1 );
             }

             System.out.println( "Initialising the device. This might take some time..." );
             try
             {
               pDev.open();
             }
             catch( ImpactAcquireException e )
             {
               // this e.g. might happen if the same device is already opened in another process...
               System.out.println( "An error occurred while opening device " + pDev.getSerial().read() +
                                   "(error code: " + e.getMessage() + ")." );
               mvIMPACT.acquire.examples.helper.DeviceAccess.waitForENTER();
               System.exit( 1 );
             }

             try
             {
               IOSubSystemFrameGrabber io = new IOSubSystemFrameGrabber( pDev );
               final long iCnt = io.getInputCount();
               System.out.println( String.format( "Available digital inputs: %d", iCnt ) );
               for( long d=0; diCnt; d++ )
               {
                 System.out.println( io.input( d ).getDescription() );
               }
               final long oCnt = io.getOutputCount();
               System.out.println( String.format( "Available digital outputs: %d", oCnt ) );
               // set all available digital outputs to high
               for( long e=0; eoCnt; e++ )
               {
                 DigitalOutput pOutput = io.output( e );
                 System.out.println( "setting " + pOutput.getDescription() + " to high" );
                 pOutput.set();
               }

               // check there is at least one digital output
               if( oCnt  0 )
               {
                 OutputSignalGeneratorFrameGrabber osg = new OutputSignalGeneratorFrameGrabber( pDev );
                 // check if this device supports enhanced signal creation at all
                 if( osg.getControlMode().isValid() )
                 {
                   // define a simple pulse on the first digital output detected.
                   // this pulse will be low after 100 us for
                   // 200us and then switches back to high.
                   osg.definePulse( io.output( 0 ), 0, 100, 200 );

                   // define a more complex pulse
                   IntVector v = new IntVector();
                   v.add( 100 );
                   v.add( 299 );
                   v.add( 666 );
                   osg.definePulseSequence( io.output( 0 ), 0, v );
                   osg.getControlMode().write( TDigitalOutputControlMode.docmSoftware );
                   osg.getImageTrigger().write( TDeviceImageTrigger.ditAfterDigOutSignals );

                   // check if line scan pulse creation is supported by this device
                   StringIntVector dict = new StringIntVector();
                   osg.getControlMode().getTranslationDict( dict );
                   final long dictSize = osg.getControlMode().dictSize();
                   for( long i=0; idictSize; i++ )
                   {
                     if( dict.get( ( int )i ).getSecond() == TDigitalOutputControlMode.docmRTC )
                     {
                       // supported - define some signal
                       System.out.println( "checkGrabberInterface: This device supports RTC control signal creation." );
                       osg.getControlMode().write( TDigitalOutputControlMode.docmRTC );
                       osg.defineLineScanPulse( io.output( 0 ), TDeviceSignalOutputStartEvent.dsosePeriodically, 100, 100, 1, 1 );
                     }
                   }
                 }
               }
             }
             catch( ImpactAcquireException e )
             {
               System.out.println( "An error occurred: " + e.getMessage() + ")." );
               mvIMPACT.acquire.examples.helper.DeviceAccess.waitForENTER();
               System.exit( 1 );
             }
           }
         }
    }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

    .. code-block:: c++

         def setUpIOs(pDev):
            # The next line will raise an exception if the device is not operated
            # in interface layout 'dilDeviceSpecific' or is not a frame grabber! This
            # should therefore be wrapped in an exception handler if in doubt!
            io = acquire.IOSubSystemFrameGrabber(pDev)
            iCnt = io.getInputCount()
            print("available digital inputs: " + str(iCnt))
            for x in range(iCnt):
              print(io.getInput(d).getDescription())

            oCnt = io.getOutputCount()
            print("available digital outputs: " + str(oCnt))
            # set all available digital outputs to high
            for e in range(oCnt):
              pOutput = io.getOutput(e)
              print("setting " + pOutput.getDescription() + " to high")
              pOutput.state = True

            # check there is at least one digital output
            if oCnt  0:
              osg = acquire.OutputSignalGeneratorFrameGrabber(pDev)
              # check if this device supports enhanced signal creation at all
              if osg.controlMode.isValid:
                # define a simple pulse on the first digital output detected.
                # this pulse will be low after 100 us for
                # 200us and then switches back to high.
                osg.definePulse(io.getOutput(0), 0, 100, 200)

                # define a more complex pulse
                v = []
                v[0] = 100
                v[1] = 299
                v[1] = 666
                osg.definePulseSequence(io.getOutput(0), 0, v)
                osg.controlMode.write(acquire.docmSoftware)
                osg.imageTrigger.write(acquire.ditAfterDigOutSignals)

                # check if line scan pulse creation is supported by this device
                dict = {None:None}
                osg.controlMode.getTranslationDict(dict)
                dictSize = osg.controlMode.dictSize
                for i in range(dictSize):
                    if dict[i].second == acquire.docmRTC:
                    # supported - define some signal
                        print("checkGrabberInterface: This device supports RTC control signal creation.")
                        osg.controlMode.write(acquire.docmRTC)
                        osg.defineLineScanPulse(io.getOutput(0), acquire.dsosePeriodically, 100, 100, 1, 1)
    }

     Whenever a signal has been defined for a a certain digital output
     pin, this pin can no longer controlled using the corresponding functions
     in the class **mvIMPACT::acquire::DigitalOutput**. In order to do that
     the pin in question must be released using the function
     **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::undefineSignal**.

     This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
     **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

    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"""
        *Overload 1:*
         Constructs a new **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber** object.
        :type pDev: :py:class:`Device`
        :param pDev: A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber** from an existing one.
        :type src: :py:class:`OutputSignalGeneratorFrameGrabber`
        :param src: [in] A constant reference to the **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.OutputSignalGeneratorFrameGrabber_swiginit(self, lib_mvIMPACT_acquire.new_OutputSignalGeneratorFrameGrabber(*args))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_OutputSignalGeneratorFrameGrabber

    def definePulse(self, pOutput, polarity, delay, width, pPulseStartConfiguration=None):
        r"""
         Assigns a single pulse to a digital output.
         Whenever a single pulse of a certain duration and polarity shall be generated
         on a digital output as a reaction on a trigger signal that was either generated by one of
         digital inputs of the device or software this is the right function to use.

         When the signal is generated can be defined by the properties
         **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::pulseStartEvent** and
         **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::imageTrigger**.

         See also: 
         **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::undefineSignal**
         :rtype: int
         :return: 
             - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
             - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.

        :type pOutput: :py:class:`DigitalOutput`
        :param pOutput: [in] A pointer to a **mvIMPACT::acquire::DigitalOutput** object obtained from an instance of the class **mvIMPACT::acquire::IOSubSystemFrameGrabber** for this device.
        :type polarity: int
        :param polarity: [in] The polarity of the pulse to generate. - 0: The pulse will be low for *width_pclk* and high otherwise - 1: The pulse will be high for *width_pclk* and high otherwise
        :type delay: int
        :param delay: [in] The delay after the trigger event before a signal generation starts
        :type width: int
        :param width: [in] The width of the pulse to generate
        :type pPulseStartConfiguration: :py:class:`PulseStartConfiguration`
        :param pPulseStartConfiguration: [in] The pulse start configuration to be used for this pulse sequence. Not every device will support the use of pulse start configurations. Valid objects that can be passed to this function can be obtained from a call to **mvIMPACT::acquire::IOSubSystem::getPulseStartConfiguration**, and **mvIMPACT::acquire::IOSubSystem::getPulseStartConfigurationCount**. If objects of these type are not supported, pass 0 or ignore this parameter. In that case the property **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::imageTrigger** will define the start condition for the signal output.
        """
        return lib_mvIMPACT_acquire.OutputSignalGeneratorFrameGrabber_definePulse(self, pOutput, polarity, delay, width, pPulseStartConfiguration)

    def definePulseSequence(self, pOutput, startLevel, sequence, pPulseStartConfiguration=None):
        r"""
         Assigns a complex signal to a digital output.
         This function can be used when a complex signal shall be generated
         on a digital output as a reaction on a trigger signal that was either generated by one of
         digital inputs of the device or software.

         When the signal is generated can be defined by the properties
         **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::pulseStartEvent** and
         **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::imageTrigger**.

         See also: 
         **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::undefineSignal**
         :rtype: int
         :return: 
             - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
             - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.

        :type pOutput: :py:class:`DigitalOutput`
        :param pOutput: [in] A pointer to a **mvIMPACT::acquire::DigitalOutput** object obtained from an instance of the class **mvIMPACT::acquire::IOSubSystemFrameGrabber** for this device.
        :type startLevel: int
        :param startLevel: [in] The start level of the generated signal. - 0: The signal will start with 'low' - 1: The signal will start with 'high'
        :type sequence: std::vector< int,std::allocator< int > >
        :param sequence: [in] An array of integer values. Each values defines a switch in polarity of the signal after 'x' us. An array containing '1000', '2000' therefore will describe a signal starting with *startLevel*, switches polarity after 1000 us and then again switches polarity after 2000 us.
        :type pPulseStartConfiguration: :py:class:`PulseStartConfiguration`
        :param pPulseStartConfiguration: [in] The pulse start configuration to be used for this pulse sequence. Not every device will support the use of pulse start configurations. Valid objects that can be passed to this function can be obtained from a call to **mvIMPACT::acquire::IOSubSystem::getPulseStartConfiguration**, and **mvIMPACT::acquire::IOSubSystem::getPulseStartConfigurationCount**. If objects of these type are not supported, pass 0 or ignore this parameter. In that case the property **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::imageTrigger** will define the start condition for the signal output.
        """
        return lib_mvIMPACT_acquire.OutputSignalGeneratorFrameGrabber_definePulseSequence(self, pOutput, startLevel, sequence, pPulseStartConfiguration)

    def getValidSignalsForPassThroughModes(self, pOutput, sequence):
        r"""
         Receives a list of valid signals that can be passed directly to a certain digital output pin.
         Whenever it is necessary to output a certain signal (e.g. a digital input signal connected to the device or
         an internal digital signal like e.g. a frame valid signal) to a digital output of the device this can be done
         by a call to the function **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::definePassThroughSignal**

         As the type of signals that a device can send to a digital output depends heavily on the device and even on the
         digital output as well, this function will return a list of strings and a numerical representation for each signal
         that can be sent to this digital output.

         Notes: 
         This function is much more efficient than calling
         **OutputSignalGeneratorFrameGrabber::getValidPassThroughSignalValue** and
         **OutputSignalGeneratorFrameGrabber::getValidPassThroughSignalString** and
         therefore this function should be called whenever all entries are required.

         :rtype: int
         :return: 
             - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
             - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.

        :type pOutput: :py:class:`DigitalOutput`
        :param pOutput: [in] A pointer to a **mvIMPACT::acquire::DigitalOutput** object obtained from an instance of the class **mvIMPACT::acquire::IOSubSystemFrameGrabber** for this device.
        :type sequence: mvIMPACT::acquire::TDigitalSignalTranslationDict
        :param sequence: [out] A reference to a vector that will receive the list of allowed digital signals for this particular digital output pin.
        """
        return lib_mvIMPACT_acquire.OutputSignalGeneratorFrameGrabber_getValidSignalsForPassThroughModes(self, pOutput, sequence)

    def getValidPassThroughSignalCount(self, pOutput):
        r"""
         Returns the number of signals that can be used for pass through signal definitions for a certain digital output pin of this device.
        :type pOutput: :py:class:`DigitalOutput`
        :param pOutput: [in] A pointer to a **mvIMPACT::acquire::DigitalOutput** object obtained from an instance of the class **mvIMPACT::acquire::IOSubSystemFrameGrabber** for this device.
        """
        return lib_mvIMPACT_acquire.OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalCount(self, pOutput)

    def getValidPassThroughSignalValue(self, pOutput, index=0):
        r"""
         Receives a valid signal that can be passed directly to a certain digital output pin.
         Whenever it is necessary to output a certain signal (e.g. a digital input signal connected to the device or
         an internal digital signal like e.g. a frame valid signal) to a digital output of the device this can be done
         by a call to the function **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::definePassThroughSignal**

         As the type of signals that a device can send to a digital output depends heavily on the device and even on the
         digital output as well, this function together with the function **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::getValidPassThroughSignalString**
         can be used to query a list of strings and a numerical representation for each signal
         that can be sent to this digital output.

         If: DOXYGEN_CPP_DOCUMENTATION {
         C++ offers the more efficient function **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::getValidSignalsForPassThroughModes**
         to obtain this information.
         }

        :type pOutput: :py:class:`DigitalOutput`
        :param pOutput: [in] A pointer to a **mvIMPACT::acquire::DigitalOutput** object obtained from an instance of the class **mvIMPACT::acquire::IOSubSystemFrameGrabber** for this device.
        :type index: int
        :param index: [in] The index of the entry to read from the property. The find out the last valid value for this parameter call **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::getValidPassThroughSignalCount**
        """
        return lib_mvIMPACT_acquire.OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalValue(self, pOutput, index)

    def getValidPassThroughSignalString(self, pOutput, index=0):
        r"""
         Receives a valid string representation of a signal that can be passed directly to a certain digital output pin.
         Whenever it is necessary to output a certain signal (e.g. a digital input signal connected to the device or
         an internal digital signal like e.g. a frame valid signal) to a digital output of the device this can be done
         by a call to the function **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::definePassThroughSignal**

         As the type of signals that a device can send to a digital output depends heavily on the device and even on the
         digital output as well, this function together with the function **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::getValidPassThroughSignalString**
         can be used to query a list of strings and a numerical representation for each signal
         that can be sent to this digital output.

         If: DOXYGEN_CPP_DOCUMENTATION {
         C++ offers the more efficient function **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::getValidSignalsForPassThroughModes**
         to obtain this information.
         }

        :type pOutput: :py:class:`DigitalOutput`
        :param pOutput: [in] A pointer to a **mvIMPACT::acquire::DigitalOutput** object obtained from an instance of the class **mvIMPACT::acquire::IOSubSystemFrameGrabber** for this device.
        :type index: int
        :param index: [in] The index of the entry to read from the property. The find out the last valid value for this parameter call **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::getValidPassThroughSignalCount**
        """
        return lib_mvIMPACT_acquire.OutputSignalGeneratorFrameGrabber_getValidPassThroughSignalString(self, pOutput, index)

    def definePassThroughSignal(self, *args):
        r"""
        *Overload 1:*
         Assigns a certain signal to a digital output.
         Some digital input signals or even some internal signals can be passed directly to one or more
         digital outputs.

         :rtype: int
         :return: 
             - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
             - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.

        :type pOutput: :py:class:`DigitalOutput`
        :param pOutput: [in] A pointer to a **mvIMPACT::acquire::DigitalOutput** object obtained from an instance of the class **mvIMPACT::acquire::IOSubSystemFrameGrabber** for this device.
        :type digitalSignal: int
        :param digitalSignal: [in] The digital signal that shall be passed to the digital output. Valid values for this parameter will be obtained by a call to the function **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::getValidSignalsForPassThroughModes**
        :type boInverted: boolean
        :param boInverted: [in] If set to *true*, the signal will be inverted internally before being passed to the output.

        |

        *Overload 2:*
         Assigning a certain signal to a digital output.
         Some digital input signals or even some internal signals can be passed directly to one or more
         digital outputs.

         :rtype: int
         :return: 
             - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
             - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.

        :type pOutput: :py:class:`DigitalOutput`
        :param pOutput: [in] A pointer to a **mvIMPACT::acquire::DigitalOutput** object obtained from an instance of the class **mvIMPACT::acquire::IOSubSystemFrameGrabber** for this device.
        :type digitalSignal: string
        :param digitalSignal: [in] The string representation of the digital output that shall be passed to the digital output. Valid values for this parameter will be obtained by a call to the function **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::getValidSignalsForPassThroughModes**
        :type boInverted: boolean
        :param boInverted: [in] If set to *true*, the signal will be inverted internally before being passed to the output.

        |

        *Overload 3:*
         Assigning a certain signal to a digital output.
         Some digital input signals or even some internal signals can be passed directly to one or more
         digital outputs.

         :rtype: int
         :return: 
             - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
             - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.

        :type pOutput: :py:class:`DigitalOutput`
        :param pOutput: [in] A pointer to a **mvIMPACT::acquire::DigitalOutput** object obtained from an instance of the class **mvIMPACT::acquire::IOSubSystemFrameGrabber** for this device.
        :type digitalSignal: string
        :param digitalSignal: [in] The string representation of the digital output that shall be passed to the digital output. Valid values for this parameter will be obtained by a call to the function **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::getValidSignalsForPassThroughModes**
        :param boInverted: [in] If set to *true*, the signal will be inverted internally before being passed to the output.
        """
        return lib_mvIMPACT_acquire.OutputSignalGeneratorFrameGrabber_definePassThroughSignal(self, *args)

    def undefineSignal(self, pOutput):
        r"""
         Removes the signal definition from the specified output pin.
         Whenever a signal has been defined for a a certain digital output
         pin, this pin can no longer controlled using the corresponding functions
         in the class **mvIMPACT::acquire::DigitalOutput**. This function removes the
         signal definition and hands back manual control of that digital output to the user.
         :rtype: int
         :return: 
             - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
             - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.

        :type pOutput: :py:class:`DigitalOutput`
        :param pOutput: [in] A pointer to a **mvIMPACT::acquire::DigitalOutput** object obtained from an instance of the class **mvIMPACT::acquire::IOSubSystemFrameGrabber** for this device.
        """
        return lib_mvIMPACT_acquire.OutputSignalGeneratorFrameGrabber_undefineSignal(self, pOutput)

    def defineLineScanPulse(self, pOutput, pulseStartEventValue, softwareSignalPeriod_pclk, width_pclk, polarity, divider):
        r"""
         Defines a pulse to trigger line scan cameras.
         Calling this function without setting **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::controlMode**
         to **mvIMPACT::acquire::docmRTC** will have **NO** effect.

         Notes: 
         Not every frame grabber will offer the **mvIMPACT::acquire::docmRTC**
         mode. Check is the mode is available by reading the properties translation dictionary with
         the functions **mvIMPACT::acquire::PropertyIDigitalOutputControlMode::getTranslationDictString** and
         **mvIMPACT::acquire::PropertyIDigitalOutputControlMode::getTranslationDictValue**. The detailed description
         of this class might contain source code examples for the language you are working with.
         If: DOXYGEN_CPP_DOCUMENTATION {
         C++ offers the more efficient function **mvIMPACT::acquire::PropertyIDigitalOutputControlMode::getTranslationDict**
         in addition to the functions mentioned above.
         }

         See also: 
         **mvIMPACT::acquire::OutputSignalGeneratorFrameGrabber::undefineSignal**
         :rtype: int
         :return: 
             - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
             - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.

        :type pOutput: :py:class:`DigitalOutput`
        :param pOutput: [in] A pointer to a **mvIMPACT::acquire::DigitalOutput** object obtained from an instance of the class **mvIMPACT::acquire::IOSubSystemFrameGrabber** for this device.
        :type pulseStartEventValue: int
        :param pulseStartEventValue: [in] Defines the start event for the signal generation. Valid values for this parameter are defined by **mvIMPACT::acquire::TDeviceSignalOutputStartEvent**.
        :type softwareSignalPeriod_pclk: int
        :param softwareSignalPeriod_pclk: [in] Defines the frequency for a continuously generated signal if *pulseStartEventValue* is **mvIMPACT::acquire::dsoseSyncInRisingEdge** or **mvIMPACT::acquire::dsoseSyncInFallingEdge** and is ignored otherwise.
        :type width_pclk: int
        :param width_pclk: [in] The width of the signal to generate if *pulseStartEventValue* is **mvIMPACT::acquire::dsoseSyncInRisingEdge**, **mvIMPACT::acquire::dsosePeriodically** or **mvIMPACT::acquire::dsoseSyncInFallingEdge** and is ignored otherwise.
        :type polarity: int
        :param polarity: [in] The polarity of the signal to generate if *pulseStartEventValue* is **mvIMPACT::acquire::dsoseSyncInRisingEdge**, **mvIMPACT::acquire::dsosePeriodically** or **mvIMPACT::acquire::dsoseSyncInFallingEdge** and is ignored otherwise. - 0: The signal will be low for *width_pclk* and high otherwise - 1: The signal will be high for *width_pclk* and high otherwise
        :type divider: int
        :param divider: [in] Defines the divider value if *pulseStartEventValue* is **mvIMPACT::acquire::dsosePeriodically**
        """
        return lib_mvIMPACT_acquire.OutputSignalGeneratorFrameGrabber_defineLineScanPulse(self, pOutput, pulseStartEventValue, softwareSignalPeriod_pclk, width_pclk, polarity, divider)
    controlMode = property(lib_mvIMPACT_acquire.OutputSignalGeneratorFrameGrabber_controlMode_get, doc=r"""
    An enumerated integer property defining the general method used to create output signals.
    This setting always applies to every signal defined. Modifying this property will also
    change the behaviour of signals already defined.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDigitalOutputControlMode**.

    When switching to **mvIMPACT::acquire::docmRTC** mode
    only one signal can be created currently.

    Notes: 
    Not every frame grabber will offer the **mvIMPACT::acquire::docmRTC**
    mode. Check if the mode is available by reading the properties translation dictionary with
    the functions **mvIMPACT::acquire::PropertyIDigitalOutputControlMode::getTranslationDictString** and
    **mvIMPACT::acquire::PropertyIDigitalOutputControlMode::getTranslationDictValue**.
    If: DOXYGEN_CPP_DOCUMENTATION {
    C++ offers the more efficient function **mvIMPACT::acquire::PropertyIDigitalOutputControlMode::getTranslationDict**
    in addition to the functions mentioned above.
    }

    Some devices will offer a more flexible way to define this behaviour. In this case, this property won't be available (a call to the function
    **mvIMPACT::acquire::Component::isValid** will return false). However then calls to **mvIMPACT::acquire::IOSubSystem::getPulseStartConfigurationCount**
    and **mvIMPACT::acquire::IOSubSystem::getPulseStartConfiguration** will succeed and the objects returned by
    **mvIMPACT::acquire::IOSubSystem::getPulseStartConfiguration** (**mvIMPACT::acquire::PulseStartConfiguration)** will
    provide a more sophisticated way to define the signal output behaviour of a device.
    """)
    pulseStartEvent = property(lib_mvIMPACT_acquire.OutputSignalGeneratorFrameGrabber_pulseStartEvent_get, doc=r"""
    An enumerated integer property defining the general behaviour of created output signals.
    This setting always applies to every signal defined. Modifying this property will also
    change the behaviour of signals already defined.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDeviceSignalOutputStartEvent**.
    """)
    imageTrigger = property(lib_mvIMPACT_acquire.OutputSignalGeneratorFrameGrabber_imageTrigger_get, doc=r"""
    An enumerated integer property defining the general behaviour of created output signals.
    This setting always applies to every signal defined. Modifying this property will also
    change the behaviour of signals already defined.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDeviceImageTrigger**.
    """)

# Register OutputSignalGeneratorFrameGrabber in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.OutputSignalGeneratorFrameGrabber_swigregister(OutputSignalGeneratorFrameGrabber)

class Connector(ComponentCollection):
    r"""
    A class describing how a video signal source(e.g. a camera or image sensor) is connected to a video signal sink(e.g. a frame grabber)(**Device** specific interface layout only).
    With an instance of this class the user can define on which input channels the
    video signal source used for this setting is connected to the video signal sink and how(in which format) the
    video signal source transmits its data.

    Video signal source and video signal sink can both belong to the same physical piece
    of hardware. This e.g. might apply to a digital camera that doesn't need a
    frame grabber (e.g. a GigE Vision TM, USB3 Vision TM or USB camera). In such a scenario
    certain properties belonging to this class might be read-only or may only allow
    a single enumeration value.

    Notes: This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
    **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::Connector** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.Connector_swiginit(self, lib_mvIMPACT_acquire.new_Connector(*args))
    cameraOutputUsed = property(lib_mvIMPACT_acquire.Connector_cameraOutputUsed_get, doc=r"""
    An enumerated integer property defining the video signal output of the video signal source used for the connection to the video signal sink.
    Notes: 
    Not every video signal sink will support every possible value defined for this property.
    For example a CameraLink(R) frame grabber will not offer to use an SVideo connector.
    Therefore the translation dictionary of this property should be used to find out, which connector types are available.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraOutput**.


    This property might not be supported by every device. Therefore always call the function
    **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.
    """)
    videoChannel = property(lib_mvIMPACT_acquire.Connector_videoChannel_get, doc=r"""
    An integer property containing the video channel the camera belonging to the current setting is connected to.
    The maximum possible video channel might change when the property
    **mvIMPACT::acquire::Connector::cameraOutputUsed** is modified as the different
    ways to transmit a video signal require more or less video input channels. While e.g. a composite
    video signal can be transmitted via a single wire, an RGB signal requires either 3 or 4 wires
    (depending on whether the sync. signal is transmitted on a separate wire or not).

    The first channel will always have the number 0. The limits (max/min values) can be queried
    by calling the function **mvIMPACT::acquire::PropertyI::getMinValue** or
    **mvIMPACT::acquire::PropertyI::getMaxValue**.

    Notes: 
    This property might not be supported by every device. Therefore always call the function
    **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.
    """)
    pinDescription = property(lib_mvIMPACT_acquire.Connector_pinDescription_get, doc=r"""
    A string property **(read-only)** containing a description for the video channel currently selected by the property **mvIMPACT::acquire::Connector::videoChannel**.
    The description string contains information about the connector pins belonging to this video
    input of the video signal sink as well as the corresponding name of this video input.

    Notes: 
    This property might not be supported by every device. Therefore always call the function
    **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_Connector

# Register Connector in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.Connector_swigregister(Connector)

class BasicDeviceSettingsWithAOI(BasicDeviceSettings):
    r"""
     A base class for camera related settings(**Device** specific interface layout only).
    This class acts as a base class for camera related settings. It only contains
    settings that are available for every device!

    Notes: This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
    **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::BasicDeviceSettingsWithAOI** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.BasicDeviceSettingsWithAOI_swiginit(self, lib_mvIMPACT_acquire.new_BasicDeviceSettingsWithAOI(*args))
    aoiHeight = property(lib_mvIMPACT_acquire.BasicDeviceSettingsWithAOI_aoiHeight_get, doc=r""" An integer property defining the number of lines to capture.""")
    aoiStartX = property(lib_mvIMPACT_acquire.BasicDeviceSettingsWithAOI_aoiStartX_get, doc=r"""
    An integer property defining the X-offset for each capture line.
    Example: When setting this property to 5 the first pixel in each line of
    the resulting image will be pixel number 5 of each line transmitted by
    the camera.
    """)
    aoiStartY = property(lib_mvIMPACT_acquire.BasicDeviceSettingsWithAOI_aoiStartY_get, doc=r"""
    An integer property defining the Y-offset.
    Example: When setting this property to 5 the first line of
    the resulting image will be line number 5 of the image transmitted by
    the camera.
    """)
    aoiWidth = property(lib_mvIMPACT_acquire.BasicDeviceSettingsWithAOI_aoiWidth_get, doc=r""" An integer property defining the number of pixels to capture per line.""")
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_BasicDeviceSettingsWithAOI

# Register BasicDeviceSettingsWithAOI in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.BasicDeviceSettingsWithAOI_swigregister(BasicDeviceSettingsWithAOI)

class CameraSettingsBase(BasicDeviceSettingsWithAOI):
    r"""
     A base class for camera related settings(**Device** specific interface layout only).
    This class acts as a base class for camera related settings. It only contains
    settings that are available for almost every device!

    Notes: This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
    **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::CameraSettingsBase** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.CameraSettingsBase_swiginit(self, lib_mvIMPACT_acquire.new_CameraSettingsBase(*args))
    pixelFormat = property(lib_mvIMPACT_acquire.CameraSettingsBase_pixelFormat_get, doc=r"""
    An enumerated integer property defining the pixel format used to transfer the image data into the target systems host memory.
    Support for this property has been added in version 1.11.0 of mvIMPACT Acquire thus old driver versions will
    raise an exception if an application accesses the property without checking if the property is present.

    By default this property will be set to **mvIMPACT::acquire::ibpfAuto**. This will result in the previous driver
    behaviour where depending on the various post processing steps that are enabled or disabled the driver will decide
    which transfer format will be used. However sometimes this could result in a transfer format, which is not ideal
    for the application (e.g. when a post processing step of the application needs RGBx888Packed but the systems bandwidth
    is limited the application might want to transfer the data in YUV422 packed and then use the fast format conversion
    algorithm in the driver). This can be achieved by explicitly setting **mvIMPACT::acquire::CameraSettingsBase::pixelFormat** to
    **mvIMPACT::acquire::ibpfYUV422Packed** and **mvIMPACT::acquire::ImageDestination::pixelFormat** to
    **mvIMPACT::acquire::ibpfRGBx888Packed**.

    Notes: 
    Selecting a defined transfer format can in some cases result in certain filters (e.g. dark current, ...) to be switched
    of as then the filters themselves can no longer influence the transfer format, which is sometimes necessary as not every
    filter does support every input format. Also this property will contain only pixel formats, which are actually supported
    by the capture device, thus in most of the cases this will be a subset of the pixel formats defined by the enumeration defining this property.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TImageBufferPixelFormat**.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_CameraSettingsBase

# Register CameraSettingsBase in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.CameraSettingsBase_swigregister(CameraSettingsBase)

class CameraSettingsVirtualDevice(CameraSettingsBase):
    r"""
    **mvVirtualDevice** related camera settings(**Device** specific interface layout only).
    Notes: 
    As this is a device driver meant for testing the interface an allowing to
    start the integration of mvIMPACT Acquire into an application, this class
    might change at ANY time! Changes in the virtual device driver might not
    be backward compatible!

    This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
    **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::CameraSettingsVirtualDevice** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.CameraSettingsVirtualDevice_swiginit(self, lib_mvIMPACT_acquire.new_CameraSettingsVirtualDevice(*args))
    bufferPartCount = property(lib_mvIMPACT_acquire.CameraSettingsVirtualDevice_bufferPartCount_get, doc=r"""
    An integer property defining the number of buffer part to transmit in each request.
    This property is meant to test the multi-part buffer feature of mvIMPACT Acquire mainly. When
    set to 0 multi-part buffer handling is switched off. When set to a value greater than 0 the
    virtual device will transmit data in multi-part mode, meaning that **mvIMPACT::acquire::Request::getBufferPartCount()**
    will return a value larger than zero. Only when this is the case the properties belonging to the
    individual buffer parts are guaranteed to contain up to date data while then all properties whose name
    starts with ``image`` within that request might not.

    Since: 2.20.0
    """)
    aoiMode = property(lib_mvIMPACT_acquire.CameraSettingsVirtualDevice_aoiMode_get, doc=r"""
    An enumerated integer property defining the used AOI mode for the image capture.
    This feature will only be visible, when the property **mvIMPACT::acquire::CameraSettingsVirtualDevice::testMode**
    is set to **mvIMPACT::acquire::vdtmImageDirectory**. Then this property will allow to enforce a certain image dimension
    ( **mvIMPACT::acquire::camUser** ) or to capture every image file in its original dimensions ( **mvIMPACT::acquire::camFull** ).
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraAoiMode**.

    Since: 2.11.9
    """)
    gain_dB = property(lib_mvIMPACT_acquire.CameraSettingsVirtualDevice_gain_dB_get, doc=r"""
     A float property defining the gain in dB to be applied to the test image.
    The formula for given ``gain_dB`` is

    .. code-block:: c++

        gain_x= 10 ^ (gain_dB/20)

    **Example**:

    .. code-block:: c++

        gain_x = 10 ^ (6/20) = 1.995

    I.e. increasing the gain setting by 6dB corresponds to factor of 2.

    The formula for given gain_x is

    .. code-block:: c++

        gain_dB = 20*log(gain_x) dB

    Where:

    ``gain_dB``: MATRIX VISION gain value (logarithmic)

    ``gain_x``: multiplicative gain

    ``^``: power function
    """)
    testMode = property(lib_mvIMPACT_acquire.CameraSettingsVirtualDevice_testMode_get, doc=r"""
    An enumerated integer property defining the test mode use to generate the dummy images.
    When **mvIMPACT::acquire::CameraSettingsBase::pixelFormat** is **NOT** set to **mvIMPACT::acquire::ibpfAuto**, this
    this property will become invisible.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TVirtualDeviceTestMode**.
    """)
    channelBitDepth = property(lib_mvIMPACT_acquire.CameraSettingsVirtualDevice_channelBitDepth_get, doc=r"""
    An integer property defining the channel bit depth for certain test image generation modes.
    When **mvIMPACT::acquire::CameraSettingsBase::pixelFormat** is **NOT** set to **mvIMPACT::acquire::ibpfAuto**, this
    this property will become invisible.

    When **mvIMPACT::acquire::CameraSettingsVirtualDevice::testMode** is set to **mvIMPACT::acquire::vdtmMovingMonoRamp**,
    **mvIMPACT::acquire::vdtmMovingBayerDataRamp** or **mvIMPACT::acquire::vdtmBayerWhiteBalanceTestImage** this property
    will allow to define the pixel format for the test image.
    """)
    paddingX = property(lib_mvIMPACT_acquire.CameraSettingsVirtualDevice_paddingX_get, doc=r"""
    An integer property defining the padding(in bytes) in X-direction for certain test image generation modes.
    When **mvIMPACT::acquire::CameraSettingsVirtualDevice::testMode** is set to a mono format(not the weird packed ones!),
    **mvIMPACT::acquire::vdtmMovingBayerDataRamp** or **mvIMPACT::acquire::vdtmBayerWhiteBalanceTestImage** this property
    will allow to define the padding in bytes for each line. This will result in images where the line pitch differs from
    the width multiplied by the bytes per pixel value. E.g. a padding of 1 in X-direction and a width of 5 for a 16 bit mono
    format will result in a line pitch of 11 bytes(5*2 + 1).
    """)
    tapsXGeometry = property(lib_mvIMPACT_acquire.CameraSettingsVirtualDevice_tapsXGeometry_get, doc=r"""
     An enumerated integer property defining the way this camera transmits the pixel data in X direction.
     Within the virtual device driver, modifying this property internally will only attach the corresponding
     attribute to the request buffer, thus might result in the tap sort filter to process the data. This is mainly
     meant for testing purposes.

     Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraTapsXGeometry**.
    Since: 2.5.2
    """)
    tapsYGeometry = property(lib_mvIMPACT_acquire.CameraSettingsVirtualDevice_tapsYGeometry_get, doc=r"""
     An enumerated integer property defining the way this camera transmits the pixel data in Y direction.
     Within the virtual device driver, modifying this property internally will only attach the corresponding
     attribute to the request buffer, thus might result in the tap sort filter to process the data. This is mainly
     meant for testing purposes.

     Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraTapsYGeometry**.
    Since: 2.5.2
    """)
    frameDelay_us = property(lib_mvIMPACT_acquire.CameraSettingsVirtualDevice_frameDelay_us_get, doc=r""" An integer property defining a delay in us before the 'captured' image is returned to the user.""")
    imageDirectory = property(lib_mvIMPACT_acquire.CameraSettingsVirtualDevice_imageDirectory_get, doc=r"""
    A string property defining the directory to capture images from.
    This feature will only be visible, when the property **mvIMPACT::acquire::CameraSettingsVirtualDevice::testMode**
    is set to **mvIMPACT::acquire::vdtmImageDirectory**.

    See **mvIMPACT::acquire::CameraSettingsVirtualDevice::imageType** to find out how to configure what kind of images shall be captured from disc.
    """)
    imageType = property(lib_mvIMPACT_acquire.CameraSettingsVirtualDevice_imageType_get, doc=r"""
    An enumerated integer property defining what images shall be captured from hard disk.
    This feature will only be visible, when the property **mvIMPACT::acquire::CameraSettingsVirtualDevice::testMode**
    is set to **mvIMPACT::acquire::vdtmImageDirectory**.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TVirtualDeviceImageType**.
    """)
    bayerMosaicParity = property(lib_mvIMPACT_acquire.CameraSettingsVirtualDevice_bayerMosaicParity_get, doc=r"""
    An enumerated integer property defining the Bayer attribute assigned to the generated test image.
    When images are acquired via a directory, or a Bayer test pattern is generated this can be used to specify the Bayer parity.
    **mvIMPACT::acquire::bmpUndefined** will set the buffers Bayer attribute thus will result in a grey(mono) buffer being returned.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBayerMosaicParity**.
    """)
    testImageBarWidth = property(lib_mvIMPACT_acquire.CameraSettingsVirtualDevice_testImageBarWidth_get, doc=r""" An integer property defining the width (in pixels) of the different bars in certain test modes.""")
    userData = property(lib_mvIMPACT_acquire.CameraSettingsVirtualDevice_userData_get, doc=r"""
    A string property that will be copied into the user data property of each request.
    This e.g. can be used to assign a certain identifier to each image request.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_CameraSettingsVirtualDevice

# Register CameraSettingsVirtualDevice in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.CameraSettingsVirtualDevice_swigregister(CameraSettingsVirtualDevice)

class CameraSettingsV4L2Device(BasicDeviceSettingsWithAOI):
    r"""
    **mvV4L2** related camera settings(**Device** specific interface layout only).
    Notes: UNDER CONSTRUCTION! Subject to change.

    This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
    **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::CameraSettingsV4L2Device** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.CameraSettingsV4L2Device_swiginit(self, lib_mvIMPACT_acquire.new_CameraSettingsV4L2Device(*args))

    def getCustomFeatureIterator(self):
        r"""
         Returns an iterator to for iterating inside a device specific feature list.
         This can be useful a device offers custom features that are not defined in the V4L2 standard and thus
         can't be known at compile time.

         It allows to write code like this:

        If: DOXYGEN_CPP_DOCUMENTATION {

        .. code-block:: c++

             CameraSettingsV4L2Device cs( getDevicePointerFromSomewhere() );
             Component it( cs.getCustomFeatureIterator() );
             std::mapstd::string, std::string m;
             while( it.isValid() )
             {
               // collect all entries that are properties and store their current name and value in a map
               if( it.isProp()  it.isVisible() )
               {
                 Property prop( it );
                 m.insert( std::make_pair( prop.name(), prop.readS() );
               }
               ++it;
             }
        }Else if: DOXYGEN_JAVA_DOCUMENTATION {

        .. code-block:: c++

             import java.util.Hashtable;

             // ...

             CameraSettingsV4L2Device cs = new CameraSettingsV4L2Device( getDevicePointerFromSomewhere() );
             Component it = cs.getCustomFeatureIterator();
             HashtableString, String m = new HashtableString, String();
             while( it.isValid() )
             {
               // collect all entries that are properties and store their current name and value in a hash table
               if( it.isProp()  it.isVisible() )
               {
                  Property prop = new Property( it.hObj() );
                  m.put( prop.name(), prop.readS() );
               }
               it = it.nextSibling();
             }
        }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

        .. code-block:: c++

              cs = acquire.CameraSettingsV4L2Device(pDev)
              it = acquire.Component(cs.getCustomFeatureIterator())
              m = {}
              while it.isValid:
                # collect all entries that are properties and store their current name and value in a map
                if it.isProp and it.isVisible:
                  prop = acquire.Property(it);
                  m[prop.name()] = prop.readS()
                it = it.nextSibling()
        }
        """
        return lib_mvIMPACT_acquire.CameraSettingsV4L2Device_getCustomFeatureIterator(self)
    imageWidth = property(lib_mvIMPACT_acquire.CameraSettingsV4L2Device_imageWidth_get, doc=r"""
    An integer property defining the width of the image supplied by the V4L2 device.
    See also: V4L2 API at http://v4l2spec.bytesex.org/spec-single/v4l2.html
    """)
    imageHeight = property(lib_mvIMPACT_acquire.CameraSettingsV4L2Device_imageHeight_get, doc=r"""
    An integer property defining the height of the image supplied by the V4L2 device.
    See also: V4L2 API at http://v4l2spec.bytesex.org/spec-single/v4l2.html
    """)
    videoStandard = property(lib_mvIMPACT_acquire.CameraSettingsV4L2Device_videoStandard_get, doc=r"""
    An integer property defining the video standard.
    Use this property to configure the V4L2-device corresponding to the connected video source.
    Available video standards depend on the V4L2-device and conform to **v4l2_std_id**
    See also: V4L2 API at http://v4l2spec.bytesex.org/spec-single/v4l2.html
    """)
    pixelFormat = property(lib_mvIMPACT_acquire.CameraSettingsV4L2Device_pixelFormat_get, doc=r"""
    An integer property defining the pixel format of captured frames.
    Use this property to set the pixel format within the image buffer supplied by the V4L2-device.
    Available pixel formats depend on the V4L2-device and conform to **v4l2_fourcc()**
    See also: V4L2 API at http://v4l2spec.bytesex.org/spec-single/v4l2.html
    """)
    brightness = property(lib_mvIMPACT_acquire.CameraSettingsV4L2Device_brightness_get, doc=r"""
    An integer property to adjust the brightness.
    This property represents a V4L2-control ID.

    Notes: This property is not supported by every device.
    Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.
    If supported, a minimum value, a maximum value and step width will be defined. Thus, invalid values may be tuned after writing to fit within the step size,
    values too large or too small will raise an exception.
    """)
    contrast = property(lib_mvIMPACT_acquire.CameraSettingsV4L2Device_contrast_get, doc=r"""
    An integer property to adjust the contrast.
    This property represents a V4L2-control ID.

    Notes: This property is not supported by every device.
    Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.
    If supported, a minimum value, a maximum value and step width will be defined. Thus, invalid values may be tuned after writing to fit within the step size,
    values too large or too small will raise an exception.
    """)
    saturation = property(lib_mvIMPACT_acquire.CameraSettingsV4L2Device_saturation_get, doc=r"""
    An integer property to adjust the saturation.
    This property represents a V4L2-control ID.
    Notes: This property is not supported by every device.
    Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.
    If supported, a minimum value, a maximum value and step width will be defined. Thus, invalid values may be tuned after writing to fit within the step size,
    values too large or too small will raise an exception.
    """)
    hue = property(lib_mvIMPACT_acquire.CameraSettingsV4L2Device_hue_get, doc=r"""
    An integer property to adjust the hue.
    This property represents a V4L2-control ID.

    Notes: This property is not supported by every device.
    Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.
    If supported, a minimum value, a maximum value and step width will be defined. Thus, invalid values may be tuned after writing to fit within the step size,
    values too large or too small will raise an exception.
    """)
    blackLevel = property(lib_mvIMPACT_acquire.CameraSettingsV4L2Device_blackLevel_get, doc=r"""
    An integer property to adjust the black level.
    This property represents a V4L2-control ID.
    Notes: This property is not supported by every device.
    Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.
    If supported, a minimum value, a maximum value and step width will be defined. Thus, invalid values may be tuned after writing to fit within the step size,
    values too large or too small will raise an exception.
    """)
    autoWhiteBalance = property(lib_mvIMPACT_acquire.CameraSettingsV4L2Device_autoWhiteBalance_get, doc=r"""
    An enumerated integer property to switch on/off the auto white balance function of the V4L2-device.
    This property represents a boolean-valued V4L2-control ID. Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.

    Notes: This property is not supported by every device.
    Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.
    """)
    redBalance = property(lib_mvIMPACT_acquire.CameraSettingsV4L2Device_redBalance_get, doc=r"""
    An integer property to adjust the red balance.
    This property represents a V4L2-control ID.

    Notes: This property is not supported by every device.
    Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.
    If supported, a minimum value, a maximum value and step width will be defined. Thus, invalid values may be tuned after writing to fit within the step size,
    values too large or too small will raise an exception.
    """)
    blueBalance = property(lib_mvIMPACT_acquire.CameraSettingsV4L2Device_blueBalance_get, doc=r"""
    An integer property to adjust the blue balance.
    This property represents a V4L2-control ID.

    Notes: This property is not supported by every device.
    Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.
    If supported, a minimum value, a maximum value and step width will be defined. Thus, invalid values may be tuned after writing to fit within the step size,
    values too large or too small will raise an exception.
    """)
    gamma = property(lib_mvIMPACT_acquire.CameraSettingsV4L2Device_gamma_get, doc=r"""
    An integer property to adjust the gamma.
    This property represents a V4L2-control ID
    Notes: This property is not supported by every device.
    Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.
    If supported, a min-value, a max-value and step-width are defined. Thus, invalid values may be tuned after writing to fit within the limits.
    """)
    exposure = property(lib_mvIMPACT_acquire.CameraSettingsV4L2Device_exposure_get, doc=r"""
    An integer property to adjust the exposure.
    This property represents a V4L2-control ID.

    Notes: This property is not supported by every device.
    Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.
    If supported, a minimum value, a maximum value and step width will be defined. Thus, invalid values may be tuned after writing to fit within the step size,
    values too large or too small will raise an exception.
    """)
    autoGain = property(lib_mvIMPACT_acquire.CameraSettingsV4L2Device_autoGain_get, doc=r"""
    An enumerated integer property to switch on/off the auto gain.
    This property represents a boolean-valued V4L2-control ID. Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.

    Notes: This property is not supported by every device.
    Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.
    """)
    gain = property(lib_mvIMPACT_acquire.CameraSettingsV4L2Device_gain_get, doc=r"""
    An integer property to adjust the gain.
    This property represents a V4L2-control ID.

    Notes: This property is not supported by every device.
    Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.
    If supported, a minimum value, a maximum value and step width will be defined. Thus, invalid values may be tuned after writing to fit within the step size,
    values too large or too small will raise an exception.
    """)
    HFlip = property(lib_mvIMPACT_acquire.CameraSettingsV4L2Device_HFlip_get, doc=r"""
    An enumerated integer property to mirror the frames horizontally.
    This property represents a boolean-valued V4L2-control ID. Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.

    Notes: This property is not supported by every device.
    Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.
    """)
    VFlip = property(lib_mvIMPACT_acquire.CameraSettingsV4L2Device_VFlip_get, doc=r"""
    An integer property to mirror the frames vertically.
    This property represents a boolean-valued V4L2-control ID. Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.

    Notes: This property is not supported by every device.
    Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.
    """)
    powerLineFrequency = property(lib_mvIMPACT_acquire.CameraSettingsV4L2Device_powerLineFrequency_get, doc=r"""
    An enumerated integer property to enable power line frequency filter.
    This property represents a V4L2-control ID.

    Notes: This property is not supported by every device.
    Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.

    If supported, possible values conform to V4L2 API:

    |string representation|numerical representation|
    |V4L2_CID_POWER_LINE_FREQUENCY_DISABLED|0|
    |V4L2_CID_POWER_LINE_FREQUENCY_50HZ|1|
    |V4L2_CID_POWER_LINE_FREQUENCY_60HZ|2|
    """)
    hueAuto = property(lib_mvIMPACT_acquire.CameraSettingsV4L2Device_hueAuto_get, doc=r"""
    An enumerated integer property to switch on/off auto hue.
    This property represents a boolean-valued V4L2-control ID. Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.

    Notes: This property is not supported by every device.
    Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.
    """)
    whiteBalanceTemperature = property(lib_mvIMPACT_acquire.CameraSettingsV4L2Device_whiteBalanceTemperature_get, doc=r"""
    An integer property to adjust white balance temperature.
    This property represents a V4L2-control ID.

    Notes: This property is not supported by every device.
    Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.
    If supported, a minimum value, a maximum value and step width will be defined. Thus, invalid values may be tuned after writing to fit within the step size,
    values too large or too small will raise an exception.
    """)
    sharpness = property(lib_mvIMPACT_acquire.CameraSettingsV4L2Device_sharpness_get, doc=r"""
    An integer property to adjust the sharpness.
    This property represents a V4L2-control ID.

    Notes: This property is not supported by every device.
    Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.
    If supported, a minimum value, a maximum value and step width will be defined. Thus, invalid values may be tuned after writing to fit within the step size,
    values too large or too small will raise an exception.
    """)
    backlightCompensation = property(lib_mvIMPACT_acquire.CameraSettingsV4L2Device_backlightCompensation_get, doc=r"""
    An integer property to adjust the backlight compensation.
    This property represents a V4L2-control ID.

    Notes: This property is not supported by every device.
    Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.
    If supported, a min-value, a max-value and step-width are defined. Thus, invalid values may be tuned after writing to fit within the limits.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_CameraSettingsV4L2Device

# Register CameraSettingsV4L2Device in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.CameraSettingsV4L2Device_swigregister(CameraSettingsV4L2Device)

class AutoControlParameters(ComponentCollection):
    r"""
     A class to control the automatic control parameters of a device(**Device** specific interface layout only).
    Currently this class provides access to the properties, which control the way the
    AGC(**A** utomatic **G** ain **C** ontrol) and the AEC
    (**A** utomatic **E** xpose **C** ontrol) operates.

    The values used to capture the image, which are directly influenced by this properties
    (e.g. the gain or the exposure time) will be returned as part of the result of the
    image request.

    Notes: 
    Not every device will offer the features provided in this class. Before accessing any members
    and/or properties call the function **mvIMPACT::acquire::AutoControlParameters::isAvailable**.
    If this function returns false, no other member or function call in this class will return valid
    results.


    Instances of these class can't be constructed directly. Its parameters can
    be accessed via an instance of the class **mvIMPACT::acquire::CameraSettingsBlueDevice**.

    This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
    **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

    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

    def getIsAvailable(self):
        r"""
        This function should be called to check if this device offers auto control parameters.
        :rtype: boolean
        :return: 
            - true if the device offers the features defined by this object.
            - false otherwise
        """
        return lib_mvIMPACT_acquire.AutoControlParameters_getIsAvailable(self)
    aoiHeight = property(lib_mvIMPACT_acquire.AutoControlParameters_aoiHeight_get, doc=r""" An integer property defining the height of the rectangle used for the parameter calculation.""")
    aoiStartX = property(lib_mvIMPACT_acquire.AutoControlParameters_aoiStartX_get, doc=r"""
    An integer property defining the X-offset of the rectangle used for the parameter calculation.
    Example: When setting this property to 5 the first pixel in each line of
    the resulting rectangle used for the calculation will be pixel number 5
    of each line transmitted by the camera.
    """)
    aoiStartY = property(lib_mvIMPACT_acquire.AutoControlParameters_aoiStartY_get, doc=r"""
    An integer property defining the Y-offset of the rectangle used for the parameter calculation.
    Example: When setting this property to 5 the first line of
    the resulting rectangle used for the calculation will be line number 5 of the
    image transmitted by the camera.
    """)
    aoiWidth = property(lib_mvIMPACT_acquire.AutoControlParameters_aoiWidth_get, doc=r""" An integer property defining the width of the rectangle.""")
    aoiMode = property(lib_mvIMPACT_acquire.AutoControlParameters_aoiMode_get, doc=r"""
    An enumerated integer property defining the which area of the image is used for the calculation of the parameters.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TAoiMode**.
    """)
    desiredAverageGreyValue = property(lib_mvIMPACT_acquire.AutoControlParameters_desiredAverageGreyValue_get, doc=r"""
    An integer property defining the average grey value to be reached within the AOI in the image by the control circuit.
    For multi-byte pixel formats like e.g. **mvIMPACT::acquire::ibpfMono10** this value will refer to
    the 8 most significant bits of the pixel data, thus e.g a value of 128 for this property will result
    it the controller trying reach an average grey value of 512 (0x200).
    """)
    controllerSpeed = property(lib_mvIMPACT_acquire.AutoControlParameters_controllerSpeed_get, doc=r"""
    An enumerated integer property defining the speed the control circuit will be operated in.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TAutoControlSpeed**.

    Once the controller started to react and adapt itself to a new situation, this property will
    define how long this adaption will take, while **AutoControlParameters::controllerDelay_Images**
    defines the number of images to wait from a detected change to the actual start of the
    adaption to this new situation.
    """)
    controllerGain = property(lib_mvIMPACT_acquire.AutoControlParameters_controllerGain_get, doc=r"""
    The **P** fraction of the controller.
    This feature will only be visible when **mvIMPACT::acquire::AutoControlParameters::controllerSpeed**
    is set to **mvIMPACT::acquire::acsUserDefined**.
    """)
    controllerIntegralTime_ms = property(lib_mvIMPACT_acquire.AutoControlParameters_controllerIntegralTime_ms_get, doc=r"""
    The **I** fraction of the controller.
    This feature will only be visible when **mvIMPACT::acquire::AutoControlParameters::controllerSpeed**
    is set to **mvIMPACT::acquire::acsUserDefined**.
    """)
    controllerDerivativeTime_ms = property(lib_mvIMPACT_acquire.AutoControlParameters_controllerDerivativeTime_ms_get, doc=r"""
    The **D** fraction of the controller.
    This feature will only be visible when **mvIMPACT::acquire::AutoControlParameters::controllerSpeed**
    is set to **mvIMPACT::acquire::acsUserDefined**.
    """)
    controllerDelay_Images = property(lib_mvIMPACT_acquire.AutoControlParameters_controllerDelay_Images_get, doc=r"""
    An integer property to influence the speed the AGC and/or AEC control circuit will react and adapt to changes.
    While **AutoControlParameters::controllerSpeed** influences the overall time
    needed to adjust the controller to a new situation, this property can be used to define a
    delay when the controller shall start to adapt to a changed situation.
    """)
    gainLowerLimit_dB = property(lib_mvIMPACT_acquire.AutoControlParameters_gainLowerLimit_dB_get, doc=r"""
    A float property defining the lower limit for the cameras gain(in dB).
    When the AGC is active this value defines the minimum value for the cameras gain.
    Even if the controller can reach the desired average grey value, the gain will
    never fall below this value.
    """)
    gainUpperLimit_dB = property(lib_mvIMPACT_acquire.AutoControlParameters_gainUpperLimit_dB_get, doc=r"""
    A float property defining the upper limit for the cameras gain(in dB).
    When the AGC is active this value defines the maximum value for the cameras gain.
    Even if the controller can reach the desired average grey value, the gain will
    never exceed this value.
    """)
    exposeLowerLimit_us = property(lib_mvIMPACT_acquire.AutoControlParameters_exposeLowerLimit_us_get, doc=r"""
    A float property defining the lower limit for the sensors expose time(in us).
    When the AEC is active this value defines the minimum value for the sensors expose time(in us).
    Even if the controller can reach the desired average grey value, the expose time will
    never fall below this value.
    """)
    exposeUpperLimit_us = property(lib_mvIMPACT_acquire.AutoControlParameters_exposeUpperLimit_us_get, doc=r"""
    An integer property defining the upper limit for the sensors expose time in us.
    When the AEC is active this value defines the maximum value for the sensors expose time(in us).
    Even if the controller can reach the desired average grey value, the expose time will
    never exceed this value.
    """)

    r""" \brief A bool property \b (read-only) which checks if if this device offers auto control parameters. See mvIMPACT.acquire.AutoControlParameters.getIsAvailable() """
    isAvailable = property(getIsAvailable, None, None, None)

    __swig_destroy__ = lib_mvIMPACT_acquire.delete_AutoControlParameters

# Register AutoControlParameters in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.AutoControlParameters_swigregister(AutoControlParameters)

class CameraSettingsBlueDevice(CameraSettingsBase):
    r"""
    A base class for camera related settings belonging to the mvBlueXXX-series (**Device** specific interface layout only).
    Notes: This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
    **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::CameraSettingsBlueDevice** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.CameraSettingsBlueDevice_swiginit(self, lib_mvIMPACT_acquire.new_CameraSettingsBlueDevice(*args))
    autoControlMode = property(lib_mvIMPACT_acquire.CameraSettingsBlueDevice_autoControlMode_get, doc=r"""
    An enumerated integer property defining the auto control mode the device is operated in.
    This property can be used to control the overall behaviour of the algorithms used for performing AEC
    (**A** utomatic **E** xpose **C** ontrol) or AGC (**A** utomatic **G** ain **C** ontrol).
    This could be done by the device itself thus e.g. even in the analog domain or e.g. by a software
    process in the driver. Each method will offer certain advantages and disadvantages and depending on the
    application the correct method can be selected.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TAutoControlMode**.

    Every device or even different models belonging to the same device family may support different auto control modes,
    thus it's crucial to query the valid modes for each device by reading the properties translation dictionary BEFORE trying
    to assign a certain value to this property.
    """)
    autoGainControl = property(lib_mvIMPACT_acquire.CameraSettingsBlueDevice_autoGainControl_get, doc=r"""
    An enumerated integer property, which represents the current mode the AGC (**A** utomatic **G** ain **C** ontrol) is operated in.
    The values used to capture the image, which are directly influenced by an activated AGC or AEC
    (e.g. the gain or the exposure time) will be returned as part of the result of the
    image request.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TAutoGainControl**.

    Notes: 
    This property is not supported by every device. Therefore always call the function
    **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.
    """)
    autoExposeControl = property(lib_mvIMPACT_acquire.CameraSettingsBlueDevice_autoExposeControl_get, doc=r"""
    An enumerated integer property, which represents the current mode the AEC (**A** utomatic **E** xpose **C** ontrol) is operated in.
    The values used to capture the image, which are directly influenced by an activated AGC or AEC
    (e.g. the gain or the exposure time) will be returned as part of the result of the
    image request.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TAutoExposureControl**.

    Notes: 
    This property might not be supported by every device. Therefore always call the function
    **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.
    """)
    gain_dB = property(lib_mvIMPACT_acquire.CameraSettingsBlueDevice_gain_dB_get, doc=r"""
     A float property defining the gain in dB.
    The formula for given ``gain_dB`` is

    .. code-block:: c++

        gain_x= 10 ^ (gain_dB/20)

    **Example**:

    .. code-block:: c++

        gain_x = 10 ^ (6/20) = 1.995

    I.e. increasing the gain setting by 6dB corresponds to factor of 2.

    The formula for given gain_x is

    .. code-block:: c++

        gain_dB = 20*log(gain_x) dB

    Where:

    ``gain_dB``: MATRIX VISION gain value (logarithmic)

    ``gain_x``: multiplicative gain

    ``^``: power function
    """)
    offset_pc = property(lib_mvIMPACT_acquire.CameraSettingsBlueDevice_offset_pc_get, doc=r"""
    A float property defining the analogue sensor offset in percent of the allowed range (sensor specific).
    This property influences the average grey level when no light reaches the sensor.

         **mvBlueFOX** **specific**:
    Changing its value will have no effect if **mvIMPACT::acquire::CameraSettingsBlueFOX::offsetAutoCalibration** is set to
    **mvIMPACT::acquire::aocOn**.

    By default
    this value will be around 10 (if **mvIMPACT::acquire::CameraSettingsBlueFOX::offsetAutoCalibration** if set
    to **mvIMPACT::acquire::aocOn)**. This means the average grey value for an image
    taken in a completely dark environment will be around 10. When setting
    **mvIMPACT::acquire::CameraSettingsBlueFOX::offsetAutoCalibration** to **mvIMPACT::acquire::aocOff**
    **mvIMPACT::acquire::CameraSettingsBlueFOX::offset_pc** can be used to modify this value.

    Image: Offset_pc.png
    The valid range for this property lies between -100% and +100%, whereas negative values
    will shifts the black level towards 0 and positive values to 255.

    Notes: 
    This property might not be supported by every device. Therefore always call the function
    **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.
    """)
    pixelClock_KHz = property(lib_mvIMPACT_acquire.CameraSettingsBlueDevice_pixelClock_KHz_get, doc=r"""
    An enumerated integer property defining the pixel clock of the camera sensor in KHz.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraPixelClock**.

    Notes: 
    Changing the pixel clock at runtime will have major impact on the overall behaviour of the
    camera. The pixel clock should therefore not be modified constantly during the execution
    of the application code. Whenever this property is changed, the next images captured should
    be skipped if a device works with an active auto offset calibration controller circuit as then the
    control circuits on the camera might need one to three images until all control loops are
    locked again.

    Every device or even different models belonging to the same device family may support different pixel clocks,
    thus it's crucial to query the valid clock modes for each sensor by reading the properties translation dictionary.
    """)
    exposeMode = property(lib_mvIMPACT_acquire.CameraSettingsBlueDevice_exposeMode_get, doc=r"""
    An enumerated integer property defining the exposure mode the camera sensor is operated in.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraExposeMode**.

    Notes: 
    Not every device will offer the same options.
    Check for valid modes by reading the properties translation dictionary with
    the functions **mvIMPACT::acquire::PropertyICameraExposeMode::getTranslationDictString** and
    **mvIMPACT::acquire::PropertyICameraExposeMode::getTranslationDictValue**.
    If: DOXYGEN_CPP_DOCUMENTATION {
    C++ offers the more efficient function **mvIMPACT::acquire::PropertyICameraExposeMode::getTranslationDict**
    in addition to the functions mentioned above.
    }
    """)
    expose_us = property(lib_mvIMPACT_acquire.CameraSettingsBlueDevice_expose_us_get, doc=r"""
    An integer property which defines the exposure time for an image in us.
    Image: Expose_us.png
    """)
    binningMode = property(lib_mvIMPACT_acquire.CameraSettingsBlueDevice_binningMode_get, doc=r"""
    An enumerated integer property defining the binning mode the camera is operated in.
    By default the no binning will be performed.
    Notes: 
    Not every camera will support every binning mode. To find out which binning modes
    are supported by your camera you can query the properties translation table with
    the functions **mvIMPACT::acquire::PropertyICameraBinningMode::getTranslationDictString** and
    **mvIMPACT::acquire::PropertyICameraBinningMode::getTranslationDictValue**
    If: DOXYGEN_CPP_DOCUMENTATION {
    C++ offers the more efficient function **mvIMPACT::acquire::PropertyICameraBinningMode::getTranslationDict**
    in addition to the functions mentioned above.
    }

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraBinningMode**.
    """)
    testMode = property(lib_mvIMPACT_acquire.CameraSettingsBlueDevice_testMode_get, doc=r"""
     An enumerated integer property defining the image transmission mode of the camera.
    If this property is set to **mvIMPACT::acquire::ctmOff** the 'normal' image
    captured by the cameras sensor will be transmitted. This is the default.
    To ensure correct operation the camera might define several test modes where
    some kind of well defined pattern will be transmitted.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraTestMode**. No every
    test mode will be supported by every device.
    """)
    triggerMode = property(lib_mvIMPACT_acquire.CameraSettingsBlueDevice_triggerMode_get, doc=r"""
    An enumerated integer property which defines what kind of trigger mode shall be used for an image acquisition.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraTriggerMode**.

    Notes: 
    Not every device will support every trigger mode. To find out which trigger modes are supported by a specific
    device at runtime the properties translation dictionary should be queried.


    Also the sensor specific part of this manual will contain a list of trigger modes that are available for
    this specific image sensor.
    """)
    frameDelay_us = property(lib_mvIMPACT_acquire.CameraSettingsBlueDevice_frameDelay_us_get, doc=r"""
    An integer property defining the delay in us between an external trigger event an the begin of the sensor exposure.
    Notes: This property is not supported by every device.
    Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.
    """)
    autoControlParameters = property(lib_mvIMPACT_acquire.CameraSettingsBlueDevice_autoControlParameters_get, doc=r"""
    Provides access to the control parameters for AGC and AEC.
    Notes: 
    These settings will only affect the image if **mvIMPACT::acquire::CameraSettingsBlueDevice::autoGainControl**,
    **mvIMPACT::acquire::CameraSettingsBlueDevice::autoExposeControl** or both are set to active.
    """)

    def getAutoControlParameters(self):
        r"""
        Provides access to the control parameters for AGC and AEC.
        Notes: 
        These settings will only affect the image if **mvIMPACT::acquire::CameraSettingsBlueDevice::autoGainControl**,
        **mvIMPACT::acquire::CameraSettingsBlueDevice::autoExposeControl** or both are set to active.
        """
        return lib_mvIMPACT_acquire.CameraSettingsBlueDevice_getAutoControlParameters(self)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_CameraSettingsBlueDevice

# Register CameraSettingsBlueDevice in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.CameraSettingsBlueDevice_swigregister(CameraSettingsBlueDevice)

class HDRKneePoint(ComponentCollection):
    r"""
    A class to configure a HDR (**H**igh **D**ynamic **R**ange) knee point (**Device** specific interface layout only).
    Notes: 
    Not every device will offer the features provided in this class. Before accessing properties call
    the function **mvIMPACT::acquire::Component::isValid**. Right now only the mvBlueFOX-x00wx types
    will support the features defined by this class.


    Instances of these class can't be constructed directly. Its parameters can
    be accessed via an instance of the class **mvIMPACT::acquire::CameraSettingsBlueFOX** or
    **mvIMPACT::acquire::CameraSettingsBlueCOUGAR**.

    This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
    **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

    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
    HDRControlVoltage_mV = property(lib_mvIMPACT_acquire.HDRKneePoint_HDRControlVoltage_mV_get, doc=r""" An enumerated integer property that can be used to define the control voltage in mV for this knee point.""")
    HDRExposure_ppm = property(lib_mvIMPACT_acquire.HDRKneePoint_HDRExposure_ppm_get, doc=r""" An enumerated integer property that can be used to define the exposure time in ppm of the overall exposure time for this knee point.""")
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_HDRKneePoint

# Register HDRKneePoint in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.HDRKneePoint_swigregister(HDRKneePoint)

class HDRControl(ComponentCollection):
    r"""
    A class to control the HDR (**H**igh **D**ynamic **R**ange) parameters of a device (**Device** specific interface layout only).
    Notes: 
    Not every device will offer the features provided in this class. Before accessing properties call
    the function **mvIMPACT::acquire::Component::isValid**. Right now only the mvBlueFOX-x00wx, mvBlueFOX-x02dx and
    mvBlueCOUGAR-x00wx as well as mvBlueCOUGAR-x02dx types will support the features defined by this class.


    Instances of these class can't be constructed directly. Its parameters can
    be accessed via an instance of the class **mvIMPACT::acquire::CameraSettingsBlueFOX** or
    **mvIMPACT::acquire::CameraSettingsBlueCOUGAR**.

    This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
    **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

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

    def __init__(self, src):
        r"""
        Copy constructor.
        Creates a new object from an existing device object. Keep in mind that this new object
        will provide access to the very same hardware and therefore you might as well use the original
        reference. This constructor is only provided for internal reference counting to guarantee correct operation of the
        objects of this class under all platforms and languages.
        """
        lib_mvIMPACT_acquire.HDRControl_swiginit(self, lib_mvIMPACT_acquire.new_HDRControl(src))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_HDRControl

    def getIsAvailable(self):
        r"""
        This function should be called to check if this device offers HDR (**H**igh **D**ynamic **R**ange) control parameters.
        :rtype: boolean
        :return: 
            - true if the device offers the features defined by this object.
            - false otherwise
        """
        return lib_mvIMPACT_acquire.HDRControl_getIsAvailable(self)

    def getHDRKneePoint(self, nr):
        r"""
         Returns a reference to a set of user definable parameters to configure a HDR (**H**igh **D**ynamic **R**ange) knee point.
         Use the property **mvIMPACT::acquire::HDRControl::HDRKneePointCount** to find out how many knee points are available
         or to change the number of knee points.

         If: DOXYGEN_CPP_DOCUMENTATION {
         If *nr* is invalid(too large) a STL out_of_range exception
         will be thrown.
         }

         :rtype: :py:class:`HDRKneePoint`
         :return: A reference to a set of user definable parameters to configure a HDR (**H**igh **D**ynamic **R**ange) knee point.

        :type nr: int
        :param nr: [in] The number of the knee point to be returned
        """
        return lib_mvIMPACT_acquire.HDRControl_getHDRKneePoint(self, nr)
    HDREnable = property(lib_mvIMPACT_acquire.HDRControl_HDREnable_get, doc=r"""
    An enumerated integer property which can be used to enable/disable HDR (**H**igh **D**ynamic **R**ange) mode.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.
    """)
    HDRMode = property(lib_mvIMPACT_acquire.HDRControl_HDRMode_get, doc=r"""
    An enumerated integer property which can be used to configure the HDR (**H**igh **D**ynamic **R**ange) mode to work with.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraHDRMode**.
    """)
    HDRKneePointCount = property(lib_mvIMPACT_acquire.HDRControl_HDRKneePointCount_get, doc=r""" An integer property to define the number of knee points to work with when **mvIMPACT::acquire::HDRControl::HDRMode** is set to **mvIMPACT::acquire::cHDRmUser**.""")

    r""" \brief A bool property \b (read-only) which checks if this device offers HDR (<b>H</b>igh <b>D</b>ynamic <b>R</b>ange) parameters. See mvIMPACT.acquire.HDRControl.getIsAvailable() """
    isAvailable = property(getIsAvailable, None, None, None)


# Register HDRControl in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.HDRControl_swigregister(HDRControl)

class CameraSettingsBlueFOX(CameraSettingsBlueDevice):
    r"""
    **mvBlueFOX** related camera settings(**Device** specific interface layout only).
    This class contains properties to control the way the image sensor of the
    **mvBlueFOX** behaves.

    Notes: This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
    **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::CameraSettingsBlueFOX** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.CameraSettingsBlueFOX_swiginit(self, lib_mvIMPACT_acquire.new_CameraSettingsBlueFOX(*args))

    def getHDRControl(self):
        r""" Returns the **mvIMPACT::acquire::HDRControl** object associated with this setting."""
        return lib_mvIMPACT_acquire.CameraSettingsBlueFOX_getHDRControl(self)
    offsetAutoCalibration = property(lib_mvIMPACT_acquire.CameraSettingsBlueFOX_offsetAutoCalibration_get, doc=r"""
    An enumerated integer property defining the offset calibration mode.
    If this property is set to **mvIMPACT::acquire::aocOff**
    the offset can be adjusted manually by modifying the **mvIMPACT::acquire::CameraSettingsBlueFOX::offset_pc** and
    mvIMPACT::acquire::CameraSettingsBlueFOX::offsetCorrection_pc properties.

    If set to **mvIMPACT::acquire::aocOn** the offset is approx. 10. That means,
    that the medium pixel count is 10, in case no light is falling on the sensor.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TAutoOffsetCalibration**.
    """)
    offsetCorrection_pc = property(lib_mvIMPACT_acquire.CameraSettingsBlueFOX_offsetCorrection_pc_get, doc=r"""
    A float property defining and **additional** analogue sensor offset in percent of the allowed range (sensor specific) **per** **color** **channel**.
    Together with value of the property **mvIMPACT::acquire::CameraSettingsBlueDevice::offset_pc** this property influences the average grey level
    when no light reaches the sensor.

    This property stores 4 values.
    - The value at index 0 applies to the green component of the red-green rows of the bayer pattern
    - The value at index 1 applies to the red component of the bayer pattern
    - The value at index 2 applies to the green component of the blue-green rows of the bayer pattern
    - The value at index 3 applies to the blue component of the bayer pattern

    Notes: 
    This property might not be supported by every device. Therefore always call the function
    **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.
    In addition to that this property must be enabled explicitly by setting the advanced option bit
    **mvIMPACT::acquire::daoEnablePerChannelOffsetCorrection** of the property
    **mvIMPACT::acquire::CameraSettingsBlueFOX::advancedOptions**.
    See also: 
    **mvIMPACT::acquire::CameraSettingsBlueDevice::offset_pc**
    """)
    offsetAutoBlackLevel = property(lib_mvIMPACT_acquire.CameraSettingsBlueFOX_offsetAutoBlackLevel_get, doc=r"""
    An integer property defining the digital value assumed as black.
    Modifying this property in rare cases might be useful to achieve a higher dynamic range for noise close to the black
    level.

    Notes: 
    As the **mvBlueFOX** internally works with a 10 bit analog to digital conversion increasing this
    value by 4 will result in a black level increased by about 1 in the resulting 8 bit raw image
    delivered from the camera.
    """)
    offsetAutoBlackSpeed = property(lib_mvIMPACT_acquire.CameraSettingsBlueFOX_offsetAutoBlackSpeed_get, doc=r"""
    An enumerated integer property defining the speed of the auto offset calibration circuit.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed**.
    """)
    lineDelay_clk = property(lib_mvIMPACT_acquire.CameraSettingsBlueFOX_lineDelay_clk_get, doc=r"""
    An integer property defining the delay in clocks between two lines.
    Can be used to slow down the image readout the reduce the peak bandwidth required
    for the transfer.
    """)
    advancedOptions = property(lib_mvIMPACT_acquire.CameraSettingsBlueFOX_advancedOptions_get, doc=r"""
    An enumerated integer property defining a collection of advanced options that can be enabled or disabled.
    This property is highly sensor dependent. Each sensor might offer a different sub set of the options offered.
    Only experienced users should work with this feature.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDeviceAdvancedOptions**.
    """)
    flashToExposeDelay_us = property(lib_mvIMPACT_acquire.CameraSettingsBlueFOX_flashToExposeDelay_us_get, doc=r"""
    An integer property defining the delay in us between the start of the flash signal output and the beginning of the expose period of the image sensor.
    Notes: 
    This property is mainly provided for compatibility reasons. Previous versions of the
    **mvBlueFOX** driver produced a fixed delay of about 300 us between the beginning of the
    flash signal creation and the beginning of the sensors expose period. Newer versions of the
    driver do **NOT** produce this delay anymore which might cause a different illumination
    for applications using very intensive, short flash and expose times. Applications relying on
    the delay introduced in older driver versions should set this property to
    '300' by calling **mvIMPACT::acquire::PropertyI::write**.

    See also: 
    **mvIMPACT::acquire::CameraSettingsBlueDevice::expose_us**
    """)
    flashMode = property(lib_mvIMPACT_acquire.CameraSettingsBlueFOX_flashMode_get, doc=r"""
    An enumerated integer property defining the behaviour of the flash output of the camera (if available).
    If this property is set the cameras flash output (if available) will be pulsed
    during the exposure period of the sensor. In that case the pulse width will be equal
    to the exposure time.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraFlashMode**.

    See also: 
    **mvIMPACT::acquire::CameraSettingsBlueFOX::flashToExposeDelay_us**
    """)
    flashType = property(lib_mvIMPACT_acquire.CameraSettingsBlueFOX_flashType_get, doc=r"""
    An enumerated integer property defining the type of the flash output of the camera (if available).
    Depending of the camera sensor type (*rolling* shutter or *frame* *shutter*
    there well be different modes available

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraFlashType**.
    """)
    shutterMode = property(lib_mvIMPACT_acquire.CameraSettingsBlueFOX_shutterMode_get, doc=r"""
    An enumerated integer property defining the shutter mode to use.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraShutterMode**.
    """)
    triggerSource = property(lib_mvIMPACT_acquire.CameraSettingsBlueFOX_triggerSource_get, doc=r"""
    An enumerated integer property defining where the trigger signal is expected to occur.
    When working with hardware generated signals via **mvIMPACT::acquire::RTCtrProgram** objects
    this property should be set to **mvIMPACT::acquire::ctsRTCtrl** as otherwise
    the program will not affect the behaviour of the camera.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraTriggerSource**.
    """)
    sensorTimingMode = property(lib_mvIMPACT_acquire.CameraSettingsBlueFOX_sensorTimingMode_get, doc=r"""
    An enumerated integer property defining the current image sensor timing mode.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBlueFOXSensorTiming**.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_CameraSettingsBlueFOX

# Register CameraSettingsBlueFOX in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.CameraSettingsBlueFOX_swigregister(CameraSettingsBlueFOX)

class CameraSettingsBlueCOUGAR(CameraSettingsBlueDevice):
    r"""
    **mvBlueCOUGAR** related camera settings (**Device** specific interface layout only).
    This class contains properties to control the way the image sensor(s) of the
    **mvBlueCOUGAR** behaves.

    Notes: This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
    **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::CameraSettingsBlueCOUGAR** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.CameraSettingsBlueCOUGAR_swiginit(self, lib_mvIMPACT_acquire.new_CameraSettingsBlueCOUGAR(*args))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_CameraSettingsBlueCOUGAR

    def getTriggerControlCount(self):
        r"""
        Returns the number of **mvIMPACT::acquire::TriggerControls** available for this device.
        This might be 0 if the device either does not support this feature.
        """
        return lib_mvIMPACT_acquire.CameraSettingsBlueCOUGAR_getTriggerControlCount(self)

    def triggerControl(self, *args):
        r"""
        *Overload 1:*
         Returns a const pointer to a **mvIMPACT::acquire::TriggerControl** object.
         If: DOXYGEN_CPP_DOCUMENTATION {
         If *nr* references an invalid pin a STL out_of_range exception
         will be thrown.
         }

         Notes: 
         The features of each **mvIMPACT::acquire::TriggerControl** will only be visible and thus available,
         when **mvIMPACT::acquire::CameraSettingsBlueCOUGAR::triggerInterface**
         is set to **mvIMPACT::acquire::dtiAdvanced**.

        :type nr: int
        :param nr: [in] The number of the trigger control

        |

        *Overload 2:*
         Returns a const pointer to a **mvIMPACT::acquire::TriggerControl** object or NULL if the name passed to the function does not specify a valid trigger control.
        :type name: string
        :param name: [in] The name of the trigger control
        """
        return lib_mvIMPACT_acquire.CameraSettingsBlueCOUGAR_triggerControl(self, *args)

    def getHDRControl(self):
        r""" Returns the **mvIMPACT::acquire::HDRControl** object associated with this setting."""
        return lib_mvIMPACT_acquire.CameraSettingsBlueCOUGAR_getHDRControl(self)
    frameRate_Hz = property(lib_mvIMPACT_acquire.CameraSettingsBlueCOUGAR_frameRate_Hz_get, doc=r"""
    A float property defining the frame rate (in Hz) this device shall use to transfer images.
    Depending on other parameters the desired frame rate might not be achievable (e.g. if the exposure time
    is higher than the frame period. In that case the device will automatically reduce the frame rate.
    Notes: This property is not supported by every device.
    Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.
    """)
    partialScanMode = property(lib_mvIMPACT_acquire.CameraSettingsBlueCOUGAR_partialScanMode_get, doc=r"""
    An enumerated integer property defining whether partial scan mode shall be used or not.
    This property currently is only available for **mvBlueCOUGAR-S** devices. When partial scan mode is active, the
    frame rate can no longer be controlled be the property **mvIMPACT::acquire::CameraSettingsBlueCOUGAR::frameRate_Hz**.
    The device will always transmit frames as fast as possible instead.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.
    """)
    triggerInterface = property(lib_mvIMPACT_acquire.CameraSettingsBlueCOUGAR_triggerInterface_get, doc=r"""
    An enumerated integer property defining which view of the trigger interface to use.
    This property mainly switches the visibility of trigger the different trigger interfaces. After applying changes to
    this property all trigger related features might have a different visibility. However the documentation will state
    what features are available in which mode.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDeviceTriggerInterface**.
    """)
    triggerSource = property(lib_mvIMPACT_acquire.CameraSettingsBlueCOUGAR_triggerSource_get, doc=r"""
    An enumerated integer property defining where the trigger signal is expected to occur.
    When working with hardware generated signals via **mvIMPACT::acquire::RTCtrProgram** objects
    this property should be set to **mvIMPACT::acquire::ctsRTCtrl** as otherwise
    the program will not affect the behaviour of the camera.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraTriggerSource**.

    Notes: 
    This feature will only be visible and thus available, when **mvIMPACT::acquire::CameraSettingsBlueCOUGAR::triggerInterface**
    is set to **mvIMPACT::acquire::dtiStandard**.
    """)
    acquisitionBurstFrameCount = property(lib_mvIMPACT_acquire.CameraSettingsBlueCOUGAR_acquisitionBurstFrameCount_get, doc=r"""
    A 64-bit integer property defining the number of frames to acquire for each FrameBurstStart trigger.
    Notes: 
    This feature will only be taken into account if the ``FrameBurstStart`` trigger is active when **mvIMPACT::acquire::CameraSettingsBlueCOUGAR::triggerInterface**
    is set to **mvIMPACT::acquire::dtiAdvanced**.
    """)

    r""" \brief An integer property \b (read-only) which holds the number of mvIMPACT.acquire.TriggerControls available for this device. See mvIMPACT.acquire.CameraSettingsBlueCOUGAR.getTriggerControlCount() """
    triggerControlCount = property (getTriggerControlCount, None, None, None)


# Register CameraSettingsBlueCOUGAR in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.CameraSettingsBlueCOUGAR_swigregister(CameraSettingsBlueCOUGAR)

class CameraSettingsFrameGrabber(CameraSettingsBase):
    r"""
    A class to access frame grabber related camera settings(**Device** specific interface layout only).
    This class contains properties to control the way the a frame grabber
    behaves in connection with the connected camera.

    Notes: 
    Not every frame grabber will support every property defined in this class. Please
    refer to the description of the individual properties and make heavy use of the
    function **mvIMPACT::acquire::Component::isValid** in order to check whether
    a property is available for the device.

    This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
    **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::CameraSettingsFrameGrabber** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.CameraSettingsFrameGrabber_swiginit(self, lib_mvIMPACT_acquire.new_CameraSettingsFrameGrabber(*args))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_CameraSettingsFrameGrabber

    def getTriggerControlCount(self):
        r"""
        Returns the number of **mvIMPACT::acquire::TriggerControls** available for this device.
        This might be 0 if the device either does not support this feature.
        """
        return lib_mvIMPACT_acquire.CameraSettingsFrameGrabber_getTriggerControlCount(self)

    def triggerControl(self, *args):
        r"""
        *Overload 1:*
         Returns a const pointer to a **mvIMPACT::acquire::TriggerControl** object.
         If: DOXYGEN_CPP_DOCUMENTATION {
         If *nr* references an invalid pin a STL out_of_range exception
         will be thrown.
         }

        :type nr: int
        :param nr: [in] The number of the trigger control

        |

        *Overload 2:*
         Returns a const pointer to a **mvIMPACT::acquire::TriggerControl** object or NULL if the name passed to the function does not specify a valid trigger control.
        :type name: string
        :param name: [in] The name of the trigger control
        """
        return lib_mvIMPACT_acquire.CameraSettingsFrameGrabber_triggerControl(self, *args)
    type = property(lib_mvIMPACT_acquire.CameraSettingsFrameGrabber_type_get, doc=r"""
    An enumerated integer property defining the camera description used for the image acquisition.
    This property **ALWAYS** defines a translation dictionary containing a string representation
    and a numerical value for the camera descriptions available for the device. The string
    representation of the camera description will be build from the property name of the class this
    camera description belongs to (e.g. *'Standard'*, *'NonStandard'* or *'CameraLink')* and
    the name of the camera description itself. Assuming a the device can handle standard
    video cameras and a description for a camera named *'MyCCIRCamera'* will therefore
    add *'Standard_MyCCIRCamera'* and a unique numerical representation to the properties
    translation dictionary.
    """)
    aoiMode = property(lib_mvIMPACT_acquire.CameraSettingsFrameGrabber_aoiMode_get, doc=r"""
    An enumerated integer property defining the used AOI mode for the image capture.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraAoiMode**.
    """)
    gain_dB = property(lib_mvIMPACT_acquire.CameraSettingsFrameGrabber_gain_dB_get, doc=r"""
    A float property defining the gain in dB.
    This is the gain applied during the analogue to digital conversion inside the frame
    grabber, not applied inside the camera.

    * The formula for given ``gain_dB`` is

    .. code-block:: c++

        gain_x= 10 ^ (gain_dB/20)

    **Example**:

    .. code-block:: c++

        gain_x = 10 ^ (6/20) = 1.995

    I.e. increasing the gain setting by 6dB corresponds to factor of 2.

    The formula for given gain_x is

    .. code-block:: c++

        gain_dB = 20*log(gain_x) dB

    Where:

    ``gain_dB``: MATRIX VISION gain value (logarithmic)

    ``gain_x``: multiplicative gain

    ``^``: power function


    Notes: 
    This property will not be available for every frame grabber, so before using it, check
    if the property is available at all by calling **mvIMPACT::acquire::Component::isValid**. Accessing
    an invalid property will raise an exception!
    """)
    offset_mV = property(lib_mvIMPACT_acquire.CameraSettingsFrameGrabber_offset_mV_get, doc=r"""
    An integer property defining the offset in milli-Volt.
    This is the analogue offset applied during the analogue to digital conversion inside the frame
    grabber, not applied inside the camera.

    Notes: 
    This property will not be available for every frame grabber, so before using it, check
    if the property is available at all by calling **mvIMPACT::acquire::Component::isValid**. Accessing
    an invalid property will raise an exception!
    """)
    scanClock = property(lib_mvIMPACT_acquire.CameraSettingsFrameGrabber_scanClock_get, doc=r"""
    An enumerated integer property defining the scan clock mode used for the current acquisition.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TScanClock**.

    Notes: 
    This property will not be available for every frame grabber, so before using it, check
    if the property is available at all by calling **mvIMPACT::acquire::Component::isValid**. Accessing
    an invalid property will raise an exception! Digital frame grabbers will however **NOT** support
    this property.
    """)
    triggerMode = property(lib_mvIMPACT_acquire.CameraSettingsFrameGrabber_triggerMode_get, doc=r"""
    An enumerated integer property defining the behaviour of the frame grabbers trigger input.
    Notes: 
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDeviceTriggerMode**. However
    not every device will offer all these trigger modes but a subset of them. Valid trigger modes therefore
    can be found by reading the properties translation dictionary.


    This property will not be available for every frame grabber, so before using it, check
    if the property is available at all by calling **mvIMPACT::acquire::Component::isValid**. Accessing
    an invalid property will raise an exception!
    """)
    softwareTriggerPeriod_ms = property(lib_mvIMPACT_acquire.CameraSettingsFrameGrabber_softwareTriggerPeriod_ms_get, doc=r"""
    An integer property defining the software simulated trigger period.
    When **mvIMPACT::acquire::CameraSettingsFrameGrabber::triggerMode** is set to
    **mvIMPACT::acquire::dtmPeriodically** this property defines the
    interval between two consecutive external trigger events simulated by the driver.

    Currently this property is only available for **mvTITAN** and **mvGAMMA** frame grabbers.

    Notes: 
    This property will not be available for every frame grabber, so before using it, check
    if the property is available at all by calling **mvIMPACT::acquire::Component::isValid**. Accessing
    an invalid property will raise an exception!
    """)
    serialPortBaudrate = property(lib_mvIMPACT_acquire.CameraSettingsFrameGrabber_serialPortBaudrate_get, doc=r"""
    An enumerated integer property defining the baud rate of the serial communication port between frame grabber and camera.
    Currently this property is only available for CameraLink(R) frame grabbers.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraSerialPortBaudRate**.

    Notes: 
    This property will not be available for every frame grabber, so before using it, check
    if the property is available at all by calling **mvIMPACT::acquire::Component::isValid**. Accessing
    an invalid property will raise an exception!
    """)
    interlacedMode = property(lib_mvIMPACT_acquire.CameraSettingsFrameGrabber_interlacedMode_get, doc=r"""
    An enumerated integer property defining how the image from the camera shall be captured.
    If a video signal is transmitted to the capture device in an interlaced format, the device
    can either capture each individual frame, or merge two frames together into a complete image.

    This property will be invisible when the camera description selected by the property
    **mvIMPACT::acquire::CameraSettingsFrameGrabber::type** does define it property
    **mvIMPACT::acquire::CameraDescriptionBase::interlacedType** to be **mvIMPACT::acquire::citNone**
    as the decision whether an interlaced image shall be reconstructed from frames or left
    as individual frame is redundant if the video source transmits full frames only.

    The visibility of a property can be checked by calling **mvIMPACT::acquire::Component::isVisible**

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TInterlacedMode**.

    Notes: 
    This property will not be available for every frame grabber, so before using it, check
    if the property is available at all by calling **mvIMPACT::acquire::Component::isValid**. Accessing
    an invalid property will raise an exception!
    """)
    acquisitionField = property(lib_mvIMPACT_acquire.CameraSettingsFrameGrabber_acquisitionField_get, doc=r"""
    An enumerated integer property defining which frame(s) of an interlaced video signal will be digitised or triggers the start of the acquisition.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TAcquisitionField**.

    Notes: 
    This property will not be available for every frame grabber, so before using it, check
    if the property is available at all by calling **mvIMPACT::acquire::Component::isValid**. Accessing
    an invalid property will raise an exception!
    """)
    scanRateMode = property(lib_mvIMPACT_acquire.CameraSettingsFrameGrabber_scanRateMode_get, doc=r"""
    An enumerated integer property defining the scan rate mode for this setting.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDeviceScanRateMode**.

    Notes: 
    This property will not be available for every frame grabber, so before using it, check
    if the property is available at all by calling **mvIMPACT::acquire::Component::isValid**. Accessing
    an invalid property will raise an exception!
    """)
    scanRate_kHz = property(lib_mvIMPACT_acquire.CameraSettingsFrameGrabber_scanRate_kHz_get, doc=r"""
    An integer property defining the current scan frequency of the capture device.
    This property is only visible if the **mvIMPACT::acquire::CameraSettingsFrameGrabber::scanRateMode**
    property is **NOT** in an auto mode.
    Notes: 
    This property will not be available for every frame grabber, so before using it, check
    if the property is available at all by calling **mvIMPACT::acquire::Component::isValid**. Accessing
    an invalid property will raise an exception!
    """)
    luminance_pc = property(lib_mvIMPACT_acquire.CameraSettingsFrameGrabber_luminance_pc_get, doc=r"""
    An integer property defining the luminance value to be applied to the image data by the frame grabber in per cent.
    Notes: 
    This property will not be available for every frame grabber, so before using it, check
    if the property is available at all by calling **mvIMPACT::acquire::Component::isValid**. Accessing
    an invalid property will raise an exception!
    """)
    saturation_pc = property(lib_mvIMPACT_acquire.CameraSettingsFrameGrabber_saturation_pc_get, doc=r"""
    An integer property defining the saturation value to be applied to the image data by the frame grabber in per cent.
    Notes: 
    This property will not be available for every frame grabber, so before using it, check
    if the property is available at all by calling **mvIMPACT::acquire::Component::isValid**. Accessing
    an invalid property will raise an exception!
    """)
    hue_pc = property(lib_mvIMPACT_acquire.CameraSettingsFrameGrabber_hue_pc_get, doc=r"""
    An integer property defining the hue value to be applied to the image data by the frame grabber in per cent.
    Notes: 
    This property will not be available for every frame grabber, so before using it, check
    if the property is available at all by calling **mvIMPACT::acquire::Component::isValid**. Accessing
    an invalid property will raise an exception!
    """)
    contrast_pc = property(lib_mvIMPACT_acquire.CameraSettingsFrameGrabber_contrast_pc_get, doc=r"""
    An integer property defining the contrast value to be applied to the image data by the frame grabber in per cent.
    Notes: 
    This property will not be available for every frame grabber, so before using it, check
    if the property is available at all by calling **mvIMPACT::acquire::Component::isValid**. Accessing
    an invalid property will raise an exception!
    """)
    lineCounter = property(lib_mvIMPACT_acquire.CameraSettingsFrameGrabber_lineCounter_get, doc=r"""
    An enumerated integer property defining the way line counter information is handled by the device.
    This is interesting for line scan camera applications.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TLineCounter**.

    Notes: 
    This property will not be available for every frame grabber, so before using it, check
    if the property is available at all by calling **mvIMPACT::acquire::Component::isValid**. Accessing
    an invalid property will raise an exception!
    """)

    r""" \brief An integer property \b (read-only) which holds the number of mvIMPACT.acquire.TriggerControls available for this device. See mvIMPACT.acquire.CameraSettingsFrameGrabber.getTriggerControlCount() """
    triggerControlCount = property (getTriggerControlCount, None, None, None)


# Register CameraSettingsFrameGrabber in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.CameraSettingsFrameGrabber_swigregister(CameraSettingsFrameGrabber)

class CameraDescriptionBase(ComponentCollection):
    r"""
     A base class to describe a camera (**Device** specific interface layout only).
     A camera description object provides an abstract way to prepare the capture
     device (e.g. a frame grabber) for the connected imaging device (e.g. a camera).

     By selecting one of the available camera descriptions the underlying hardware
     will use the information provided in the camera description to prepare the
     image capture. Therefore it is crucial to select a camera description
     that matches the connected video signal as close as possible. If no description
     for the camera or imaging device connected is available a new description
     should be generated from one of the existing ones. This can be achieved by calling
     the function **mvIMPACT::acquire::CameraDescriptionBase::copyDescription**. A new
     camera description with the name that is passed to the function will be created.

     Notes: 
     The name must be unique. There can't be two descriptions with the same name
     belonging to the same generic class (i.e. *'Standard'* or *'CameraLink'*(R)). However
     it's perfectly legal to have a camera description for standard analogue video signals
     and one for e.g. CameraLink(R) signals with the same name.

     This new description will be an exact copy of the one the copy function has been
     executed for. After creation this description can be selected e.g. by setting the
     property **mvIMPACT::acquire::CameraSettingsFrameGrabber::type** to the name of the
     new description.


     Please note that the name passed to the property **mvIMPACT::acquire::CameraSettingsFrameGrabber::type**
     does **NOT** exactly correspond to the name assigned to the new camera description.
     It is a combination of the class the camera is belonging to (e.g. *'Standard')* and the actual name.
     So to select a camera description the name must be build from the return value of a call to
     **mvIMPACT::acquire::CameraDescriptionBase::getClassName**, an underscore ('_') and the
     actual name of the description: <class name>_<desc. name>

     Example: For a standard description with the name *'MyCam'* the full name would be *'Standard_MyCam'*.

    If: DOXYGEN_CPP_DOCUMENTATION {

    .. code-block:: c++

         #include mvIMPACT_CPP/mvIMPACT_acquire.h
         #include iostream

         using namespace std;

         //-----------------------------------------------------------------------------
         int main( int argc, char* argv[] )
         //-----------------------------------------------------------------------------
         {
           mvIMPACT::acquire::DeviceManager devMgr;
           mvIMPACT::acquire::Device* pDev = devMgr[0];
           if( !pDev )
           {
             cout < "No device found" < endl;
             return 1;
           }

           try
           {
             // the next line will raise an exception if this device does not
             // support camera descriptions (e.g. if it is a USB camera rather than a frame grabber)
             mvIMPACT::acquire::CameraDescriptionManager cdm( pDev );
             mvIMPACT::acquire::CameraDescriptionStandard* pCam = cdm.cameraDescriptionStandard( "Generic" );
             pCam-copyDescription( "MyCam" );
             // Get access to the newly created description
             mvIMPACT::acquire::CameraDescriptionStandard* pMyCam = cdm.cameraDescriptionStandard( "MyCam" );
             // Modify something
             pMyCam-videoStandard.write( vsRS170 );
             pMyCam-scanStandard.write( ssITU601 );
             // now save the description to make it available in all future sessions
             pMyCam-exportDescription();
             // select the newly created description
             mvIMPACT::acquire::CameraSettingsFrameGrabber cs( pDev );
             // the name for this property is always a combination of the class the camera
             // description is belonging to and the actual name:
             cs.type.writeS( pMyCam-getClassName() + "_" + pMyCam-name.read() );
           }
           catch( const ImpactAcquireException e )
           {
             cout < "An exception occurred: " < e.getErrorString() < endl;
             return 1;
           }
           return 0;
         }
    }Else if: DOXYGEN_JAVA_DOCUMENTATION {

    .. code-block:: c++

         import mvIMPACT.acquire.*;

         //-----------------------------------------------------------------------------
         public class CameraDescriptionManagerExample
         //-----------------------------------------------------------------------------
         {
           //=============================================================================
           //=== Static member functions =================================================
           //=============================================================================
           static
           {
             try
             {
               System.loadLibrary( "mvIMPACT_Acquire.java" );
             }
             catch( UnsatisfiedLinkError e )
             {
               System.err.println( "Native code library failed to load. Make sure the 'mvIMPACT_Acquire.java' library can be found in the systems search path.\n" + e );
               System.exit( 1 );
             }
           }

           //-----------------------------------------------------------------------------
           public static void main( String[] args )
           //-----------------------------------------------------------------------------
           {
             DeviceManager devMgr = new DeviceManager();
             Device pDev = mvIMPACT.acquire.examples.helper.DeviceAccess.getDeviceFromUserInput( devMgr );
             if( pDev == null )
             {
               System.out.print( "Unable to continue!" );
               mvIMPACT.acquire.examples.helper.DeviceAccess.waitForENTER();
               System.exit( 1 );
             }

             System.out.println( "Initialising the device. This might take some time..." );
             try
             {
               pDev.open();
             }
             catch( ImpactAcquireException e )
             {
               // this e.g. might happen if the same device is already opened in another process...
               System.out.println( "An error occurred while opening device " + pDev.getSerial().read() +
                                   "(error code: " + e.getMessage() + ")." );
               mvIMPACT.acquire.examples.helper.DeviceAccess.waitForENTER();
               System.exit( 1 );
             }

             try
             {
               // the next line will raise an exception if this device does not
               // support camera descriptions (e.g. if it is a USB camera rather than a frame grabber)
               CameraDescriptionManager cdm = new CameraDescriptionManager( pDev );
               CameraDescriptionStandard pCam = cdm.cameraDescriptionStandard( "Generic" );
               pCam.copyDescription( "MyCam" );
               // Get access to the newly created description
               CameraDescriptionStandard pMyCam = cdm.cameraDescriptionStandard( "MyCam" );
               // Modify something
               pMyCam.getVideoStandard().write( TVideoStandard.vsRS170 );
               pMyCam.getScanStandard().write( TScanStandard.ssITU601 );
               // now save the description to make it available in all future sessions
               pMyCam.exportDescription();
               // select the newly created description
               CameraSettingsFrameGrabber cs = new CameraSettingsFrameGrabber( pDev );
               // the name for this property is always a combination of the class the camera
               // description is belonging to and the actual name:
               cs.getType().writeS( pMyCam.getClassName() + "_" + pMyCam.getName().read() );
             }
             catch( ImpactAcquireException e )
             {
               System.out.println( "An error occurred: " + e.getMessage() + "." );
               mvIMPACT.acquire.examples.helper.DeviceAccess.waitForENTER();
               System.exit( 1 );
             }
           }
         }
    }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

    .. code-block:: c++

        try:
          # the next line will raise an exception if this device does not
          # support camera descriptions (e.g. if it is a USB camera rather than a frame grabber)
          cdm = acquire.CameraDescriptionManager(pDev)
          pCam = cdm.cameraDescriptionStandard("Generic")
          pCam.copyDescription("MyCam")
          # Get access to the newly created description
          pMyCam = cdm.cameraDescriptionStandard("MyCam")
          # Modify something
          pMyCam.videoStandard.write(acquire.vsRS170)
          pMyCam.scanStandard.write(acquire.ssITU601)
          # now save the description to make it available in all future sessions
          pMyCam.exportDescription()
          # select the newly created description
          cs = acquire.CameraSettingsFrameGrabber(pDev)
          # the name for this property is always a combination of the class the camera
          # description is belonging to and the actual name:
          cs.type.writeS(pMyCam.getClassName() + "_" + pMyCam.name.readS())
        except Exception as e:
          print("An exception occurred: " + e.getErrorString())
    }

     This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
     **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

    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

    def getClassName(self):
        r"""
        Returns the class this description is belonging to.
        :rtype: string
        :return: The class this description is belonging to.
        """
        return lib_mvIMPACT_acquire.CameraDescriptionBase_getClassName(self)

    def copyDescription(self, newName):
        r"""
         Creates a new camera description list as a copy of the current one.
         This function can be used to create a new camera description list. It will create
         a deep copy of the properties referenced by this camera description and will append the new description
         to the list of camera descriptions.

         Notes: 
         This will **NOT** store the new description permanently. After the driver has been
         closed, this data will be lost. To store the new list in a way that it will be available
         the next time the driver/device is opened again, **mvIMPACT::acquire::CameraDescriptionBase::exportDescription** must
         be called with the handle of the newly created description after this function.
         See also: 
         **mvIMPACT::acquire::CameraDescriptionBase::exportDescription**,

         **mvIMPACT::acquire::CameraDescriptionBase::importDescription**
         :rtype: int
         :return: 
             - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
             - **mvIMPACT::acquire::DEV_INPUT_PARAM_INVALID** if new name matches a description that is already
             existing.
             - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** or **mvIMPACT::acquire::TPROPHANDLING_ERROR** otherwise.

        :type newName: string
        :param newName: [in] The name for the newly created camera description. This name **MUST** NOT match a description already existing.
        """
        return lib_mvIMPACT_acquire.CameraDescriptionBase_copyDescription(self, newName)

    def exportDescription(self):
        r"""
         Stores the current camera description on disc.
         This function can be used to store the current settings of a camera description
         permanently so that the next time the driver is initialized these settings are restored.

         When exporting a camera description a file in XML format will be written to disc. On
         Windows(R) camera descriptions will be stored under

        .. code-block:: c++

             %ALLUSERS%/Documents/MATRIX VISION/mvIMPACT acquire/CameraFiles
         or

        .. code-block:: c++

             %MVIMPACT_ACQUIRE_DATA_DIR%/CameraFiles
         which will point to the same folder), on Linux(R) this directory will be

         .. code-block:: c++

             /etc/matrix-vision/mvimpact-acquire/camerafiles
         while under other platforms these files will end up in the current working directory. This behaviour can be modified
         by writing the property **mvIMPACT::acquire::Device::customDataDirectory** before initialising the
         device.

         See also: 
         **mvIMPACT::acquire::CameraDescriptionBase::copyDescription**,

         **mvIMPACT::acquire::CameraDescriptionBase::importDescription**
         :rtype: int
         :return: 
             - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
             - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** or **mvIMPACT::acquire::TPROPHANDLING_ERROR** otherwise.
        """
        return lib_mvIMPACT_acquire.CameraDescriptionBase_exportDescription(self)

    def importDescription(self):
        r"""
         Updates a camera description with the data stored in a previous session or with the original default data.
         When importing a camera description the device driver will try to retrieve the parameters
         needed from a XML file. On Windows(R) camera descriptions MUST be stored under

        .. code-block:: c++

             %ALLUSERS%/Documents/MATRIX VISION/mvIMPACT acquire/CameraFiles
         or

        .. code-block:: c++

             %MVIMPACT_ACQUIRE_DATA_DIR%/CameraFiles
         which will point to the same folder), under Linux(R) this directory will be

         .. code-block:: c++

             /etc/matrix-vision/mvimpact-acquire/camerafiles
         while under other platforms these files MUST be located in the current working directory.
         This behaviour can be modified by writing the property **mvIMPACT::acquire::Device::customDataDirectory** before initialising the device.
         To get access to a XML description file within the application, these file must be copied to
         this directory **BEFORE** the device is initialized. During the initialisation process the
         device driver will process every file located under this location and will add them to
         the internal list of descriptions. Every camera located during this process and also descriptions
         created later on during the program operation can be selected via the property
         **mvIMPACT::acquire::CameraSettingsFrameGrabber::type**.

         Notes: 
         In order not to bloat the device driver with redundant data it's wise only to store the
         descriptions needed for the application to run under this location.


         Only camera descriptions supported by the capture device will be added to the device
         drivers internal list and will therefore be accessible via the
         **mvIMPACT::acquire::CameraDescriptionManager**.

         To restore the default values valid during the driver was initialized the function
         **mvIMPACT::acquire::ComponentCollection::restoreDefault** can be used as well.

         See also: 
         **mvIMPACT::acquire::CameraDescriptionBase::exportDescription**,

            mvIMPACT::acquire::CameraDescriptionBase::copyDescription
         :rtype: int
         :return: 
             - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
             - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** or **mvIMPACT::acquire::TPROPHANDLING_ERROR** otherwise.
        """
        return lib_mvIMPACT_acquire.CameraDescriptionBase_importDescription(self)
    name = property(lib_mvIMPACT_acquire.CameraDescriptionBase_name_get, doc=r""" A string property **read-only** containing the name of this camera description list.""")
    videoOutput = property(lib_mvIMPACT_acquire.CameraDescriptionBase_videoOutput_get, doc=r"""
    An enumerated integer property defining the type of video outputs this camera offers.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraOutput**.

    Notes: 
    This property will be **(read-only)** for camera descriptions of type
    **mvIMPACT::acquire::CameraDescriptionCameraLink** and **mvIMPACT::acquire::CameraDescriptionSDI**
    as for these camera types the video output depends on certain other parameters according to the
    corresponding standard.
    """)
    interlacedType = property(lib_mvIMPACT_acquire.CameraDescriptionBase_interlacedType_get, doc=r"""
    An enumerated integer property defining how the camera transmits image data.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraInterlacedType**.
    """)
    aoiHeight = property(lib_mvIMPACT_acquire.CameraDescriptionBase_aoiHeight_get, doc=r""" An integer property defining the number of active lines to capture from the camera.""")
    aoiStartX = property(lib_mvIMPACT_acquire.CameraDescriptionBase_aoiStartX_get, doc=r""" An integer property defining the X-offset in pixels to the first active pixel to capture.""")
    aoiStartY = property(lib_mvIMPACT_acquire.CameraDescriptionBase_aoiStartY_get, doc=r""" An integer property defining the Y-offset in lines to the first active line to capture.""")
    aoiWidth = property(lib_mvIMPACT_acquire.CameraDescriptionBase_aoiWidth_get, doc=r""" An integer property defining the number of active pixels to capture per line.""")

    r""" \brief A string property \b (read-only) which holds the class this description is belonging to. See mvIMPACT.acquire.CameraDescriptionBase.getClassName() """
    className = property (getClassName, None, None, None)

    __swig_destroy__ = lib_mvIMPACT_acquire.delete_CameraDescriptionBase

# Register CameraDescriptionBase in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.CameraDescriptionBase_swigregister(CameraDescriptionBase)

class CameraDescriptionDigitalBase(CameraDescriptionBase):
    r"""
    A base class to describe an arbitrary digital camera signal(**Device** specific interface layout only).
    This class provides access to all settings specific for digital video signals.

    Notes: This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
    **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

    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
    bitsPerPixel = property(lib_mvIMPACT_acquire.CameraDescriptionDigitalBase_bitsPerPixel_get, doc=r""" An integer property defining the number of bits per pixel currently transmitted by this camera.""")
    format = property(lib_mvIMPACT_acquire.CameraDescriptionDigitalBase_format_get, doc=r"""
    An enumerated integer property defining the data format the camera is sending image data.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraDataFormat**.
    """)
    bayerParity = property(lib_mvIMPACT_acquire.CameraDescriptionDigitalBase_bayerParity_get, doc=r"""
    An enumerated integer property defining the start pixel for a camera delivering an unconverted bayer image.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBayerMosaicParity**.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_CameraDescriptionDigitalBase

# Register CameraDescriptionDigitalBase in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.CameraDescriptionDigitalBase_swigregister(CameraDescriptionDigitalBase)

class CameraDescriptionSDI(CameraDescriptionDigitalBase):
    r"""
    A base class to describe a SDI(Serial Digital Interface) camera signal (**Device** specific interface layout only).
    This class provides access to all settings specific for SDI video signals.

    Notes: This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
    **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

    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
    videoStandard = property(lib_mvIMPACT_acquire.CameraDescriptionSDI_videoStandard_get, doc=r"""
    An enumerated integer property for defining the video standard this camera is compliant with.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TVideoStandard**.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_CameraDescriptionSDI

# Register CameraDescriptionSDI in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.CameraDescriptionSDI_swigregister(CameraDescriptionSDI)

class CameraDescriptionDigitalBase2(CameraDescriptionDigitalBase):
    r"""
    A base class to describe an arbitrary digital camera signal(**Device** specific interface layout only).
    This class provides access to all settings specific for digital video signals.

    Notes: This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
    **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

    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
    pixelsPerCycle = property(lib_mvIMPACT_acquire.CameraDescriptionDigitalBase2_pixelsPerCycle_get, doc=r"""
    An integer property defining the number of pixels per clock cycle transmitted by this camera.
    This corresponds the number of taps used by the camera in the described configuration.
    """)
    scanMode = property(lib_mvIMPACT_acquire.CameraDescriptionDigitalBase2_scanMode_get, doc=r"""
    An enumerated integer property providing information about the sensor of this camera.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraScanMode**.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_CameraDescriptionDigitalBase2

# Register CameraDescriptionDigitalBase2 in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.CameraDescriptionDigitalBase2_swigregister(CameraDescriptionDigitalBase2)

class CameraDescriptionCameraLink(CameraDescriptionDigitalBase2):
    r"""
    A class to describe a CameraLink(R) compliant camera(**Device** specific interface layout only).
    This class provides access to all settings specific for CameraLink(R) compliant cameras.

    Notes: This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
    **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

    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
    dataValid = property(lib_mvIMPACT_acquire.CameraDescriptionCameraLink_dataValid_get, doc=r"""
    An enumerated integer property defining the way this camera transmits the data valid (**DVAL)** signal.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraLinkDataValidMode**.
    """)
    tapsXGeometry = property(lib_mvIMPACT_acquire.CameraDescriptionCameraLink_tapsXGeometry_get, doc=r"""
    An enumerated integer property defining the way this camera transmits the pixel data in X direction.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraTapsXGeometry**.
    """)
    tapsYGeometry = property(lib_mvIMPACT_acquire.CameraDescriptionCameraLink_tapsYGeometry_get, doc=r"""
    An enumerated integer property defining the way this camera transmits the pixel data in Y direction.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraTapsYGeometry**.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_CameraDescriptionCameraLink

# Register CameraDescriptionCameraLink in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.CameraDescriptionCameraLink_swigregister(CameraDescriptionCameraLink)

class CameraDescriptionDigital(CameraDescriptionDigitalBase2):
    r"""
    A class to describe a non-standard digital video signal(**Device** specific interface layout only).
    This class provides access to all settings specific for non-standard digital video signals.

    Notes: This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
    **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

    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
    frameSync = property(lib_mvIMPACT_acquire.CameraDescriptionDigital_frameSync_get, doc=r"""
    An enumerated integer property defining the edge valid for the frame sync signal of this camera.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraExternalSyncEdge**.

    Notes: 
    Not every value defined by this enumeration will be supported by this property. Check which values
    are available by reading the properties translation dictionary with
    the functions **mvIMPACT::acquire::PropertyICameraExternalSyncEdge::getTranslationDictString** and
    **mvIMPACT::acquire::PropertyICameraExternalSyncEdge::getTranslationDictValue**
    If: DOXYGEN_CPP_DOCUMENTATION {
    C++ offers the more efficient function **mvIMPACT::acquire::PropertyICameraExternalSyncEdge::getTranslationDict**
    in addition to the functions mentioned above.
    }
    """)
    lineSync = property(lib_mvIMPACT_acquire.CameraDescriptionDigital_lineSync_get, doc=r"""
    An enumerated integer property defining the edge valid for the line sync. of this camera.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraExternalSyncEdge**.

    Notes: 
    Not every value defined by this enumeration will be supported by this property. Check which values
    are available by reading the properties translation dictionary with
    the functions **mvIMPACT::acquire::PropertyICameraExternalSyncEdge::getTranslationDictString** and
    **mvIMPACT::acquire::PropertyICameraExternalSyncEdge::getTranslationDictValue**
    If: DOXYGEN_CPP_DOCUMENTATION {
    C++ offers the more efficient function **mvIMPACT::acquire::PropertyICameraExternalSyncEdge::getTranslationDict**
    in addition to the functions mentioned above.
    }
    """)
    pixelClk = property(lib_mvIMPACT_acquire.CameraDescriptionDigital_pixelClk_get, doc=r"""
    An enumerated integer property defining the edge valid for the pixel clock of this camera.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraExternalSyncEdge**.

    Notes: 
    Not every value defined by this enumeration will be supported by this property. Check which values
    are available by reading the properties translation dictionary with
    the functions **mvIMPACT::acquire::PropertyICameraExternalSyncEdge::getTranslationDictString** and
    **mvIMPACT::acquire::PropertyICameraExternalSyncEdge::getTranslationDictValue**
    If: DOXYGEN_CPP_DOCUMENTATION {
    C++ offers the more efficient function **mvIMPACT::acquire::PropertyICameraExternalSyncEdge::getTranslationDict**
    in addition to the functions mentioned above.
    }
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_CameraDescriptionDigital

# Register CameraDescriptionDigital in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.CameraDescriptionDigital_swigregister(CameraDescriptionDigital)

class CameraDescriptionStandardBase(CameraDescriptionBase):
    r"""
    An internal base class to describe standard analogue video cameras(**Device** specific interface layout only).
    Instances of this class can't be constructed directly. Use one of the derived types.

    Notes: This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
    **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

    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
    videoStandard = property(lib_mvIMPACT_acquire.CameraDescriptionStandardBase_videoStandard_get, doc=r"""
    An enumerated integer property for defining the video standard this camera is compliant with.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TVideoStandard**.
    """)
    scanStandard = property(lib_mvIMPACT_acquire.CameraDescriptionStandardBase_scanStandard_get, doc=r"""
    An enumerated integer property defining the scan standard this camera is compliant with.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TScanStandard**.
    """)
    scanRate_kHz = property(lib_mvIMPACT_acquire.CameraDescriptionStandardBase_scanRate_kHz_get, doc=r""" An integer property containing the scan rate in kHz needed to driver the AD converter of the capture device with to convert the video signal properly.""")
    startField = property(lib_mvIMPACT_acquire.CameraDescriptionStandardBase_startField_get, doc=r"""
    An enumerated integer property containing information about the first field transmitted by a camera.
    A camera might transmit either the odd or the even field of an interlaced video signal first.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TAcquisitionField**.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_CameraDescriptionStandardBase

# Register CameraDescriptionStandardBase in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.CameraDescriptionStandardBase_swigregister(CameraDescriptionStandardBase)

class CameraDescriptionStandard(CameraDescriptionStandardBase):
    r"""
    A class describing analogue standard compliant video cameras(**Device** specific interface layout only).
    Notes: This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
    **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

    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__ = lib_mvIMPACT_acquire.delete_CameraDescriptionStandard

# Register CameraDescriptionStandard in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.CameraDescriptionStandard_swigregister(CameraDescriptionStandard)

class CameraDescriptionNonStandard(CameraDescriptionStandardBase):
    r"""
    A class describing non-standard video cameras(**Device** specific interface layout only).
    This class can be used to describe a non-standard analogue video camera. A camera
    considered as non-standard when it is not compliant with one of the defined
    video standards like e.g. CCIR.

    Notes: This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
    **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

    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
    lineFrequency_Hz = property(lib_mvIMPACT_acquire.CameraDescriptionNonStandard_lineFrequency_Hz_get, doc=r""" An integer property containing the line frequency of this camera in Hertz.""")
    VDOutput = property(lib_mvIMPACT_acquire.CameraDescriptionNonStandard_VDOutput_get, doc=r"""
    An enumerated integer property defining whether the vertical sync. information is part of the video signal or transmitted via a separate wire.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraExternalSyncEdge**.
    """)
    HDOutput = property(lib_mvIMPACT_acquire.CameraDescriptionNonStandard_HDOutput_get, doc=r"""
    An enumerated integer property defining whether the horizontal sync. information is part of the video signal or transmitted via a separate wire.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraExternalSyncEdge**.
    """)
    syncOutput = property(lib_mvIMPACT_acquire.CameraDescriptionNonStandard_syncOutput_get, doc=r"""
    An enumerated integer property for RGB cameras containing information where the sync. information is transmitted.
    This can either be within one of the three color components or on a separate wire.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraExternalSyncOutput**.
    """)
    pixelClockOutput = property(lib_mvIMPACT_acquire.CameraDescriptionNonStandard_pixelClockOutput_get, doc=r"""
    An enumerated integer property containing information whether the pixel clock is part of the video signal or not.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TCameraExternalSyncEdge**.
    """)
    fieldGateMode = property(lib_mvIMPACT_acquire.CameraDescriptionNonStandard_fieldGateMode_get, doc=r"""
    An enumerated integer property defining the clamp mode for this camera description.
    This defines how the field detection(ODD/EVEN) is done.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TFieldGateMode**.
    """)
    fieldGateStart = property(lib_mvIMPACT_acquire.CameraDescriptionNonStandard_fieldGateStart_get, doc=r"""
    An integer property defining the start position (in pixel clocks) of the field gate detection area.
    This will only need modification in very rare cases.
    """)
    fieldGateWidth = property(lib_mvIMPACT_acquire.CameraDescriptionNonStandard_fieldGateWidth_get, doc=r"""
    An integer property defining the width (in pixel clocks) of the field gate detection area.
    This will only need modification in very rare cases.
    """)
    clampMode = property(lib_mvIMPACT_acquire.CameraDescriptionNonStandard_clampMode_get, doc=r"""
    An enumerated integer property defining the clamp mode for this camera description.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TClampMode**.
    """)
    clampStart_us = property(lib_mvIMPACT_acquire.CameraDescriptionNonStandard_clampStart_us_get, doc=r"""
    The clamp start position defines where in each line of the video signal the frame grabber assumes the black level position.
    This will only need modification in very rare cases.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_CameraDescriptionNonStandard

# Register CameraDescriptionNonStandard in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.CameraDescriptionNonStandard_swigregister(CameraDescriptionNonStandard)

class CameraDescriptionManager(object):
    r"""
     Grants access to camera description objects(**Device** specific interface layout only).
     This class provides access to the various camera description objects. Each
     device recognizes a different set of camera descriptions. E.g. a digital
     frame grabber will not be able to work with analogue cameras. Each camera description
     class will be derived from **mvIMPACT::acquire::CameraDescriptionBase**.

     Notes: 
     Please note that instances of this class will **ONLY** list camera descriptions
     that have once been selected by the property **mvIMPACT::acquire::CameraSettingsFrameGrabber::type**
     at runtime. This is to save memory. A complete list of camera descriptions
     available for the current device therefore can only be queried by reading the
     the translation dictionary of the property **mvIMPACT::acquire::CameraSettingsFrameGrabber::type**.

    If: DOXYGEN_CPP_DOCUMENTATION {

    .. code-block:: c++

         #include mvIMPACT_CPP/mvIMPACT_acquire.h
         #include algorithm
         #include iostream

         using namespace std;
         using namespace mvIMPACT::acquire;

         //-----------------------------------------------------------------------------
         templateclass T
         class DisplayDictEntry : public unary_functionpair<string, T, void
         //-----------------------------------------------------------------------------
         {
         public:
           void operator()( const pairstring, T data ) const
           {
             cout < "  [" < data.second < "]: " < data.first < endl;
           }
         };

         //-----------------------------------------------------------------------------
         // lists all available camera descriptions for a certain device
         int main( int argc, char* argv[] )
         //-----------------------------------------------------------------------------
         {
           DeviceManager devMgr;
           Device* pDev = devMgr[0];
           if( !pDev )
           {
             cout < "No device found" < endl;
             return 0;
           }

           // display the name of every camera description available for this device.
           // this might be less than the number of camera descriptions available on the system as e.g.
           // an analog frame grabber can't use descriptions for digital cameras
           CameraSettingsFrameGrabber cs( pDev );
           std::stringstd::string, int vAvailableDescriptions;
           cs.type.getTranslationDict( vAvailableDescriptions );
           cout < endl < "Available camera descriptions: " < vAvailableDescriptions.size() < endl
                < "----------------------------------" < endl;
           for_each( vAvailableDescriptions.begin(), vAvailableDescriptions.end(), DisplayDictEntryint() )

           // list all descriptions that already have been selected at least once
           CameraDescriptionManager camMgr( pDev );
           unsigned int camCnt = camMgr.getCLCameraDescriptionCount();
           cout < "Available CL descriptions: " < camCnt < endl;
           for( unsigned int a=0; acamCnt; a++ )
           {
             cout < "  " < camMgr.cameraDescriptionCameraLink( a )-name.read() < endl;
           }
           camCnt = camMgr.getStandardCameraDescriptionCount();
           cout < "Available Std descriptions: " < camCnt < endl;
           for( unsigned int b=0; bcamCnt; b++ )
           {
             cout < "  " < camMgr.cameraDescriptionStandard( b )-name.read() < endl;
           }
           camCnt = camMgr.getNonStandardCameraDescriptionCount();
           cout < "Available NonStd descriptions: " < camCnt < endl;
           for( unsigned int c=0; ccamCnt; c++ )
           {
             cout < "  " < camMgr.cameraDescriptionNonStandard( c )-name.read() < endl;
           }
           return 0;
         }
    }Else if: DOXYGEN_JAVA_DOCUMENTATION {

    .. code-block:: c++

        import mvIMPACT.acquire.*;

        //-----------------------------------------------------------------------------
        public class ListCameraDescriptions
        //-----------------------------------------------------------------------------
        {
          static
          {
            try
            {
              System.loadLibrary( "mvIMPACT_Acquire.java" );
            }
            catch( UnsatisfiedLinkError e )
            {
              System.err.println( "Native code library failed to load. Make sure the 'mvIMPACT_Acquire.java' library can be found in the systems search path.\n" + e );
              System.exit( 1 );
            }
          }

          //-----------------------------------------------------------------------------
          public static void main( String[] args )
          //-----------------------------------------------------------------------------
          {
            DeviceManager devMgr = new DeviceManager();
            Device pDev = mvIMPACT.acquire.examples.helper.DeviceAccess.getDeviceFromUserInput( devMgr );
            if( pDev == null )
            {
              System.out.print( "Unable to continue!" );
              mvIMPACT.acquire.examples.helper.DeviceAccess.waitForENTER();
              System.exit( 1 );
            }

            System.out.println( "Initialising the device. This might take some time..." );
            try
            {
              pDev.open();
            }
            catch( ImpactAcquireException e )
            {
              // this e.g. might happen if the same device is already opened in another process...
              System.out.println( "An error occurred while opening device " + pDev.getSerial().read() +
                                  "(error code: " + e.getMessage() + ")." );
              mvIMPACT.acquire.examples.helper.DeviceAccess.waitForENTER();
              System.exit( 1 );
            }

            // display the name of every camera description available for this device.
            // this might be less than the number of camera descriptions available on the system as e.g.
            // an analog frame grabber can't use descriptions for digital cameras
            CameraSettingsFrameGrabber cs = new CameraSettingsFrameGrabber(pDev);
            StringIntVector vAvailableDescriptions = new StringIntVector();
            cs.getType().getTranslationDict( vAvailableDescriptions );
            System.out.println( String.format( "\nAvailable camera descriptions: %d", vAvailableDescriptions.size() ) );
            System.out.println( "----------------------------------" );

            for( int i=0; ivAvailableDescriptions.size(); i++ )
            {
                System.out.println( String.format( "[%d]: %s", vAvailableDescriptions.get( i ).getSecond(), vAvailableDescriptions.get( i ).getFirst() ) );
            }

            // list all descriptions that already have been selected at least once
            CameraDescriptionManager camMgr = new CameraDescriptionManager( pDev );
            long camCnt = camMgr.getCLCameraDescriptionCount();
            System.out.println( String.format( "Available CL descriptions: %d", camCnt ) );
            for( long a=0; acamCnt; a++ )
            {
              System.out.println( "  " + camMgr.cameraDescriptionCameraLink( a ).getName().read() );
            }
            camCnt = camMgr.getStandardCameraDescriptionCount();
            System.out.println( String.format( "Available Std descriptions: %d", camCnt ) );
            for( long b=0; bcamCnt; b++ )
            {
              System.out.println( "  " + camMgr.cameraDescriptionStandard( b ).getName().read() );
            }
            camCnt = camMgr.getNonStandardCameraDescriptionCount();
            System.out.println( String.format( "Available NonStd descriptions: %d", camCnt ) );
            for( long c=0; ccamCnt; c++ )
            {
              System.out.println( "  " + camMgr.cameraDescriptionNonStandard( c ).getName().read() );
            }
          }
        }
    }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

    .. code-block:: c++

          # ...
          # display the name of every camera description available for this device.
          # this might be less than the number of camera descriptions available on the system as e.g.
          # an analog frame grabber can't use descriptions for digital cameras
          cs = acquire.CameraSettingsFrameGrabber(pDev)
          availableDescriptions = []

          cs.type.getTranslationDict(availableDescriptions)
          print()
          print("Available camera descriptions: " + str(availableDescriptions.size()))
          print("----------------------------------")

          for description in availableDescriptions:
              print(description)

          # list all descriptions that already have been selected at least once
          camMgr = acquire.CameraDescriptionManager(pDev)
          camCnt = camMgr.getCLCameraDescriptionCount()
          print("Available CL descriptions: " + str(camCnt))
          for a in range(camCnt):
              print("  " + camMgr.cameraDescriptionCameraLink(a).name.readS())

          camCnt = camMgr.getStandardCameraDescriptionCount()
          print("Available Std descriptions: " + str(camCnt))
          for b in range(camCnt):
              print("  " < camMgr.cameraDescriptionStandard(b).name.readS())

          camCnt = camMgr.getNonStandardCameraDescriptionCount()
          print("Available NonStd descriptions: " + str(camCnt))
          for c in range(camCnt):
            print("  " < camMgr.cameraDescriptionNonStandard(c).name.readS())
    }


     This class will only be available for frame grabber devices. For other devices
     the class constructor will raise an exception.

     This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
     **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

    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"""
        *Overload 1:*
         Constructs a new **mvIMPACT::acquire::CameraDescriptionManager** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire:**:>DeviceManager object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::CameraDescriptionManager** from an existing one.
        :type src: :py:class:`CameraDescriptionManager`
        :param src: A constant reference to the **mvIMPACT::acquire::CameraDescriptionManager** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.CameraDescriptionManager_swiginit(self, lib_mvIMPACT_acquire.new_CameraDescriptionManager(*args))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_CameraDescriptionManager

    def getCLCameraDescriptionCount(self):
        r""" Returns the number of CameraLink(R) camera descriptions currently available for the device that constructed this instance of the class."""
        return lib_mvIMPACT_acquire.CameraDescriptionManager_getCLCameraDescriptionCount(self)

    def cameraDescriptionCameraLink(self, *args):
        r"""
        *Overload 1:*
         Returns a pointer to a **mvIMPACT::acquire::CameraDescriptionCameraLink** object specifying the camera description found at the given index in the camera description managers internal list.
         If: DOXYGEN_CPP_DOCUMENTATION {
         If the index is either equal or higher than the number of CameraLink(R) camera descriptions

         detected for this device a STL out_of_range exception will be thrown.
         }

        :type index: int
        :param index: [in] The index of the camera description to return

        |

        *Overload 2:*
         Returns a pointer to a **mvIMPACT::acquire::CameraDescriptionCameraLink** object specifying the camera description with the given name in the camera description managers internal list.
         :rtype: :py:class:`CameraDescriptionCameraLink`
         :return: 
             - a pointer to a **mvIMPACT::acquire::CameraDescriptionCameraLink** object specifying the camera
             description with the given name in the camera description managers internal list if a camera
             description with *name* is available.
             - an invalid pointer or reference otherwise.

        :type name: string
        :param name: [in] The name of the camera description. This can either be the name of the list like e.g. 'CameraLink_Generic' or the value of the property 'name' of this description like e.g. 'Generic'.
        """
        return lib_mvIMPACT_acquire.CameraDescriptionManager_cameraDescriptionCameraLink(self, *args)

    def getSDICameraDescriptionCount(self):
        r""" Returns the number of SDI camera descriptions currently available for the device that constructed this instance of the class."""
        return lib_mvIMPACT_acquire.CameraDescriptionManager_getSDICameraDescriptionCount(self)

    def cameraDescriptionSDI(self, *args):
        r"""
        *Overload 1:*
         Returns a pointer to a **mvIMPACT::acquire::CameraDescriptionSDI** object specifying the camera description found at the given index in the camera description managers internal list.
         If: DOXYGEN_CPP_DOCUMENTATION {
         If the index is either equal or higher than the number of SDI camera descriptions

         detected for this device a STL out_of_range exception will be thrown.
         }

        :type index: int
        :param index: [in] The index of the camera description to return

        |

        *Overload 2:*
         Returns a pointer to a **mvIMPACT::acquire::CameraDescriptionSDI** object specifying the camera description with the given name in the camera description managers internal list.
         :rtype: :py:class:`CameraDescriptionSDI`
         :return: 
             - a pointer to a **mvIMPACT::acquire::CameraDescriptionSDI** object specifying the camera
             description with the given name in the camera description managers internal list if a camera
             description with *name* is available.
             - an invalid pointer or reference otherwise.

        :type name: string
        :param name: [in] The name of the camera description. This can either be the name of the list like e.g. 'CameraLink_Generic' or the value of the property 'name' of this description like e.g. 'Generic'.
        """
        return lib_mvIMPACT_acquire.CameraDescriptionManager_cameraDescriptionSDI(self, *args)

    def getDigitalCameraDescriptionCount(self):
        r""" Returns the number of non-standard digital camera descriptions currently available for the device that constructed this instance of the class."""
        return lib_mvIMPACT_acquire.CameraDescriptionManager_getDigitalCameraDescriptionCount(self)

    def cameraDescriptionDigital(self, *args):
        r"""
        *Overload 1:*
         Returns a pointer to a **mvIMPACT::acquire::CameraDescriptionDigital** object specifying the camera description found at the given index in the camera description managers internal list.
         If: DOXYGEN_CPP_DOCUMENTATION {
         If the index is either equal or higher than the number of non-standard digital camera descriptions

         detected for this device a STL out_of_range exception will be thrown.
         }

        :type index: int
        :param index: [in] The index of the camera description to return

        |

        *Overload 2:*
         Returns a pointer to a **mvIMPACT::acquire::CameraDescriptionDigital** object specifying the camera description with the given name in the camera description managers internal list.
         :rtype: :py:class:`CameraDescriptionDigital`
         :return: 
             - a pointer to a **mvIMPACT::acquire::CameraDescriptionDigital** object specifying the camera
             description with the given name in the camera description managers internal list if a camera
             description with *name* is available.
             - an invalid pointer or reference otherwise.

        :type name: string
        :param name: [in] The name of the camera description. This can either be the name of the list like e.g. 'Digital_Generic' or the value of the property 'name' of this description like e.g. 'Generic'.
        """
        return lib_mvIMPACT_acquire.CameraDescriptionManager_cameraDescriptionDigital(self, *args)

    def getStandardCameraDescriptionCount(self):
        r""" Returns the number of standard camera descriptions currently available for the device that constructed this instance of the class."""
        return lib_mvIMPACT_acquire.CameraDescriptionManager_getStandardCameraDescriptionCount(self)

    def cameraDescriptionStandard(self, *args):
        r"""
        *Overload 1:*
         Returns a pointer to a **mvIMPACT::acquire::CameraDescriptionStandard** object specifying the camera description found at the given index in the camera description managers internal list.
         If: DOXYGEN_CPP_DOCUMENTATION {
         If the index is either equal or higher than the number of standard camera descriptions

         detected for this device a STL out_of_range exception will be thrown.
         }

        :type index: int
        :param index: [in] The index of the camera description to return

        |

        *Overload 2:*
         Returns a pointer to a **mvIMPACT::acquire::CameraDescriptionStandard** object specifying the camera description with the given name in the camera description managers internal list.
         :rtype: :py:class:`CameraDescriptionStandard`
         :return: 
             - a pointer to a **mvIMPACT::acquire::CameraDescriptionStandard** object specifying the camera
             description with the given name in the camera description managers internal list if a camera
             description with *name* is available.
             - an invalid pointer or reference otherwise.

        :type name: string
        :param name: [in] The name of the camera description. This can either be the name of the list like e.g. 'Standard_Generic' or the value of the property 'name' of this description like e.g. 'Generic'.
        """
        return lib_mvIMPACT_acquire.CameraDescriptionManager_cameraDescriptionStandard(self, *args)

    def getNonStandardCameraDescriptionCount(self):
        r""" Returns the number of non-standard camera descriptions currently available for the device that constructed this instance of the class."""
        return lib_mvIMPACT_acquire.CameraDescriptionManager_getNonStandardCameraDescriptionCount(self)

    def cameraDescriptionNonStandard(self, *args):
        r"""
        *Overload 1:*
         Returns a pointer to a **mvIMPACT::acquire::CameraDescriptionNonStandard** object specifying the camera description found at the given index in the camera description managers internal list.
         If: DOXYGEN_CPP_DOCUMENTATION {
         If the index is either equal or higher than the number of non-standard camera descriptions

         detected for this device a STL out_of_range exception will be thrown.
         }

        :type index: int
        :param index: [in] The index of the camera description to return

        |

        *Overload 2:*
         Returns a pointer to a **mvIMPACT::acquire::CameraDescriptionNonStandard** object specifying the camera description with the given name in the camera description managers internal list.
         :rtype: :py:class:`CameraDescriptionNonStandard`
         :return: 
             - a pointer to a **mvIMPACT::acquire::CameraDescriptionNonStandard** object specifying the camera
             description with the given name in the camera description managers internal list if a camera
             description with *name* is available.
             - an invalid pointer or reference otherwise.

        :type name: string
        :param name: [in] The name of the camera description. This can either be the name of the list like e.g. 'NonStandard_Generic' or the value of the property 'name' of this description like e.g. 'Generic'.
        """
        return lib_mvIMPACT_acquire.CameraDescriptionManager_cameraDescriptionNonStandard(self, *args)

    def getTotalCameraDescriptionCount(self):
        r"""
        Returns the total number camera descriptions currently available for the device that constructed this instance of the class.
        Since: 2.1.4
        """
        return lib_mvIMPACT_acquire.CameraDescriptionManager_getTotalCameraDescriptionCount(self)

    r""" \brief An integer property \b (read-only) which holds the number of CameraLink® camera descriptions currently available for the device that constructed this instance of the class. See mvIMPACT.acquire.CameraDescriptionManager.getCLCameraDescriptionCount() """
    cLCameraDescriptionCount = property (getCLCameraDescriptionCount, None, None, None)
    r""" \brief An integer property \b (read-only) which holds the number of non-standard digital camera descriptions currently available for the device that constructed this instance of the class. See mvIMPACT.acquire.CameraDescriptionManager.getDigitalCameraDescriptionCount() """
    digitalCameraDescriptionCount = property (getDigitalCameraDescriptionCount, None, None, None)
    r""" \brief An integer property \b (read-only) which holds the number of non-standard camera descriptions currently available for the device that constructed this instance of the class. See mvIMPACT.acquire.CameraDescriptionManager.getNonStandardCameraDescriptionCount() """
    nonStandardCameraDescriptionCount = property (getNonStandardCameraDescriptionCount, None, None, None)
    r""" \brief An integer property \b (read-only) which holds the number of standard camera descriptions currently available for the device that constructed this instance of the class. See mvIMPACT.acquire.CameraDescriptionManager.getStandardCameraDescriptionCount() """
    standardCameraDescriptionCount = property (getStandardCameraDescriptionCount, None, None, None)


# Register CameraDescriptionManager in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.CameraDescriptionManager_swigregister(CameraDescriptionManager)

class I2CControl(ComponentCollection):
    r"""
     Properties for accessing features belonging to the I2C control(**Device** specific interface layout only).
     Properties in this class will only be available if a device has a local I2C
     bus and this is configured for access from an application. Right now this is only
     the case for mvBlueFOX-MLC devices.

     **mvBlueFOX** **specific**:

     For mvBlueFOX devices
     - clock stretching is supported
     - bus master is supported

     The following I2C addresses will be blocked for access from an application:

     |i2c address|remark|
     |0x20-0x3F|-|
     |0x66-0x67|-|
     |0x90-0x91|mvBlueFOX-200w only|
     |0xA0-0xA3|-|
     |0xA6-0xA7|-|
     |0xBA-0xBB|mvBlueFOX-202a and mvBlueFOX-205 only|


    If: DOXYGEN_CPP_DOCUMENTATION {

    .. code-block:: c++

         I2CControl i2cc( pBF ); // assuming 'pBF' to be a valid 'Device*' instance to an mvBlueFOX device
         if( i2cc.I2COperationMode.isValid() )
         {
           // direct property access
           i2cc.I2CBufferLength.write( 0 );
           i2cc.I2COperationMode.write( I2ComRead );
           assert( ( i2cc.I2COperationExecute.call() == DMR_INVALID_PARAMETER )  "Unexpected driver behaviour" );
           assert( ( i2cc.I2COperationStatus.read() == I2CosNotEnoughData )  "Unexpected driver behaviour" );
           i2cc.I2CBufferLength.write( 1 );
           // assuming we write to an invalid address
           assert( ( i2cc.I2COperationExecute.call() == DMR_EXECUTION_FAILED )  "Unexpected driver behaviour" );
           assert( ( i2cc.I2COperationStatus.read() == I2CosFailure )  "Unexpected driver behaviour" );
           i2cc.I2COperationMode.write( I2ComWrite );
           i2cc.I2CBuffer.writeBinary( string() );
           assert( ( i2cc.I2COperationExecute.call() == DMR_INVALID_PARAMETER )  "Unexpected driver behaviour" );
           assert( ( i2cc.I2COperationStatus.read() == I2CosNotEnoughData )  "Unexpected driver behaviour" );
           {
             char binData[2] = { 'A', 'B' };
             i2cc.I2CBuffer.writeBinary( string(binData, sizeof(binData)) );
           }
           // assuming we write to an invalid address
           assert( ( i2cc.I2COperationExecute.call() == DMR_EXECUTION_FAILED )  "Unexpected driver behaviour" );
           assert( ( i2cc.I2COperationStatus.read() == I2CosFailure )  "Unexpected driver behaviour" );
           // Write some data. This will only work if several conditions are met:
           // - there is a device that can be written to at address 0xA6
           // - the sub-address 0x04 is valid
           // - the device is designed to work with 8 bit sub-addresses
           // - the device can deal with 9 bytes in a single command
           i2cc.I2CDeviceAddress.write( 0xA6 );
           i2cc.I2CDeviceSubAddress.write( 0x04 );
           i2cc.I2CDeviceSubAddressWidth.write( 8 );
           {
             char binData[9] = { 'D', 'E', 'A', 'D', ' ', 'B', 'E', 'E', 'F' };
             i2cc.I2CBuffer.writeBinary( string( binData, sizeof( binData ) ) );
           }
           i2cc.I2COperationMode.write( I2ComWrite );
           int I2COperationExecuteResult = i2cc.I2COperationExecute.call();
           if( I2COperationExecuteResult != DMR_NO_ERROR )
           {
             printf( "'I2COperationExecute' write failed. Return value: %s(%d).\n", ImpactAcquireException::getErrorCodeAsString( I2COperationExecuteResult ).c_str(), I2COperationExecuteResult );
           }
           printf( "'I2COperationStatus' after write: %s.\n", i2cc.I2COperationStatus.readS().c_str() );
           // Read some data. Similar condition as for write apply
           const int bytesToRead = 4;
           i2cc.I2CDeviceAddress.write( 0xA8 );
           i2cc.I2CDeviceSubAddress.write( 0x00 );
           i2cc.I2CDeviceSubAddressWidth.write( 8 );
           i2cc.I2CBufferLength.write( bytesToRead ); // read 'bytesToRead' bytes
           i2cc.I2COperationMode.write( I2ComRead );
           i2cc.I2COperationExecute.call();
           I2COperationExecuteResult = i2cc.I2COperationExecute.call();
           if( I2COperationExecuteResult != DMR_NO_ERROR )
           {
             printf( "'I2COperationExecute' read failed. Return value: %s(%d).\n", ImpactAcquireException::getErrorCodeAsString( I2COperationExecuteResult ).c_str(), I2COperationExecuteResult );
           }
           printf( "'I2COperationStatus' after read: %s.\n", i2cc.I2COperationStatus.readS().c_str() );
           if( i2cc.I2CBuffer.binaryDataBufferSize() != bytesToRead )
           {
             printf( "'I2CBuffer' reports %d bytes of data while %d bytes where expected.\n", i2cc.I2CBuffer.binaryDataBufferSize(), bytesToRead );
           }
           // usage of the convenience functions
           i2cc.I2CWrite( 0xA4, 0x00, 8, string("TEST") );
           const string i2cReadBuffer = i2cc.I2CRead( 0xA4, 0x00, 8, 4 );
         }
         else
         {
           printf( "I2CControl not available.\n" );
         }
    }Else if: DOXYGEN_JAVA_DOCUMENTATION {

    .. code-block:: c++

         import java.nio.ByteBuffer; // needed for binary data exchange!

         // more code and a class definition must follow here...

         I2CControl i2cc = new I2CControl( pDev ); // assuming 'pBF' to be a valid 'Device*' instance to an mvBlueFOX device
         if( i2cc.getI2COperationMode().isValid() )
         {
           // direct property access
           i2cc.getI2CBufferLength().write( 0 );
           i2cc.getI2COperationMode().write( TI2COperationMode.I2ComRead );
           assert i2cc.getI2COperationExecute().call() == TDMR_ERROR.DMR_INVALID_PARAMETER : "Unexpected driver behaviour";
           assert i2cc.getI2COperationStatus().read() == TI2COperationStatus.I2CosNotEnoughData : "Unexpected driver behaviour";
           i2cc.getI2CBufferLength().write( 1 );
           // assuming we write to an invalid address
           assert i2cc.getI2COperationExecute().call() == TDMR_ERROR.DMR_EXECUTION_FAILED : "Unexpected driver behaviour";
           assert i2cc.getI2COperationStatus().read() == TI2COperationStatus.I2CosFailure : "Unexpected driver behaviour";
           i2cc.getI2COperationMode().write( TI2COperationMode.I2ComWrite );
           {
             final int BUF_SIZE = 2;
             byte[] data_bytes = new byte[BUF_SIZE];
             data_bytes[0] = 'A';
             data_bytes[1] = 'B';
             ByteBuffer data = ByteBuffer.allocateDirect( BUF_SIZE );
             data.put( data_bytes );
             i2cc.getI2CBuffer().writeBinary( data );
           }
           // assuming we write to an invalid address
           assert i2cc.getI2COperationExecute().call() == TDMR_ERROR.DMR_EXECUTION_FAILED : "Unexpected driver behaviour";
           assert i2cc.getI2COperationStatus().read() == TI2COperationStatus.I2CosFailure : "Unexpected driver behaviour";
           // Write some data. This will only work if several conditions are met:
           // - there is a device that can be written to at address 0xA6
           // - the sub-address 0x04 is valid
           // - the device is designed to work with 8 bit sub-addresses
           // - the device can deal with 9 bytes in a single command
           i2cc.getI2CDeviceAddress().write( 0xA6 );
           i2cc.getI2CDeviceSubAddress().write( 0x04 );
           i2cc.getI2CDeviceSubAddressWidth().write( 8 );
           {
             final int BUF_SIZE = 9;
             byte[] data_bytes = new byte[BUF_SIZE];
             data_bytes[0] = 'D';
             data_bytes[0] = 'E';
             data_bytes[0] = 'A';
             data_bytes[0] = 'D';
             data_bytes[0] = ' ';
             data_bytes[0] = 'B';
             data_bytes[0] = 'E';
             data_bytes[0] = 'E';
             data_bytes[0] = 'F';
             ByteBuffer data = ByteBuffer.allocateDirect( BUF_SIZE );
             data.put( data_bytes );
             i2cc.getI2CBuffer().writeBinary( data );
           }
           i2cc.getI2COperationMode().write( TI2COperationMode.I2ComWrite );
           int I2COperationExecuteResult = i2cc.getI2COperationExecute().call();
           if( I2COperationExecuteResult != TDMR_ERROR.DMR_NO_ERROR )
           {
             System.out.println( String.format( "'I2COperationExecute' write failed. Return value: %s(%d).", ImpactAcquireException.getErrorCodeAsString( I2COperationExecuteResult ), I2COperationExecuteResult ) );
           }
           System.out.println( String.format( "'I2COperationStatus' after write: %s.", i2cc.getI2COperationStatus().readS() ) );
           // Read some data. Similar condition as for write apply
           final int bytesToRead = 4;
           i2cc.getI2CDeviceAddress().write( 0xA8 );
           i2cc.getI2CDeviceSubAddress().write( 0x00 );
           i2cc.getI2CDeviceSubAddressWidth().write( 8 );
           i2cc.getI2CBufferLength().write( bytesToRead ); // read 'bytesToRead' bytes
           i2cc.getI2COperationMode().write( TI2COperationMode.I2ComRead );
           i2cc.getI2COperationExecute().call();
           I2COperationExecuteResult = i2cc.getI2COperationExecute().call();
           if( I2COperationExecuteResult != TDMR_ERROR.DMR_NO_ERROR )
           {
             System.out.println( String.format( "'I2COperationExecute' read failed. Return value: %s(%d).", ImpactAcquireException.getErrorCodeAsString( I2COperationExecuteResult ), I2COperationExecuteResult ) );
           }
           System.out.println( String.format( "'I2COperationStatus' after read: %s.", i2cc.getI2COperationStatus().readS() ) );
           if( i2cc.getI2CBuffer().binaryDataBufferSize() != bytesToRead )
           {
             System.out.println( String.format( "'I2CBuffer' reports %d bytes of data while %d bytes where expected.", i2cc.getI2CBuffer().binaryDataBufferSize(), bytesToRead ) );
           }
           // usage of the convenience functions
           i2cc.I2CWrite( 0xA4, 0x00, 8, "TEST" );
           final String i2cReadBuffer = i2cc.I2CRead( 0xA4, 0x00, 8, 4 );
         }
         else
         {
           System.out.println( "I2CControl not available." );
         }
    }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

    .. code-block:: c++

         i2cc = acquire.I2CControl(pBF); # assuming 'pBF' to be a valid 'Device*' instance to an mvBlueFOX device
         if i2cc.I2COperationMode.isValid():
           # direct property access
           i2cc.I2CBufferLength.write(0)
           i2cc.I2COperationMode.write(acquire.I2ComRead)
           assert i2cc.I2COperationExecute.call() == acquire.DMR_INVALID_PARAMETER, "Unexpected driver behaviour"
           assert i2cc.I2COperationStatus.read() == acquire.I2CosNotEnoughData, "Unexpected driver behaviour"
           i2cc.I2CBufferLength.write(1)
           # assuming we write to an invalid address
           assert i2cc.I2COperationExecute.call() == acquire.DMR_EXECUTION_FAILED, "Unexpected driver behaviour"
           assert i2cc.I2COperationStatus.read() == acquire.I2CosFailure, "Unexpected driver behaviour"
           i2cc.I2COperationMode.write(acquire.I2ComWrite)
           pBuf = '' # 'A' and 'B'
           i2cc.I2CBuffer.writeBinary(pBuf)
           # assuming we write to an invalid address
           assert i2cc.I2COperationExecute.call() == acquire.DMR_EXECUTION_FAILED, "Unexpected driver behaviour"
           assert i2cc.I2COperationStatus.read() == acquire.I2CosFailure, "Unexpected driver behaviour"
           # Write some data. This will only work if several conditions are met:
           # - there is a device that can be written to at address 0xA6
           # - the sub-address 0x04 is valid
           # - the device is designed to work with 8 bit sub-addresses
           # - the device can deal with 9 bytes in a single command
           i2cc.I2CDeviceAddress.write(0xA6)
           i2cc.I2CDeviceSubAddress.write(0x04)
           i2cc.I2CDeviceSubAddressWidth.write(8)
           pBuf = '' # The good old 'DEAD BEEF' in HEX notation
           i2cc.I2CBuffer.writeBinary(pBuf)
           i2cc.I2COperationMode.write(acquire.I2ComWrite)
           I2COperationExecuteResult = i2cc.I2COperationExecute.call()
           if I2COperationExecuteResult != acquire.DMR_NO_ERROR:
             print("'I2COperationExecute' write failed. Return value: {0}({1}).".format(acquire.ImpactAcquireException.getErrorCodeAsString(I2COperationExecuteResult), I2COperationExecuteResult))
           print("'I2COperationStatus' after write: {0}.".format(i2cc.I2COperationStatus.readS()))
           # Read some data. Similar condition as for write apply
           bytesToRead = 4
           i2cc.I2CDeviceAddress.write(0xA8)
           i2cc.I2CDeviceSubAddress.write(0x00)
           i2cc.I2CDeviceSubAddressWidth.write(8)
           i2cc.I2CBufferLength.write(bytesToRead) # read 'bytesToRead' bytes
           i2cc.I2COperationMode.write(acquire.I2ComRead)
           i2cc.I2COperationExecute.call()
           I2COperationExecuteResult = i2cc.I2COperationExecute.call()
           if I2COperationExecuteResult != acquire.DMR_NO_ERROR:
             System.out.println(String.format("'I2COperationExecute' read failed. Return value: %s(%d).", ImpactAcquireException.getErrorCodeAsString(I2COperationExecuteResult), I2COperationExecuteResult))
           print("'I2COperationStatus' after read: {0}.".format(i2cc.I2COperationStatus.readS()))
           if i2cc.I2CBuffer.binaryDataBufferSize() != bytesToRead:
             print("'I2CBuffer' reports {0} bytes of data while {1} bytes where expected.".format(i2cc.I2CBuffer.binaryDataBufferSize(), bytesToRead))
           # usage of the convenience functions
           i2cc.I2CWrite(0xA4, 0x00, 8, "TEST")
           i2cReadBuffer = i2cc.I2CRead(0xA4, 0x00, 8, 4)
         else:
           print("I2CControl not available.")
    }

     Notes: This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
     **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

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

    def __init__(self, pDev):
        r"""
         brief Constructs a new **mvIMPACT::acquire::I2CControl** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        """
        lib_mvIMPACT_acquire.I2CControl_swiginit(self, lib_mvIMPACT_acquire.new_I2CControl(pDev))
    I2COperationMode = property(lib_mvIMPACT_acquire.I2CControl_I2COperationMode_get, doc=r"""
    An enumerated integer property to select the I2C operation.
    The selected operation is executed when **mvIMPACT::acquire::I2CControl::I2COperationExecute** is called.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TI2COperationMode**.
    """)
    I2COperationExecute = property(lib_mvIMPACT_acquire.I2CControl_I2COperationExecute_get, doc=r""" Calling this function will execute the operation selected by **mvIMPACT::acquire::I2CControl::I2COperationMode**.""")
    I2COperationStatus = property(lib_mvIMPACT_acquire.I2CControl_I2COperationStatus_get, doc=r"""
    Represents the I2C operation execution status.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TI2COperationStatus**.
    """)
    I2CDeviceAddress = property(lib_mvIMPACT_acquire.I2CControl_I2CDeviceAddress_get, doc=r""" An integer property storing the address of the I2C device to communicate with.""")
    I2CDeviceSubAddressWidth = property(lib_mvIMPACT_acquire.I2CControl_I2CDeviceSubAddressWidth_get, doc=r"""
    An enumerated integer property storing the sub-address width(in bits) of the I2C device to communicate with.
    Valid values for this property are:

    - 0
    - 8
    - 16

    Notes: 
    This property must be set to 0 for devices not supporting a sub-address.
    """)
    I2CDeviceSubAddress = property(lib_mvIMPACT_acquire.I2CControl_I2CDeviceSubAddress_get, doc=r"""
    An integer property storing the sub-address of the I2C device to communicate with.
    When **mvIMPACT::acquire::I2CControl::I2CDeviceSubAddressWidth** is set to 0, this property will be ignored.
    """)
    I2CBuffer = property(lib_mvIMPACT_acquire.I2CControl_I2CBuffer_get, doc=r"""
    Defines the intermediate access buffer that allows the exchange of data between the I2C device and the application.
    This property can store binary data.
    """)
    I2CBufferLength = property(lib_mvIMPACT_acquire.I2CControl_I2CBufferLength_get, doc=r""" An integer property controlling the length of the mapping between the I2C device and the **mvIMPACT::acquire::I2CControl::I2CBuffer** property.""")

    def I2CRead(self, deviceAddress, deviceSubAddress, deviceSubAddressWidth, byteCnt):
        r"""
         Read data from an I2C device.
         This is a convenience function that wraps the property access a little.
         In order to find out if the command has been executed successfully
         **mvIMPACT::acquire::I2CControl::I2COperationStatus** should be checked afterwards.

        :type deviceAddress: int
        :param deviceAddress: [in] The address of the I2C device to communicate with.
        :type deviceSubAddress: int
        :param deviceSubAddress: [in] The sub-address of the I2C device to communicate with.
        :type deviceSubAddressWidth: int
        :param deviceSubAddressWidth: [in] The sub-address width(in bits) of the I2C device to communicate with.
        :type byteCnt: int
        :param byteCnt: [in] The amount of bytes to read.
        """
        return lib_mvIMPACT_acquire.I2CControl_I2CRead(self, deviceAddress, deviceSubAddress, deviceSubAddressWidth, byteCnt)

    def I2CWrite(self, deviceAddress, deviceSubAddress, deviceSubAddressWidth, data):
        r"""
         Write data to a I2C device.
         This is a convenience function that wraps the property access a little.
         In order to find out if the command has been executed successfully
         **mvIMPACT::acquire::I2CControl::I2COperationStatus** should be checked afterwards.

        :type deviceAddress: int
        :param deviceAddress: [in] The address of the I2C device to communicate with.
        :type deviceSubAddress: int
        :param deviceSubAddress: [in] The sub-address of the I2C device to communicate with.
        :type deviceSubAddressWidth: int
        :param deviceSubAddressWidth: [in] The sub-address width(in bits) of the I2C device to communicate with.
        :type data: string
        :param data: [in] The data to write to the I2C device.
        """
        return lib_mvIMPACT_acquire.I2CControl_I2CWrite(self, deviceAddress, deviceSubAddress, deviceSubAddressWidth, data)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_I2CControl

# Register I2CControl in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.I2CControl_swigregister(I2CControl)

class MotorFocusControl(ComponentCollection):
    r"""
    Properties for configuring settings belonging to the motor focus control (**Device** specific interface layout only).
    Properties in this class will only be available if a device is fitted with
    a focus motor.

    Notes: This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
    **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

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

    def __init__(self, pDev):
        r"""
         brief Constructs a new **mvIMPACT::acquire::MotorFocusControl** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        """
        lib_mvIMPACT_acquire.MotorFocusControl_swiginit(self, lib_mvIMPACT_acquire.new_MotorFocusControl(pDev))
    motorFocusSendBuffer = property(lib_mvIMPACT_acquire.MotorFocusControl_motorFocusSendBuffer_get, doc=r"""
    A string property storing a command to be sent to the motor focus.
    To actually send the command, the function **mvIMPACT::acquire::MotorFocusControl::motorFocusSend** must be executed.
    """)
    motorFocusReceiveBuffer = property(lib_mvIMPACT_acquire.MotorFocusControl_motorFocusReceiveBuffer_get, doc=r""" A string property **(read-only)** that will contain answers sent by the motor focus controller.""")
    motorFocusSend = property(lib_mvIMPACT_acquire.MotorFocusControl_motorFocusSend_get, doc=r"""
    Calling this function will send the value of **mvIMPACT::acquire::MotorFocusControl::motorFocusSendBuffer** to the hardware.
    Afterwards **mvIMPACT::acquire::MotorFocusControl::motorFocusReceiveBuffer** will contain the hardwares answer.
    """)
    motorFocusIncrement = property(lib_mvIMPACT_acquire.MotorFocusControl_motorFocusIncrement_get, doc=r""" An integer property storing an increment(in encoder counts) that will be used by subsequent calls to **mvIMPACT::acquire::MotorFocusControl::motorFocusNear** and **mvIMPACT::acquire::MotorFocusControl::motorFocusFar** commands.""")
    motorFocusNear = property(lib_mvIMPACT_acquire.MotorFocusControl_motorFocusNear_get, doc=r""" Calling this function will cause the motor focus to move forward by **mvIMPACT::acquire::MotorFocusControl::motorFocusIncrement** encoder units.""")
    motorFocusFar = property(lib_mvIMPACT_acquire.MotorFocusControl_motorFocusFar_get, doc=r""" Calling this function will cause the motor focus to move backward by **mvIMPACT::acquire::MotorFocusControl::motorFocusIncrement** encoder units.""")
    motorFocusAbsolutePositionCurrent = property(lib_mvIMPACT_acquire.MotorFocusControl_motorFocusAbsolutePositionCurrent_get, doc=r""" An integer property **(read-only)** storing the current absolute position(in encoder counts).""")
    motorFocusAbsolutePositionDesired = property(lib_mvIMPACT_acquire.MotorFocusControl_motorFocusAbsolutePositionDesired_get, doc=r""" An integer property storing an absolute position(in encoder counts) that will be used by subsequent calls to the **mvIMPACT::acquire::MotorFocusControl::motorFocusMoveToAbsolutePositionDesired** command.""")
    motorFocusMoveToAbsolutePositionDesired = property(lib_mvIMPACT_acquire.MotorFocusControl_motorFocusMoveToAbsolutePositionDesired_get, doc=r""" Calling this function will cause the motor focus to move to the position defined by the value of **mvIMPACT::acquire::MotorFocusControl::motorFocusAbsolutePositionDesired**.""")
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_MotorFocusControl

# Register MotorFocusControl in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.MotorFocusControl_swigregister(MotorFocusControl)

class DigitalIOMeasurementControl(ComponentCollection):
    r"""
     Properties for configuring settings belonging to the digital I/O measurement(**Device** specific interface layout only).
     Properties in this class will only be available if a device offers digital I/O measurement features.

    If: DOXYGEN_CPP_DOCUMENTATION {

    .. code-block:: c++

         // This code fragment will print result of measurement using all modes on all sources
         // to the standard output.
         DigitalIOMeasurementControl iomc(getDevicePointerFromSomewhere());
         if( iomc.digitalIOMeasurementMode.isValid()  iomc.digitalIOMeasurementSource.isValid() )
         {
           vectorpair<string, TDigitalIOMeasurementMode  modeDict;
           iomc.digitalIOMeasurementMode.getTranslationDict( modeDict );
           const unsigned int modeCnt = iomc.digitalIOMeasurementMode.dictSize();
           vectorpair<string, TDigitalIOMeasurementSource  srcDict;
           iomc.digitalIOMeasurementSource.getTranslationDict( srcDict );
           const unsigned int srcCnt = iomc.digitalIOMeasurementSource.dictSize();
           for( unsigned int i=0; imodeCnt; i++ )
           {
             iomc.digitalIOMeasurementMode.write( modeDict[i].second );
             for( unsigned int j=0; jsrcCnt; j++ )
             {
               iomc.digitalIOMeasurementSource.write( srcDict[j].second );
               printf( "Digital I/O measurement result using mode '%s' at source '%s': %s\n", iomc.digitalIOMeasurementMode.readS().c_str(), iomc.digitalIOMeasurementSource.readS().c_str(), iomc.digitalIOMeasurementResult.readS().c_str() );
             }
           }
         }
    }Else if: DOXYGEN_JAVA_DOCUMENTATION {

    .. code-block:: c++

         // This code fragment will print result of measurement using all modes on all sources
         // to the standard output.
         DigitalIOMeasurementControl iomc = new DigitalIOMeasurementControl(getDevicePointerFromSomewhere());
         if( iomc.digitalIOMeasurementMode.isValid()  iomc.digitalIOMeasurementSource.isValid() )
         {
           StringIntVector modeDict = new StringIntVector();
           iomc.digitalIOMeasurementMode.getTranslationDict( modeDict );
           final int modeCnt = iomc.digitalIOMeasurementMode.dictSize();
           StringIntVector srcDict = new StringIntVector();
           iomc.digitalIOMeasurementSource.getTranslationDict( srcDict );
           final int srcCnt = iomc.digitalIOMeasurementSource.dictSize();
           for( int i=0; imodeCnt; i++ )
           {
             iomc.digitalIOMeasurementMode.write( modeDict.get( i ).getSecond() );
             for( int j=0; jsrcCnt; j++ )
             {
               iomc.digitalIOMeasurementSource.write( srcDict.get( j ).getSecond() );
               System.out.println( String.format( "Digital I/O measurement result using mode '%s' at source '%s': %s\n", iomc.digitalIOMeasurementMode.readS(), iomc.digitalIOMeasurementSource.readS(), iomc.digitalIOMeasurementResult.readS() ) );
             }
           }
         }
    }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

    .. code-block:: c++

         modeDict = []
         srcDict = []
         iomc = acquire.DigitalIOMeasurementControl(pDev)
         if iomc.digitalIOMeasurementMode.isValid and iomc.digitalIOMeasurementSource.isValid:
             iomc.digitalIOMeasurementMode.getTranslationDict(modeDict)
             modeCnt = iomc.digitalIOMeasurementMode.dictSize()
             iomc.digitalIOMeasurementSource.getTranslationDict(srcDict);
             srcCnt = iomc.digitalIOMeasurementSource.dictSize();
             for i in range(modeCnt):
                 iomc.digitalIOMeasurementMode.write(modeDict[i].second);
                 for j in range(srcCnt):
                     iomc.digitalIOMeasurementSource.write(srcDict[j].second);
                     print("Digital I/O measurement result using mode '" +  iomc.digitalIOMeasurementMode.readS() + "' at source '" +  iomc.digitalIOMeasurementSource.readS() + "': " + iomc.digitalIOMeasurementResult.readS())
    }

     Notes: This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
     **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

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

    def __init__(self, pDev):
        r"""
         brief Constructs a new **mvIMPACT::acquire::DigitalIOMeasurementControl** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        """
        lib_mvIMPACT_acquire.DigitalIOMeasurementControl_swiginit(self, lib_mvIMPACT_acquire.new_DigitalIOMeasurementControl(pDev))
    digitalIOMeasurementMode = property(lib_mvIMPACT_acquire.DigitalIOMeasurementControl_digitalIOMeasurementMode_get, doc=r"""
    An enumerated integer property defining the type of measurement to perform.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDigitalIOMeasurementMode**.
    """)
    digitalIOMeasurementSource = property(lib_mvIMPACT_acquire.DigitalIOMeasurementControl_digitalIOMeasurementSource_get, doc=r"""
    An enumerated integer property defining where the measurement shall be performed.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDigitalIOMeasurementMode**.
    """)
    digitalIOMeasurementResult = property(lib_mvIMPACT_acquire.DigitalIOMeasurementControl_digitalIOMeasurementResult_get, doc=r"""
    A float property **(read-only)** that will contain the result of the measurement.
    Reading this property will automatically perform a new measurement.

    Notes: 
    Please note that the signal connected to the digital input must match the selected digital input
    threshold(see **mvIMPACT::acquire::IOSubSystemBlueFOX::digitalInputThreshold)** in order to
    obtain valid results.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_DigitalIOMeasurementControl

# Register DigitalIOMeasurementControl in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.DigitalIOMeasurementControl_swigregister(DigitalIOMeasurementControl)

class SettingsBlueFOX(FullSettingsBase):
    r"""
    This class provides access to general settings as well as to settings which are unique for the **mvBlueFOX(****Device** specific interface layout only).
    To see a small code example on how you can work with object of this class see
    the detailed description of the class **mvIMPACT::acquire::FunctionInterface** as well.
    Statements made for the use of the class **mvIMPACT::acquire::FullSettingsBase** apply for
    this class as well.

    Notes: This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
    **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

    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"""
         brief Constructs a new **mvIMPACT::acquire::SettingsBlueFOX** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type name: string
        :param name: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.SettingsBlueFOX_swiginit(self, lib_mvIMPACT_acquire.new_SettingsBlueFOX(*args))
    cameraSetting = property(lib_mvIMPACT_acquire.SettingsBlueFOX_cameraSetting_get, doc=r""" Camera related settings.""")
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_SettingsBlueFOX

# Register SettingsBlueFOX in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.SettingsBlueFOX_swigregister(SettingsBlueFOX)

class SettingsFrameGrabber(FullSettingsBase):
    r"""
    This class provides access to general settings as well as to settings which are unique for frame grabber devices(**Device** specific interface layout only).
    To see a small code example on how you can work with object of this class see
    the detailed description of the class **mvIMPACT::acquire::FunctionInterface** as well.
    Statements made for the use of the class **mvIMPACT::acquire::FullSettingsBase** apply for
    this class as well.

    Notes: This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
    **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

    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"""
         brief Constructs a new **mvIMPACT::acquire::SettingsFrameGrabber** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type name: string
        :param name: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.SettingsFrameGrabber_swiginit(self, lib_mvIMPACT_acquire.new_SettingsFrameGrabber(*args))
    cameraSetting = property(lib_mvIMPACT_acquire.SettingsFrameGrabber_cameraSetting_get, doc=r""" Camera related settings.""")
    connector = property(lib_mvIMPACT_acquire.SettingsFrameGrabber_connector_get, doc=r""" Input channel related properties.""")
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_SettingsFrameGrabber

# Register SettingsFrameGrabber in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.SettingsFrameGrabber_swigregister(SettingsFrameGrabber)

class SystemBlueFOX(SystemSettings):
    r"""
    A class containing **mvBlueFOX** specific settings to control the overall behaviour of the driver(**Device** specific interface layout only).
    Notes: This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
    **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

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

    def __init__(self, pDev):
        r"""
         Constructs a new **mvIMPACT::acquire::SystemBlueFOX** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        """
        lib_mvIMPACT_acquire.SystemBlueFOX_swiginit(self, lib_mvIMPACT_acquire.new_SystemBlueFOX(pDev))
    transferSize = property(lib_mvIMPACT_acquire.SystemBlueFOX_transferSize_get, doc=r"""
    An enumerated integer property defining the block size of the image data blocks transferred from the device.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBlueFOXTransferSize**.
    """)
    footerMode = property(lib_mvIMPACT_acquire.SystemBlueFOX_footerMode_get, doc=r"""
    An enumerated integer property defining the footer mode of the device.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBlueFOXFooterMode**.
    """)
    footerCheckEnable = property(lib_mvIMPACT_acquire.SystemBlueFOX_footerCheckEnable_get, doc=r"""
    An enumerated integer property allowing to switch on/off the check of the image footer.
    The image footer contains certain additional data as e.g. the exposure time as used by the image
    sensor. To debug transfer related problems it sometimes can be useful to disable all internal
    data consistency checks by the driver.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.
    """)
    powerMode = property(lib_mvIMPACT_acquire.SystemBlueFOX_powerMode_get, doc=r"""
    An enumerated integer property defining the power mode of the device.
    Notes: 
    This property requires at least firmware version 39! See **mvIMPACT::acquire::Device::firmwareVersion** to find
    out which firmware is currently running on the device or use **mvIMPACT::acquire::Device::updateFirmware()**
    to update the firmware to the state compiled into the driver.


    Do **NOT** modify this property when images are acquired in parallel. Switching off or on the power
    for a device that is capturing images at the same time will result in incorrect images! Therefore
    always make sure to stop image acquisition and clean up **BEFORE** modifying this property.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TDevicePowerMode**.
    """)
    statusLEDEnable = property(lib_mvIMPACT_acquire.SystemBlueFOX_statusLEDEnable_get, doc=r"""
    An enumerated integer property allowing to switch on/off the status LED of the device.
    Notes: 
    This feature is currently available for mvBlueFOX-MLC devices only.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.

    Since: 2.17.0
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_SystemBlueFOX

# Register SystemBlueFOX in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.SystemBlueFOX_swigregister(SystemBlueFOX)

class SystemV4L2(SystemSettings):
    r"""
    A class containing **mvV4L2** specific settings to control the overall behaviour of the driver(**Device** specific interface layout only).
    Notes: UNDER CONSTRUCTION! Subject to change.

    This class will only be available if **mvIMPACT::acquire::Device::interfaceLayout** is set to
    **mvIMPACT::acquire::dilDeviceSpecific** before the device is opened.
    """

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

    def __init__(self, pDev):
        r"""
         Constructs a new **mvIMPACT::acquire::SystemV4L2** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        """
        lib_mvIMPACT_acquire.SystemV4L2_swiginit(self, lib_mvIMPACT_acquire.new_SystemV4L2(pDev))
    volume = property(lib_mvIMPACT_acquire.SystemV4L2_volume_get, doc=r"""
    If V4L2 device supports audio, this integer property adjusts the audio volume.
    This property represents a V4L2-audio-control ID.

    Notes: This property is not supported by every device.
    Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.
    If supported, a minimum value, a maximum value and step width will be defined. Thus, invalid values may be tuned after writing to fit within the step size,
    values too large or too small will raise an exception.
    """)
    balance = property(lib_mvIMPACT_acquire.SystemV4L2_balance_get, doc=r"""
    If V4L2 device supports audio, this integer property adjusts the audio balance.
    This property represents a V4L2-audio-control ID.

    Notes: This property is not supported by every device.
    Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.
    If supported, a minimum value, a maximum value and step width will be defined. Thus, invalid values may be tuned after writing to fit within the step size,
    values too large or too small will raise an exception.
    """)
    bass = property(lib_mvIMPACT_acquire.SystemV4L2_bass_get, doc=r"""
    If V4L2 device supports audio, this integer property adjusts the audio bass.
    This property represents a V4L2-audio-control ID.

    Notes: This property is not supported by every device.
    Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.
    If supported, a minimum value, a maximum value and step width will be defined. Thus, invalid values may be tuned after writing to fit within the step size,
    values too large or too small will raise an exception.
    """)
    treble = property(lib_mvIMPACT_acquire.SystemV4L2_treble_get, doc=r"""
    If V4L2 device supports audio, this integer property adjusts the audio treble.
    This property represents a V4L2-audio-control ID.

    Notes: This property is not supported by every device.
    Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.
    If supported, a minimum value, a maximum value and step width will be defined. Thus, invalid values may be tuned after writing to fit within the step size,
    values too large or too small will raise an exception.
    """)
    mute = property(lib_mvIMPACT_acquire.SystemV4L2_mute_get, doc=r"""
    If V4L2 device supports audio, this enumerated integer property sets audio mute on/off.
    This property represents a boolean-valued V4L2-control ID. Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.

    Notes: This property is not supported by every device.
    Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.
    """)
    loudness = property(lib_mvIMPACT_acquire.SystemV4L2_loudness_get, doc=r"""
    If V4L2 device supports audio, this enumerated integer property sets audio loudness on/off.
    This property represents a boolean-valued V4L2-control ID. Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.

    Notes: This property is not supported by every device.
    Therefore always call the function **mvIMPACT::acquire::Component::isValid** to check if this property is available or not.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_SystemV4L2

# Register SystemV4L2 in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.SystemV4L2_swigregister(SystemV4L2)

class GenTLProducerConfiguration(ComponentCollection):
    r"""
     A class that contains items to configure the behaviour of the GenICam GenTL driver stack.
    This class contains items to configure the enumeration behaviour of a third party GenTL producer library.

     Notes: 
    Instances of this class cannot be constructed directly. To get access the functions **mvIMPACT::acquire::GenICam::GenTLDriverConfigurator::createProducerConfiguration**,
    **mvIMPACT::acquire::GenICam::GenTLDriverConfigurator::getProducerConfigurations**
    or **mvIMPACT::acquire::GenICam::GenTLDriverConfigurator::getProducerConfiguration** must be used.
    must be used.

    For a comprehensive usage example see the description of the class **mvIMPACT::acquire::GenICam::GenTLDriverConfigurator**.

    See also: 
    'CommonCases_mvGenTLConsumerSetup'

    Since: 2.34.0
    """

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

    def __init__(self, src):
        r"""
         Constructs a new **mvIMPACT::acquire::GenICam::GenTLProducerConfiguration** from an existing one.
        :type src: :py:class:`GenTLProducerConfiguration`
        :param src: [in] A constant reference to the **mvIMPACT::acquire::GenICam::GenTLProducerConfiguration** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.GenTLProducerConfiguration_swiginit(self, lib_mvIMPACT_acquire.new_GenTLProducerConfiguration(src))
    enumerationEnable = property(lib_mvIMPACT_acquire.GenTLProducerConfiguration_enumerationEnable_get, doc=r"""
     An enumerated integer property defining the enumeration behavior this particular GenTL producer.
    If this property is set to **mvIMPACT::acquire::bTrue** ALL interfaces of this producer will be enumerated
    unless a specific interface enumeration behaviour has been set to **mvIMPACT::acquire::iebForceIgnore**.

    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TBoolean**.
    """)

    def getInterfaceEnumerationBehaviour(self, interfaceID):
        r"""
         Returns the interface enumeration behaviour property for the specified interface ID for this particular GenTL producer.

        Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TInterfaceEnumerationBehaviour**.

        Notes: If no entry for the specified interface ID exists an exception will be thrown.

        :rtype: :py:class:`PropertyIInterfaceEnumerationBehaviour`
        :return: The enumeration behaviour configuration property for the specified interface

        :type interfaceID: string
        :param interfaceID: [in] The interface ID previously passed e.g. to the **mvIMPACT::acquire::GenICam::GenTLProducerConfiguration::createProducerInterfaceConfigurationEntry** function.
        """
        return lib_mvIMPACT_acquire.GenTLProducerConfiguration_getInterfaceEnumerationBehaviour(self, interfaceID)

    def getInterfaceEnumerationBehaviours(self):
        r"""
         Returns a map containing all the configured interface IDs and their corresponding enumeration behaviour properties for this particular GenTL producer.
        The returned map will only contain interface IDs which have explicitly been configured (e.g. by a previous call to
        **mvIMPACT::acquire::GenICam::GenTLProducerConfiguration::createProducerInterfaceConfigurationEntry**. Certain third party
        interfaces might also have an entry in this map (e.g. if there is a MATRIX VISION producer supporting the same technology present
        on the system).

        Valid values for the properties are defined by the enumeration **mvIMPACT::acquire::TInterfaceEnumerationBehaviour**.

        :rtype: std::map< std::string,mvIMPACT::acquire::PropertyIInterfaceEnumerationBehaviour >
        :return: A map containing all the configured interface IDs and their corresponding enumeration behaviour properties for this particular GenTL producer
        """
        return lib_mvIMPACT_acquire.GenTLProducerConfiguration_getInterfaceEnumerationBehaviours(self)

    def createProducerInterfaceConfigurationEntry(self, interfaceID):
        r"""
         Creates a new interface configuration entry for this producers configuration.
        Usually the parameter passed to this function will be one of the interface IDs of the producers list of reported interfaces
        in order to configure this particular interface. However it can also be an identifier for an interface not yet connected to the
        system or not yet available to the producer. No internal checks are performed regarding the validity of the given interface ID.

        Notes: If an entry with the same interface ID already exists an exception will be thrown.

        :type interfaceID: string
        :param interfaceID: [in] The interface ID to create the configuration entry for.
        """
        return lib_mvIMPACT_acquire.GenTLProducerConfiguration_createProducerInterfaceConfigurationEntry(self, interfaceID)

    def deleteProducerInterfaceConfigurationEntry(self, interfaceID):
        r"""
         Deletes an interface configuration entry from this producers configuration.
        Notes: If no entry for the specified interface can be found an exception will be thrown.

        :type interfaceID: string
        :param interfaceID: [in] The exact interface ID of the producers list of reported interfaces to delete the configuration entry for.
        """
        return lib_mvIMPACT_acquire.GenTLProducerConfiguration_deleteProducerInterfaceConfigurationEntry(self, interfaceID)

    def getProducerName(self):
        r"""
         Returns the name of the GenTL producer associated with this configuration object.
        :rtype: string
        :return: The name of the GenTL producer associated with this configuration object.
        """
        return lib_mvIMPACT_acquire.GenTLProducerConfiguration_getProducerName(self)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_GenTLProducerConfiguration

# Register GenTLProducerConfiguration in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.GenTLProducerConfiguration_swigregister(GenTLProducerConfiguration)

class GenTLDriverConfigurator(ComponentCollection):
    r"""
     A class that contains items to configure the behaviour of the GenICam GenTL driver stack.
    This class contains items e.g. to configure the enumeration behaviour of third party GenTL producer libraries.

    Since version 2.32.0 mvIMPACT Acquire has built-in support for third party GenTL producer libraries.
    The latest version of the GenTL specification can be found here: https://www.emva.org/standards-technology/genicam/.

    Detection of GenTL producer libraries works by evaluating the ``GENICAM_GENTL32_PATH`` environment variable
    within a 32-bit process or the ``GENICAM_GENTL64_PATH`` variable in a 64-bit process. This variable contains
    a list of directories that might potentially contain GenTL producer libraries. These libraries use a
    the file extension ``.cti`` and export a defined interface.

    All libraries that fulfill these requirements will be loaded into the mvIMPACT Acquire process. By default
    all these libraries will then also be enumerated for connected/bound devices. The only exception will be
    if a third party producer is found that reports an interface supporting the same technology as one delivered
    by mvIMPACT Acquire (e.g. for the GigE Vision or USB3 Vision standard). These interfaces by default will not
    be enumerated.

    The purpose of this class now is to allow an application to modify this behaviour. This might be beneficial for
    several reasons:

    - a certain third party library on the system has negative impact on the overall stability of the process
    - there are so many third party libraries on the system that enumeration takes a very long time but the application does not want to access devices reported by these third party libraries
    - multiple producers support the same device resulting in very long and confusing device lists
    - etc.

    To exclude a certain producer from enumeration first a mvIMPACT::acquire::GenICam::GenTLProducerConfiguration entry for that
    producer must be created and then the **mvIMPACT::acquire::GenICam::GenTLProducerConfiguration::enumerationEnable**
    property for this producer must be set to **mvIMPACT::acquire::bFalse**.

    If: DOXYGEN_CPP_DOCUMENTATION {

    .. code-block:: c++

        // Assuming a certain 'ACME.producer.cti' producer has been found somewhere in the GENICAM_GENTLXY_PATH.
        GenTLDriverConfigurator driverConfigurator;
        if( !driverConfigurator.hasProducerConfiguration( "ACME.producer.cti" ) )
        {
          driverConfigurator.createProducerConfiguration( "ACME.producer.cti" ); // the 'enumerationEnable' will be false by default!
        }
        else
        {
          driverConfigurator.getProducerConfiguration( "ACME.producer.cti" ).enumerationEnable.write( bFalse );
        }
    }Else if: DOXYGEN_JAVA_DOCUMENTATION {

    .. code-block:: c++

        // Assuming a certain 'ACME.producer.cti' producer has been found somewhere in the GENICAM_GENTLXY_PATH.
        GenTLDriverConfigurator driverConfigurator = new GenTLDriverConfigurator();
        if( !driverConfigurator.hasProducerConfiguration( "ACME.producer.cti" ) )
        {
          driverConfigurator.createProducerConfiguration( "ACME.producer.cti" ); // the 'enumerationEnable' will be false by default!
        }
        else
        {
           driverConfigurator.getProducerConfiguration( "ACME.producer.cti" ).enumerationEnable.write( TBoolean.bFalse );
        }
    }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

    .. code-block:: c++

        # Assuming a certain 'ACME.producer.cti' producer has been found somewhere in the GENICAM_GENTLXY_PATH.
        driverConfigurator = acquire.GenTLDriverConfigurator()
        if driverConfigurator.hasProducerConfiguration("ACME.producer.cti") == False:
          driverConfigurator.createProducerConfiguration("ACME.producer.cti") # the 'enumerationEnable' will be false by default!
        else:
           driverConfigurator.getProducerConfiguration("ACME.producer.cti").enumerationEnable.write(acquire.bFalse)
    }

    To exclude a certain interface from a producer from enumeration an **mvIMPACT::acquire::GenICam::GenTLProducerConfiguration::enumerationEnable**
    property for this producer can be set to **mvIMPACT::acquire::bFalse** and the interface enumeration behaviour should be set to
    **mvIMPACT::acquire::iebForceEnumerate**.

    If: DOXYGEN_CPP_DOCUMENTATION {

    .. code-block:: c++

        // Assuming a certain 'ACME.producer.cti' producer has been found somewhere in the GENICAM_GENTLXY_PATH.
        GenTLDriverConfigurator driverConfigurator;
        GenTLProducerConfiguration configuration( driverConfigurator.hasProducerConfiguration( "ACME.producer.cti" ) ? driverConfigurator.getProducerConfiguration( "ACME.producer.cti" ) : driverConfigurator.createProducerConfiguration( "ACME.producer.cti" ) );
        configuration.enumerationEnable.write( bTrue ); // switch on ALL interfaces...
        configuration.createProducerInterfaceConfigurationEntry( "ACME.interface0.ID" ).write( iebForceIgnore ); // ... except this one
    }Else if: DOXYGEN_JAVA_DOCUMENTATION {

    .. code-block:: c++

        // Assuming a certain 'ACME.producer.cti' producer has been found somewhere in the GENICAM_GENTLXY_PATH.
        GenTLDriverConfigurator driverConfigurator = new GenTLDriverConfigurator();
        GenTLProducerConfiguration configuration = null;
        if( driverConfigurator.hasProducerConfiguration( "ACME.producer.cti" ) )
        {
          configuration = driverConfigurator.getProducerConfiguration( "ACME.producer.cti" );
        }
        else
        {
          configuration = driverConfigurator.createProducerConfiguration( "ACME.producer.cti" );
        }
        configuration.getEnumerationEnable().write( TBoolean.bTrue ); // switch on ALL interfaces...
        configuration.createProducerInterfaceConfigurationEntry( "ACME.interface0.ID" ).write( TInterfaceEnumerationBehaviour.iebForceIgnore ); // ... except this one
    }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

    .. code-block:: c++

        # Assuming a certain 'ACME.producer.cti' producer has been found somewhere in the GENICAM_GENTLXY_PATH.
        driverConfigurator = acquire.GenTLDriverConfigurator()
        GenTLProducerConfiguration configuration = None
        if driverConfigurator.hasProducerConfiguration("ACME.producer.cti"):
          configuration = driverConfigurator.getProducerConfiguration("ACME.producer.cti")
        else:
          configuration = driverConfigurator.createProducerConfiguration("ACME.producer.cti")
        configuration.enumerationEnable.write(acquire.bTrue) # switch on ALL interfaces...
        configuration.createProducerInterfaceConfigurationEntry("ACME.interface0.ID").write(acquire.iebForceIgnore) # ... except this one
    }

    The same thing can be done the other way round:

    If: DOXYGEN_CPP_DOCUMENTATION {

    .. code-block:: c++

        // Assuming a certain 'ACME.producer.cti' producer has been found somewhere in the GENICAM_GENTLXY_PATH and only a certain interface shall be enumerated.
        GenTLDriverConfigurator driverConfigurator;
        GenTLProducerConfiguration configuration( driverConfigurator.hasProducerConfiguration( "ACME.producer.cti" ) ? driverConfigurator.getProducerConfiguration( "ACME.producer.cti" ) : driverConfigurator.createProducerConfiguration( "ACME.producer.cti" ) );
        configuration.enumerationEnable.write( bFalse ); // switch off ALL interfaces...
        configuration.createProducerInterfaceConfigurationEntry( "ACME.interface0.ID" ).write( iebForceEnumerate ); // ... except this one
    }Else if: DOXYGEN_JAVA_DOCUMENTATION {

    .. code-block:: c++

        GenTLDriverConfigurator driverConfigurator = new GenTLDriverConfigurator();
        GenTLProducerConfiguration configuration = null;
        if( driverConfigurator.hasProducerConfiguration( "ACME.producer.cti" ) )
        {
          configuration = driverConfigurator.getProducerConfiguration( "ACME.producer.cti" );
        }
        else
        {
          configuration = driverConfigurator.createProducerConfiguration( "ACME.producer.cti" );
        }
        configuration.getEnumerationEnable().write( TBoolean.bFalse ); // switch on ALL interfaces...
        configuration.createProducerInterfaceConfigurationEntry( "ACME.interface0.ID" ).write( TInterfaceEnumerationBehaviour.iebForceEnumerate ); // ... except this one
    }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

    .. code-block:: c++

        # Assuming a certain 'ACME.producer.cti' producer has been found somewhere in the GENICAM_GENTLXY_PATH.
        driverConfigurator = acquire.GenTLDriverConfigurator()
        GenTLProducerConfiguration configuration = None
        if driverConfigurator.hasProducerConfiguration("ACME.producer.cti"):
          configuration = driverConfigurator.getProducerConfiguration("ACME.producer.cti")
        else:
          configuration = driverConfigurator.createProducerConfiguration("ACME.producer.cti")
        configuration.enumerationEnable.write(acquire.bFalse) # switch on ALL interfaces...
        configuration.createProducerInterfaceConfigurationEntry("ACME.interface0.ID").write(acquire.iebForceEnumerate) # ... except this one
    }
    See also: 
    'CommonCases_mvGenTLConsumerSetup'

    Since: 2.34.0
    """

    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"""
        *Overload 1:*
         Constructs a new **mvIMPACT::acquire::GenICam::GenTLDriverConfigurator** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::GenICam::GenTLDriverConfigurator** from an existing one.
        :type src: :py:class:`GenTLDriverConfigurator`
        :param src: [in] A constant reference to the **mvIMPACT::acquire::GenICam::GenTLDriverConfigurator** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.GenTLDriverConfigurator_swiginit(self, lib_mvIMPACT_acquire.new_GenTLDriverConfigurator(*args))
    masterEnumerationBehaviour = property(lib_mvIMPACT_acquire.GenTLDriverConfigurator_masterEnumerationBehaviour_get, doc=r"""
     An enumerated integer property defining the master enumeration mode for all GenTL producer detected in the current session.
    Valid values for this property are defined by the enumeration **mvIMPACT::acquire::TInterfaceEnumerationBehaviour**.
    """)

    def createProducerConfiguration(self, *args):
        r"""
         Creates a new **mvIMPACT::acquire::GenICam::GenTLProducerConfiguration** object for the desired interface reported by the specified producer.
        Calling this function will creates a new **mvIMPACT::acquire::GenICam::GenTLProducerConfiguration** object for the desired interface
        reported by the specified producer.

        Notes: If a configuration entry for the specified interface does already exist an exception will be thrown.

        :type producerName: string
        :param producerName: [in] The exact name of the producer library without the path to create the entry for.
        :type interfaceID: string
        :param interfaceID: [in] The interface ID to create the configuration entry for.
        """
        return lib_mvIMPACT_acquire.GenTLDriverConfigurator_createProducerConfiguration(self, *args)

    def deleteProducerConfiguration(self, producerName):
        r"""
         Deletes a **mvIMPACT::acquire::GenICam::GenTLProducerConfiguration** objects.
        Calling this function will delete the **mvIMPACT::acquire::GenICam::GenTLProducerConfiguration** object for the referenced producer.

        Notes: If no entry for the specified producer can be found an exception will be thrown.

        :type producerName: string
        :param producerName: [in] The exact name of the producer library without the path to delete the entry from.
        """
        return lib_mvIMPACT_acquire.GenTLDriverConfigurator_deleteProducerConfiguration(self, producerName)

    def deleteAllProducerConfigurations(self):
        r"""
         Deletes all **mvIMPACT::acquire::GenICam::GenTLProducerConfiguration** objects.
        Calling this function will result in all **mvIMPACT::acquire::GenICam::GenTLProducerConfiguration** objects to be deleted. When the next
        mvIMPACT Acquire process will be started after shutting down the current one all producer libraries found on the system will be processed. By default only interfaces reporting
        types/technologies (e.g. GigE Vision) also supported by MATRIX VISION will be ignored (will not enumerate devices) then.
        """
        return lib_mvIMPACT_acquire.GenTLDriverConfigurator_deleteAllProducerConfigurations(self)

    def hasProducerConfiguration(self, producerName):
        r"""
         Checks if a certain producer library has been associated with a **mvIMPACT::acquire::GenICam::GenTLProducerConfiguration**.
        :rtype: boolean
        :return: 
            - true if a **mvIMPACT::acquire::GenICam::GenTLProducerConfiguration** is currently associated with the referenced producer library
            - false otherwise

        :type producerName: string
        :param producerName: [in] The exact name of the producer library without the path.
        """
        return lib_mvIMPACT_acquire.GenTLDriverConfigurator_hasProducerConfiguration(self, producerName)

    def getProducerConfiguration(self, producerName):
        r"""
         Returns the **mvIMPACT::acquire::GenICam::GenTLProducerConfiguration** associated with the referenced producer library.

        Notes: If no entry for the specified producer can be found an exception will be thrown.

        :rtype: :py:class:`GenTLProducerConfiguration`
        :return: The **mvIMPACT::acquire::GenICam::GenTLProducerConfiguration** associated with the referenced producer library.

        :type producerName: string
        :param producerName: [in] The exact name of the producer library without the path.
        """
        return lib_mvIMPACT_acquire.GenTLDriverConfigurator_getProducerConfiguration(self, producerName)

    def getProducerConfigurations(self):
        r"""
         Returns a vector containing all **mvIMPACT::acquire::GenICam::GenTLProducerConfiguration** objects currently defined.
        :rtype: std::vector< mvIMPACT::acquire::GenICam::GenTLProducerConfiguration,std::allocator< mvIMPACT::acquire::GenICam::GenTLProducerConfiguration > >
        :return: A vector containing all **mvIMPACT::acquire::GenICam::GenTLProducerConfiguration** objects currently defined.
        """
        return lib_mvIMPACT_acquire.GenTLDriverConfigurator_getProducerConfigurations(self)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_GenTLDriverConfigurator

# Register GenTLDriverConfigurator in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.GenTLDriverConfigurator_swigregister(GenTLDriverConfigurator)

class VideoStream(object):
    r"""
     A class to create compressed video stream from images captured or loaded using the %mvIMPACT Acquire API.
    This class heavily depends on the FFmpeg project (see 'LegalNotice_UsedThirdPartySoftware_FFmpeg)'. Without the
    libraries belonging to this project being present on the target system video streams cannot be created.

    Because of what is stated in the above section %mvIMPACT Acquire is **NOT** shipped with the FFmpeg binaries required to use
    this class!

    On Windows the *FFmpeg-share* package matching the platform the application shall run with (32- or 64-bit) is needed. This
    can either be extracted into the installation folder of %mvIMPACT Acquire e.g. into $(MVIMPACT_ACQUIRE_DIR)/Toolkits/ffmpeg-4.2.2-win64-shared or
    **$(MVIMPACT_ACQUIRE_DIR)/Toolkits/ffmpeg-4.2.2-win32-shared** (Works only for this versions) **OR** at the location pointed to by **MVIMPACT_ACQUIRE_FFMPEG_DIR** (see below)
    **OR** anywhere into the systems search path.

    On Linux the package *ffmpeg* must be installed and if e.g. H.264 support is needed the libavcodec-extra package as well.

    Please carefully read and understand the legal implications coming with the use of FFmpeg in a commercial product: http://ffmpeg.org/legal.html

    %mvIMPACT Acquire is capable of communicating with FFmpeg 3.x and 4.x right now. This means that the following libraries will be recognized:
    - libavcodec-58, libavformat-58 and libavutil-56 (FFmpeg 4.0 was released on 20.04.2018)
    - libavcodec-57, libavformat-57 and libavutil-55 (FFmpeg 3.0 was released on 15.02.2016)

    In order to load the FFmpeg libraries
    from a custom location the environment variable **MVIMPACT_ACQUIRE_FFMPEG_DIR** can be defined before creating the first
    **mvIMPACT::acquire::labs::VideoStream** instance after loading the mvDeviceManager library into the current processes address space.
    Without this environment variable only the systems default search path will be used to locate it and (Windows only) the *Toolkits*
    folder of the installation directory. This is how the search algorithm will operate:

    .. code-block:: c++

        if isEnvironmentVariableDefined( MVIMPACT_ACQUIRE_FFMPEG_DIR )
          if tryToLoadFFmpegVersion4Succeeded
            return
          if tryToLoadFFmpegVersion3Succeeded
            return
        if isWindowsSystem
          if tryToLoadFFmpegVersionFromToolkits4Succeeded
            return
        if tryToLoadFFmpegVersion4Succeeded
          return
        if tryToLoadFFmpegVersion3Succeeded
          return
        ReportError

    Notes: 
    Currently video streams can only be created for a limited number of pixel formats. Which codec supports which input formats is described at the corresponding
    **mvIMPACT::acquire::TVideoCodec** value. Make sure to use one of these formats either by setting up your device accordingly or by using
    the **mvIMPACT::acquire::ImageDestination::pixelFormat** property of the 'Image_Format_Converter'.

    Since: 2.39.0
    """

    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"""
        *Overload 1:*
         Creates a new video stream file.
        Notes: 
        Internally the FFmpeg project (see 'LegalNotice_UsedThirdPartySoftware_FFmpeg' section) is used for this operation. If the corresponding libraries
        cannot be located in one of the supported versions on the host system calling this constructor will raise an exception.

        :type fileName: string
        :param fileName: [in] The name or full path of the file to create. The recommended file extensions for files can be found where the **mvIMPACT::acquire::TVideoCodec** enumeration is documented
        :type pBuffer: :py:class:`ImageBuffer`
        :param pBuffer: [in] An image buffer containing the layout of the images that are about to get stored in the stream. This structure can be extracted from a real **mvIMPACT::acquire::Request** object captured previously but **NOT** by calling the **mvIMPACT::acquire::FunctionInterface::getCurrentCaptureBufferLayout** function after setting up the device completely. You could even create a stream from a list of files e.g. on a hard-disc using the **mvIMPACT::acquire::ImageBufferDesc** constructor accepting a file name. If you want to use the **mvIMPACT::acquire::Request** object obtained from a call to **mvIMPACT::acquire::FunctionInterface::getCurrentCaptureBufferLayout** use the constructor accepting a **mvIMPACT::acquire::Request** pointer!
        :type codec: int
        :param codec: [in] The codec that shall be used while encoding the images into the stream.
        :type quality_pc: int
        :param quality_pc: [in] The quality of the resulting video stream in percent. The higher this value the larger the file will get. This value is only taken into account for the following codecs: **mvIMPACT::acquire::vcH264**, **mvIMPACT::acquire::vcH265**
        :type bitrate: int
        :param bitrate: [in] The bitrate of the resulting video stream in kBit/s. The higher this value the larger the file will get. This value is only taken into account for the following codecs: **mvIMPACT::acquire::vcMPEG2**.

        |

        *Overload 2:*
         Creates a new video stream file.
        Notes: 
        Internally the FFmpeg project (see 'LegalNotice_UsedThirdPartySoftware_FFmpeg' section) is used for this operation. If the corresponding libraries
        cannot be located in one of the supported versions on the host system calling this constructor will raise an exception.

        :type fileName: string
        :param fileName: [in] The name or full path of the file to create. The recommended file extensions for files can be found where the **mvIMPACT::acquire::TVideoCodec** enumeration is documented
        :type imageWidth: int
        :param imageWidth: [in] The input image width in pixels
        :type imageHeight: int
        :param imageHeight: [in] The input image height in pixels
        :type codec: int
        :param codec: [in] The codec that shall be used while encoding the images into the stream.
        :type quality_pc: int
        :param quality_pc: [in] The quality of the resulting video stream in percent. The higher this value the larger the file will get. This value is only taken into account for the following codecs: **mvIMPACT::acquire::vcH264**, **mvIMPACT::acquire::vcH265**
        :type bitrate: int
        :param bitrate: [in] The bitrate of the resulting video stream in kBit/s. The higher this value the larger the file will get. This value is only taken into account for the following codecs: **mvIMPACT::acquire::vcMPEG2**.

        |

        *Overload 3:*
         Creates a new video stream file.
        Notes: 
        Internally the FFmpeg project (see 'LegalNotice_UsedThirdPartySoftware_FFmpeg' section) is used for this operation. If the corresponding libraries
        cannot be located in one of the supported versions on the host system calling this constructor will raise an exception.

        :type fileName: string
        :param fileName: [in] The name or full path of the file to create. The recommended file extensions for files can be found where the **mvIMPACT::acquire::TVideoCodec** enumeration is documented
        :type imageWidth: int
        :param imageWidth: [in] The input image width in pixels
        :type imageHeight: int
        :param imageHeight: [in] The input image height in pixels
        :type codec: int
        :param codec: [in] The codec that shall be used while encoding the images into the stream.
        :type quality_pc: int
        :param quality_pc: [in] The quality of the resulting video stream in percent. The higher this value the larger the file will get. This value is only taken into account for the following codecs: **mvIMPACT::acquire::vcH264**, **mvIMPACT::acquire::vcH265**
        :param bitrate: [in] The bitrate of the resulting video stream in kBit/s. The higher this value the larger the file will get. This value is only taken into account for the following codecs: **mvIMPACT::acquire::vcMPEG2**.

        |

        *Overload 4:*
         Creates a new video stream file.
        Notes: 
        Internally the FFmpeg project (see 'LegalNotice_UsedThirdPartySoftware_FFmpeg' section) is used for this operation. If the corresponding libraries
        cannot be located in one of the supported versions on the host system calling this constructor will raise an exception.

        :type fileName: string
        :param fileName: [in] The name or full path of the file to create. The recommended file extensions for files can be found where the **mvIMPACT::acquire::TVideoCodec** enumeration is documented
        :type imageWidth: int
        :param imageWidth: [in] The input image width in pixels
        :type imageHeight: int
        :param imageHeight: [in] The input image height in pixels
        :type codec: int
        :param codec: [in] The codec that shall be used while encoding the images into the stream.
        :param quality_pc: [in] The quality of the resulting video stream in percent. The higher this value the larger the file will get. This value is only taken into account for the following codecs: **mvIMPACT::acquire::vcH264**, **mvIMPACT::acquire::vcH265**
        :param bitrate: [in] The bitrate of the resulting video stream in kBit/s. The higher this value the larger the file will get. This value is only taken into account for the following codecs: **mvIMPACT::acquire::vcMPEG2**.

        |

        *Overload 5:*
         Creates a new video stream file.
        Notes: 
        Internally the FFmpeg project (see 'LegalNotice_UsedThirdPartySoftware_FFmpeg' section) is used for this operation. If the corresponding libraries
        cannot be located in one of the supported versions on the host system calling this constructor will raise an exception.

        :type fileName: string
        :param fileName: [in] The name or full path of the file to create. The recommended file extensions for files can be found where the **mvIMPACT::acquire::TVideoCodec** enumeration is documented
        :type imageWidth: int
        :param imageWidth: [in] The input image width in pixels
        :type imageHeight: int
        :param imageHeight: [in] The input image height in pixels
        :param codec: [in] The codec that shall be used while encoding the images into the stream.
        :param quality_pc: [in] The quality of the resulting video stream in percent. The higher this value the larger the file will get. This value is only taken into account for the following codecs: **mvIMPACT::acquire::vcH264**, **mvIMPACT::acquire::vcH265**
        :param bitrate: [in] The bitrate of the resulting video stream in kBit/s. The higher this value the larger the file will get. This value is only taken into account for the following codecs: **mvIMPACT::acquire::vcMPEG2**.

        |

        *Overload 6:*
         Creates a new video stream file.
        Notes: 
        Internally the FFmpeg project (see 'LegalNotice_UsedThirdPartySoftware_FFmpeg' section) is used for this operation. If the corresponding libraries
        cannot be located in one of the supported versions on the host system calling this constructor will raise an exception.

        :type fileName: string
        :param fileName: [in] The name or full path of the file to create. The recommended file extensions for files can be found where the **mvIMPACT::acquire::TVideoCodec** enumeration is documented
        :type pRequest: :py:class:`Request`
        :param pRequest: [in] A **mvIMPACT::acquire::Request** object carrying the image related information that are about to get stored in the stream. This can either be extracted from a real **mvIMPACT::acquire::Request** object captured previously or by calling the **mvIMPACT::acquire::FunctionInterface::getCurrentCaptureBufferLayout** function after setting up the device completely. To create a stream from a list of files e.g. on a hard-disc use the **mvIMPACT::acquire::labs::VideoStream** constructor accepting a **mvIMPACT::acquire::ImageBufferDesc** instead! Create instances of b mvIMPACT::acquire::ImageBufferDesc objects from files call the **mvIMPACT::acquire::ImageBufferDesc** constructor accepting a file name.
        :type codec: int
        :param codec: [in] The codec that shall be used while encoding the images into the stream.
        :type quality_pc: int
        :param quality_pc: [in] The quality of the resulting video stream in percent. The higher this value the larger the file will get. This value is only taken into account for the following codecs: **mvIMPACT::acquire::vcH264**, **mvIMPACT::acquire::vcH265**
        :type bitrate: int
        :param bitrate: [in] The bitrate of the resulting video stream in kBit/s. The higher this value the larger the file will get. This value is only taken into account for the following codecs: **mvIMPACT::acquire::vcMPEG2**.

        |

        *Overload 7:*
         Creates a new video stream file.
        Notes: 
        Internally the FFmpeg project (see 'LegalNotice_UsedThirdPartySoftware_FFmpeg' section) is used for this operation. If the corresponding libraries
        cannot be located in one of the supported versions on the host system calling this constructor will raise an exception.

        :type fileName: string
        :param fileName: [in] The name or full path of the file to create. The recommended file extensions for files can be found where the **mvIMPACT::acquire::TVideoCodec** enumeration is documented
        :type pRequest: :py:class:`Request`
        :param pRequest: [in] A **mvIMPACT::acquire::Request** object carrying the image related information that are about to get stored in the stream. This can either be extracted from a real **mvIMPACT::acquire::Request** object captured previously or by calling the **mvIMPACT::acquire::FunctionInterface::getCurrentCaptureBufferLayout** function after setting up the device completely. To create a stream from a list of files e.g. on a hard-disc use the **mvIMPACT::acquire::labs::VideoStream** constructor accepting a **mvIMPACT::acquire::ImageBufferDesc** instead! Create instances of b mvIMPACT::acquire::ImageBufferDesc objects from files call the **mvIMPACT::acquire::ImageBufferDesc** constructor accepting a file name.
        :type codec: int
        :param codec: [in] The codec that shall be used while encoding the images into the stream.
        :type quality_pc: int
        :param quality_pc: [in] The quality of the resulting video stream in percent. The higher this value the larger the file will get. This value is only taken into account for the following codecs: **mvIMPACT::acquire::vcH264**, **mvIMPACT::acquire::vcH265**
        :param bitrate: [in] The bitrate of the resulting video stream in kBit/s. The higher this value the larger the file will get. This value is only taken into account for the following codecs: **mvIMPACT::acquire::vcMPEG2**.

        |

        *Overload 8:*
         Creates a new video stream file.
        Notes: 
        Internally the FFmpeg project (see 'LegalNotice_UsedThirdPartySoftware_FFmpeg' section) is used for this operation. If the corresponding libraries
        cannot be located in one of the supported versions on the host system calling this constructor will raise an exception.

        :type fileName: string
        :param fileName: [in] The name or full path of the file to create. The recommended file extensions for files can be found where the **mvIMPACT::acquire::TVideoCodec** enumeration is documented
        :type pRequest: :py:class:`Request`
        :param pRequest: [in] A **mvIMPACT::acquire::Request** object carrying the image related information that are about to get stored in the stream. This can either be extracted from a real **mvIMPACT::acquire::Request** object captured previously or by calling the **mvIMPACT::acquire::FunctionInterface::getCurrentCaptureBufferLayout** function after setting up the device completely. To create a stream from a list of files e.g. on a hard-disc use the **mvIMPACT::acquire::labs::VideoStream** constructor accepting a **mvIMPACT::acquire::ImageBufferDesc** instead! Create instances of b mvIMPACT::acquire::ImageBufferDesc objects from files call the **mvIMPACT::acquire::ImageBufferDesc** constructor accepting a file name.
        :type codec: int
        :param codec: [in] The codec that shall be used while encoding the images into the stream.
        :param quality_pc: [in] The quality of the resulting video stream in percent. The higher this value the larger the file will get. This value is only taken into account for the following codecs: **mvIMPACT::acquire::vcH264**, **mvIMPACT::acquire::vcH265**
        :param bitrate: [in] The bitrate of the resulting video stream in kBit/s. The higher this value the larger the file will get. This value is only taken into account for the following codecs: **mvIMPACT::acquire::vcMPEG2**.

        |

        *Overload 9:*
         Creates a new video stream file.
        Notes: 
        Internally the FFmpeg project (see 'LegalNotice_UsedThirdPartySoftware_FFmpeg' section) is used for this operation. If the corresponding libraries
        cannot be located in one of the supported versions on the host system calling this constructor will raise an exception.

        :type fileName: string
        :param fileName: [in] The name or full path of the file to create. The recommended file extensions for files can be found where the **mvIMPACT::acquire::TVideoCodec** enumeration is documented
        :type pRequest: :py:class:`Request`
        :param pRequest: [in] A **mvIMPACT::acquire::Request** object carrying the image related information that are about to get stored in the stream. This can either be extracted from a real **mvIMPACT::acquire::Request** object captured previously or by calling the **mvIMPACT::acquire::FunctionInterface::getCurrentCaptureBufferLayout** function after setting up the device completely. To create a stream from a list of files e.g. on a hard-disc use the **mvIMPACT::acquire::labs::VideoStream** constructor accepting a **mvIMPACT::acquire::ImageBufferDesc** instead! Create instances of b mvIMPACT::acquire::ImageBufferDesc objects from files call the **mvIMPACT::acquire::ImageBufferDesc** constructor accepting a file name.
        :param codec: [in] The codec that shall be used while encoding the images into the stream.
        :param quality_pc: [in] The quality of the resulting video stream in percent. The higher this value the larger the file will get. This value is only taken into account for the following codecs: **mvIMPACT::acquire::vcH264**, **mvIMPACT::acquire::vcH265**
        :param bitrate: [in] The bitrate of the resulting video stream in kBit/s. The higher this value the larger the file will get. This value is only taken into account for the following codecs: **mvIMPACT::acquire::vcMPEG2**.
        """
        lib_mvIMPACT_acquire.VideoStream_swiginit(self, lib_mvIMPACT_acquire.new_VideoStream(*args))
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_VideoStream

    def getFileName(self):
        r"""
         Returns the file name of this video stream.
        This function returns the file name of this video stream.

        Since: 2.39.0

         :rtype: string
         :return: The file name of this video stream.
        """
        return lib_mvIMPACT_acquire.VideoStream_getFileName(self)

    def getCodec(self):
        r"""
         Returns the codec used by this video stream.
        This function returns the codec used by this video stream.

        Since: 2.39.0

         :rtype: int
         :return: The codec used by this video stream.
        """
        return lib_mvIMPACT_acquire.VideoStream_getCodec(self)

    def getCodecAsString(self, *args):
        r"""
        *Overload 1:*
         Returns the a string representation for a video codec.
        This function returns a string representation for a video codec.

        Since: 2.39.0

         :rtype: string
         :return: A string representation for a video codec.

        |

        *Overload 2:*
         Returns the codec used by this video stream as a string.
        This function returns the codec used by this video stream as a string.

        Since: 2.39.0

         :rtype: string
         :return: The codec used by this video stream as a string.
        """
        return lib_mvIMPACT_acquire.VideoStream_getCodecAsString(self, *args)

    @staticmethod
    def isAPIAvailable():
        r"""
         Checks if the video stream API is available.
        This function checks if the video stream API is available.

        Since: 2.39.0

        :rtype: boolean
        :return: 
             - true if the video stream API is available thus video streams can be created
             - false otherwise.
        """
        return lib_mvIMPACT_acquire.VideoStream_isAPIAvailable()

    def saveImage(self, *args):
        r"""
        *Overload 1:*
         Stores an image into the video stream.
         This function stores an image into the video stream.

         Notes: 
         Internally the FFmpeg project (see 'LegalNotice_UsedThirdPartySoftware_FFmpeg' section as well as the remarks made here: **mvIMPACT::acquire::labs::VideoStream)** is used for this operation. If the corresponding libraries
         cannot be located in one of the supported versions on the host system calling this function will fail.

        Since: 2.39.0

         :rtype: int
         :return: 
             - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
             - **mvIMPACT::acquire::DMR_LIBRARY_NOT_FOUND** if no compatible version of the FFmpeg libraries could be located on the host system.
             - **mvIMPACT::acquire::DEV_UNSUPPORTED_PARAMETER** if a pixel format has been passed to the function that is not supported by the internal algorithms.
             - **mvIMPACT::acquire::DEV_INPUT_PARAM_INVALID** e.g. if a pixel format has been passed to the function that is not supported by the FFmpeg libraries.
             - A negative error code of type **::TDMR_ERROR** otherwise.

        :type pBuffer: :py:class:`ImageBuffer`
        :param pBuffer: [in] The image to encode and store.
        :type timestamp_us: int
        :param timestamp_us: [in] A timestamp(in us) to associate this image with. This can be 0 if no timestamp is available.

        |

        *Overload 2:*
         Encodes and stores the image associated with the **mvIMPACT::acquire::Request** object into the stream.
         This function stores the image associated with an **mvIMPACT::acquire::Request** object into the video stream.

         Notes: 
         Internally the FFmpeg project (see 'LegalNotice_UsedThirdPartySoftware_FFmpeg' section as well as the remarks made here: **mvIMPACT::acquire::labs::VideoStream)** is used for this operation. If the corresponding libraries
         cannot be located in one of the supported versions on the host system calling this function will fail.

        Since: 2.39.0

         :rtype: int
         :return: 
             - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
             - **mvIMPACT::acquire::DMR_LIBRARY_NOT_FOUND** if no compatible version of the FFmpeg libraries could be located on the host system.
             - **mvIMPACT::acquire::DEV_UNSUPPORTED_PARAMETER** if a pixel format has been passed to the function that is not supported by the internal algorithms.
             - **mvIMPACT::acquire::DEV_INPUT_PARAM_INVALID** e.g. if a pixel format has been passed to the function that is not supported by the FFmpeg libraries.
             - A negative error code of type **::TDMR_ERROR** otherwise.

        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type pRequest: :py:class:`Request`
        :param pRequest: [in] A pointer to the **mvIMPACT::acquire::Request** object carrying the image to encode and store.
        """
        return lib_mvIMPACT_acquire.VideoStream_saveImage(self, *args)

# Register VideoStream in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.VideoStream_swigregister(VideoStream)

def VideoStream_isAPIAvailable():
    r"""
     Checks if the video stream API is available.
    This function checks if the video stream API is available.

    Since: 2.39.0

    :rtype: boolean
    :return: 
         - true if the video stream API is available thus video streams can be created
         - false otherwise.
    """
    return lib_mvIMPACT_acquire.VideoStream_isAPIAvailable()

class PropertyI(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< int >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyI_swiginit(self, lib_mvIMPACT_acquire.new_PropertyI(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< int >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,int >,std::allocator< std::pair< std::string,int > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyI_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyI_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyI_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< int >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyI_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< int >
         :return: A const reference to the calling property.

        :type sequence: std::vector< int,std::allocator< int > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyI_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyI_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyI_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyI_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< int,std::allocator< int > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< int,std::allocator< int > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< int,std::allocator< int > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< int,std::allocator< int > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< int,std::allocator< int > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< int,std::allocator< int > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyI_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< int >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< int >
         :return: A const 'self' reference.

        :type sequence: std::vector< int,std::allocator< int > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< int >
         :return: A const 'self' reference.

        :type sequence: std::vector< int,std::allocator< int > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< int >
         :return: A const 'self' reference.

        :type sequence: std::vector< int,std::allocator< int > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< int >
         :return: A const 'self' reference.

        :type sequence: std::vector< int,std::allocator< int > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyI_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyI

# Register PropertyI in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyI_swigregister(PropertyI)

class pairstringint(object):
    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):
        lib_mvIMPACT_acquire.pairstringint_swiginit(self, lib_mvIMPACT_acquire.new_pairstringint(*args))
    first = property(lib_mvIMPACT_acquire.pairstringint_first_get, lib_mvIMPACT_acquire.pairstringint_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringint_second_get, lib_mvIMPACT_acquire.pairstringint_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringint

# Register pairstringint in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringint_swigregister(pairstringint)

class PropertyIAcquisitionField(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIAcquisitionField_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIAcquisitionField(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TAcquisitionField >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TAcquisitionField > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIAcquisitionField_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIAcquisitionField_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIAcquisitionField_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIAcquisitionField_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIAcquisitionField_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIAcquisitionField_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIAcquisitionField_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIAcquisitionField_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIAcquisitionField_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionField >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TAcquisitionField,std::allocator< mvIMPACT::acquire::TAcquisitionField > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIAcquisitionField_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIAcquisitionField

# Register PropertyIAcquisitionField in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIAcquisitionField_swigregister(PropertyIAcquisitionField)

class pairstringTAcquisitionField(object):
    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):
        lib_mvIMPACT_acquire.pairstringTAcquisitionField_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTAcquisitionField(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTAcquisitionField_first_get, lib_mvIMPACT_acquire.pairstringTAcquisitionField_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTAcquisitionField_second_get, lib_mvIMPACT_acquire.pairstringTAcquisitionField_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTAcquisitionField

# Register pairstringTAcquisitionField in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTAcquisitionField_swigregister(pairstringTAcquisitionField)

class PropertyIAcquisitionMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIAcquisitionMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIAcquisitionMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TAcquisitionMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIAcquisitionMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIAcquisitionMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIAcquisitionMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIAcquisitionMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIAcquisitionMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIAcquisitionMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIAcquisitionMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIAcquisitionMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIAcquisitionMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TAcquisitionMode,std::allocator< mvIMPACT::acquire::TAcquisitionMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIAcquisitionMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIAcquisitionMode

# Register PropertyIAcquisitionMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIAcquisitionMode_swigregister(PropertyIAcquisitionMode)

class pairstringTAcquisitionMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTAcquisitionMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTAcquisitionMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTAcquisitionMode_first_get, lib_mvIMPACT_acquire.pairstringTAcquisitionMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTAcquisitionMode_second_get, lib_mvIMPACT_acquire.pairstringTAcquisitionMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTAcquisitionMode

# Register pairstringTAcquisitionMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTAcquisitionMode_swigregister(pairstringTAcquisitionMode)

class PropertyIAcquisitionStartStopBehaviour(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIAcquisitionStartStopBehaviour_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIAcquisitionStartStopBehaviour(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TAcquisitionStartStopBehaviour > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIAcquisitionStartStopBehaviour_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIAcquisitionStartStopBehaviour_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIAcquisitionStartStopBehaviour_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIAcquisitionStartStopBehaviour_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIAcquisitionStartStopBehaviour_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIAcquisitionStartStopBehaviour_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIAcquisitionStartStopBehaviour_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIAcquisitionStartStopBehaviour_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIAcquisitionStartStopBehaviour_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAcquisitionStartStopBehaviour >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TAcquisitionStartStopBehaviour,std::allocator< mvIMPACT::acquire::TAcquisitionStartStopBehaviour > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIAcquisitionStartStopBehaviour_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIAcquisitionStartStopBehaviour

# Register PropertyIAcquisitionStartStopBehaviour in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIAcquisitionStartStopBehaviour_swigregister(PropertyIAcquisitionStartStopBehaviour)

class pairstringTAcquisitionStartStopBehaviour(object):
    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):
        lib_mvIMPACT_acquire.pairstringTAcquisitionStartStopBehaviour_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTAcquisitionStartStopBehaviour(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTAcquisitionStartStopBehaviour_first_get, lib_mvIMPACT_acquire.pairstringTAcquisitionStartStopBehaviour_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTAcquisitionStartStopBehaviour_second_get, lib_mvIMPACT_acquire.pairstringTAcquisitionStartStopBehaviour_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTAcquisitionStartStopBehaviour

# Register pairstringTAcquisitionStartStopBehaviour in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTAcquisitionStartStopBehaviour_swigregister(pairstringTAcquisitionStartStopBehaviour)

class PropertyIAoiMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIAoiMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIAoiMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TAoiMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TAoiMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIAoiMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIAoiMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIAoiMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIAoiMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIAoiMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIAoiMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIAoiMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIAoiMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIAoiMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAoiMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TAoiMode,std::allocator< mvIMPACT::acquire::TAoiMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIAoiMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIAoiMode

# Register PropertyIAoiMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIAoiMode_swigregister(PropertyIAoiMode)

class pairstringTAoiMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTAoiMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTAoiMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTAoiMode_first_get, lib_mvIMPACT_acquire.pairstringTAoiMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTAoiMode_second_get, lib_mvIMPACT_acquire.pairstringTAoiMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTAoiMode

# Register pairstringTAoiMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTAoiMode_swigregister(pairstringTAoiMode)

class PropertyIAutoControlSpeed(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIAutoControlSpeed_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIAutoControlSpeed(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TAutoControlSpeed > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIAutoControlSpeed_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIAutoControlSpeed_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIAutoControlSpeed_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIAutoControlSpeed_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIAutoControlSpeed_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIAutoControlSpeed_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIAutoControlSpeed_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIAutoControlSpeed_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIAutoControlSpeed_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlSpeed >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoControlSpeed,std::allocator< mvIMPACT::acquire::TAutoControlSpeed > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIAutoControlSpeed_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIAutoControlSpeed

# Register PropertyIAutoControlSpeed in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIAutoControlSpeed_swigregister(PropertyIAutoControlSpeed)

class pairstringTAutoControlSpeed(object):
    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):
        lib_mvIMPACT_acquire.pairstringTAutoControlSpeed_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTAutoControlSpeed(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTAutoControlSpeed_first_get, lib_mvIMPACT_acquire.pairstringTAutoControlSpeed_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTAutoControlSpeed_second_get, lib_mvIMPACT_acquire.pairstringTAutoControlSpeed_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTAutoControlSpeed

# Register pairstringTAutoControlSpeed in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTAutoControlSpeed_swigregister(pairstringTAutoControlSpeed)

class PropertyIAutoControlMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIAutoControlMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIAutoControlMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TAutoControlMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TAutoControlMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIAutoControlMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIAutoControlMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIAutoControlMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIAutoControlMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIAutoControlMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIAutoControlMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIAutoControlMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIAutoControlMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIAutoControlMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoControlMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoControlMode,std::allocator< mvIMPACT::acquire::TAutoControlMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIAutoControlMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIAutoControlMode

# Register PropertyIAutoControlMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIAutoControlMode_swigregister(PropertyIAutoControlMode)

class pairstringTAutoControlMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTAutoControlMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTAutoControlMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTAutoControlMode_first_get, lib_mvIMPACT_acquire.pairstringTAutoControlMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTAutoControlMode_second_get, lib_mvIMPACT_acquire.pairstringTAutoControlMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTAutoControlMode

# Register pairstringTAutoControlMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTAutoControlMode_swigregister(pairstringTAutoControlMode)

class PropertyIAutoExposureControl(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIAutoExposureControl_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIAutoExposureControl(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TAutoExposureControl > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIAutoExposureControl_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIAutoExposureControl_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIAutoExposureControl_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIAutoExposureControl_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIAutoExposureControl_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIAutoExposureControl_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIAutoExposureControl_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIAutoExposureControl_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIAutoExposureControl_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoExposureControl >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoExposureControl,std::allocator< mvIMPACT::acquire::TAutoExposureControl > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIAutoExposureControl_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIAutoExposureControl

# Register PropertyIAutoExposureControl in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIAutoExposureControl_swigregister(PropertyIAutoExposureControl)

class pairstringTAutoExposureControl(object):
    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):
        lib_mvIMPACT_acquire.pairstringTAutoExposureControl_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTAutoExposureControl(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTAutoExposureControl_first_get, lib_mvIMPACT_acquire.pairstringTAutoExposureControl_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTAutoExposureControl_second_get, lib_mvIMPACT_acquire.pairstringTAutoExposureControl_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTAutoExposureControl

# Register pairstringTAutoExposureControl in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTAutoExposureControl_swigregister(pairstringTAutoExposureControl)

class PropertyIAutoGainControl(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIAutoGainControl_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIAutoGainControl(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TAutoGainControl >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TAutoGainControl > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIAutoGainControl_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIAutoGainControl_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIAutoGainControl_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIAutoGainControl_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIAutoGainControl_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIAutoGainControl_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIAutoGainControl_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIAutoGainControl_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIAutoGainControl_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoGainControl >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoGainControl,std::allocator< mvIMPACT::acquire::TAutoGainControl > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIAutoGainControl_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIAutoGainControl

# Register PropertyIAutoGainControl in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIAutoGainControl_swigregister(PropertyIAutoGainControl)

class pairstringTAutoGainControl(object):
    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):
        lib_mvIMPACT_acquire.pairstringTAutoGainControl_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTAutoGainControl(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTAutoGainControl_first_get, lib_mvIMPACT_acquire.pairstringTAutoGainControl_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTAutoGainControl_second_get, lib_mvIMPACT_acquire.pairstringTAutoGainControl_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTAutoGainControl

# Register pairstringTAutoGainControl in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTAutoGainControl_swigregister(pairstringTAutoGainControl)

class PropertyIAutoOffsetCalibration(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIAutoOffsetCalibration_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIAutoOffsetCalibration(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TAutoOffsetCalibration > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIAutoOffsetCalibration_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIAutoOffsetCalibration_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIAutoOffsetCalibration_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIAutoOffsetCalibration_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIAutoOffsetCalibration_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIAutoOffsetCalibration_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIAutoOffsetCalibration_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIAutoOffsetCalibration_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIAutoOffsetCalibration_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TAutoOffsetCalibration >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TAutoOffsetCalibration,std::allocator< mvIMPACT::acquire::TAutoOffsetCalibration > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIAutoOffsetCalibration_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIAutoOffsetCalibration

# Register PropertyIAutoOffsetCalibration in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIAutoOffsetCalibration_swigregister(PropertyIAutoOffsetCalibration)

class pairstringTAutoOffsetCalibration(object):
    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):
        lib_mvIMPACT_acquire.pairstringTAutoOffsetCalibration_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTAutoOffsetCalibration(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTAutoOffsetCalibration_first_get, lib_mvIMPACT_acquire.pairstringTAutoOffsetCalibration_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTAutoOffsetCalibration_second_get, lib_mvIMPACT_acquire.pairstringTAutoOffsetCalibration_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTAutoOffsetCalibration

# Register pairstringTAutoOffsetCalibration in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTAutoOffsetCalibration_swigregister(pairstringTAutoOffsetCalibration)

class PropertyIBayerConversionMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIBayerConversionMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIBayerConversionMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TBayerConversionMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIBayerConversionMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIBayerConversionMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIBayerConversionMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIBayerConversionMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIBayerConversionMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIBayerConversionMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIBayerConversionMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIBayerConversionMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIBayerConversionMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerConversionMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TBayerConversionMode,std::allocator< mvIMPACT::acquire::TBayerConversionMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIBayerConversionMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIBayerConversionMode

# Register PropertyIBayerConversionMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIBayerConversionMode_swigregister(PropertyIBayerConversionMode)

class pairstringTBayerConversionMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTBayerConversionMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTBayerConversionMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTBayerConversionMode_first_get, lib_mvIMPACT_acquire.pairstringTBayerConversionMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTBayerConversionMode_second_get, lib_mvIMPACT_acquire.pairstringTBayerConversionMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTBayerConversionMode

# Register pairstringTBayerConversionMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTBayerConversionMode_swigregister(pairstringTBayerConversionMode)

class PropertyIBayerMosaicParity(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIBayerMosaicParity_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIBayerMosaicParity(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TBayerMosaicParity > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIBayerMosaicParity_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIBayerMosaicParity_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIBayerMosaicParity_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIBayerMosaicParity_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIBayerMosaicParity_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIBayerMosaicParity_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIBayerMosaicParity_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIBayerMosaicParity_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIBayerMosaicParity_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerMosaicParity >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TBayerMosaicParity,std::allocator< mvIMPACT::acquire::TBayerMosaicParity > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIBayerMosaicParity_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIBayerMosaicParity

# Register PropertyIBayerMosaicParity in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIBayerMosaicParity_swigregister(PropertyIBayerMosaicParity)

class pairstringTBayerMosaicParity(object):
    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):
        lib_mvIMPACT_acquire.pairstringTBayerMosaicParity_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTBayerMosaicParity(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTBayerMosaicParity_first_get, lib_mvIMPACT_acquire.pairstringTBayerMosaicParity_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTBayerMosaicParity_second_get, lib_mvIMPACT_acquire.pairstringTBayerMosaicParity_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTBayerMosaicParity

# Register pairstringTBayerMosaicParity in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTBayerMosaicParity_swigregister(pairstringTBayerMosaicParity)

class PropertyIBayerWhiteBalanceResult(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIBayerWhiteBalanceResult_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIBayerWhiteBalanceResult(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TBayerWhiteBalanceResult > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIBayerWhiteBalanceResult_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIBayerWhiteBalanceResult_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIBayerWhiteBalanceResult_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIBayerWhiteBalanceResult_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIBayerWhiteBalanceResult_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIBayerWhiteBalanceResult_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIBayerWhiteBalanceResult_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIBayerWhiteBalanceResult_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIBayerWhiteBalanceResult_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBayerWhiteBalanceResult >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TBayerWhiteBalanceResult,std::allocator< mvIMPACT::acquire::TBayerWhiteBalanceResult > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIBayerWhiteBalanceResult_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIBayerWhiteBalanceResult

# Register PropertyIBayerWhiteBalanceResult in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIBayerWhiteBalanceResult_swigregister(PropertyIBayerWhiteBalanceResult)

class pairstringTBayerWhiteBalanceResult(object):
    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):
        lib_mvIMPACT_acquire.pairstringTBayerWhiteBalanceResult_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTBayerWhiteBalanceResult(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTBayerWhiteBalanceResult_first_get, lib_mvIMPACT_acquire.pairstringTBayerWhiteBalanceResult_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTBayerWhiteBalanceResult_second_get, lib_mvIMPACT_acquire.pairstringTBayerWhiteBalanceResult_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTBayerWhiteBalanceResult

# Register pairstringTBayerWhiteBalanceResult in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTBayerWhiteBalanceResult_swigregister(pairstringTBayerWhiteBalanceResult)

class PropertyIBlueFOXDigitalInputThreshold(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIBlueFOXDigitalInputThreshold_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIBlueFOXDigitalInputThreshold(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXDigitalInputThreshold_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXDigitalInputThreshold_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXDigitalInputThreshold_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXDigitalInputThreshold_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXDigitalInputThreshold_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXDigitalInputThreshold_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXDigitalInputThreshold_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXDigitalInputThreshold_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXDigitalInputThreshold_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold,std::allocator< mvIMPACT::acquire::TBlueFOXDigitalInputThreshold > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXDigitalInputThreshold_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIBlueFOXDigitalInputThreshold

# Register PropertyIBlueFOXDigitalInputThreshold in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIBlueFOXDigitalInputThreshold_swigregister(PropertyIBlueFOXDigitalInputThreshold)

class pairstringTBlueFOXDigitalInputThreshold(object):
    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):
        lib_mvIMPACT_acquire.pairstringTBlueFOXDigitalInputThreshold_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTBlueFOXDigitalInputThreshold(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTBlueFOXDigitalInputThreshold_first_get, lib_mvIMPACT_acquire.pairstringTBlueFOXDigitalInputThreshold_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTBlueFOXDigitalInputThreshold_second_get, lib_mvIMPACT_acquire.pairstringTBlueFOXDigitalInputThreshold_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTBlueFOXDigitalInputThreshold

# Register pairstringTBlueFOXDigitalInputThreshold in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTBlueFOXDigitalInputThreshold_swigregister(pairstringTBlueFOXDigitalInputThreshold)

class PropertyIBlueFOXFooterMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIBlueFOXFooterMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIBlueFOXFooterMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TBlueFOXFooterMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXFooterMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXFooterMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXFooterMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXFooterMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXFooterMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXFooterMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXFooterMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXFooterMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXFooterMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXFooterMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXFooterMode,std::allocator< mvIMPACT::acquire::TBlueFOXFooterMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXFooterMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIBlueFOXFooterMode

# Register PropertyIBlueFOXFooterMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIBlueFOXFooterMode_swigregister(PropertyIBlueFOXFooterMode)

class pairstringTBlueFOXFooterMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTBlueFOXFooterMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTBlueFOXFooterMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTBlueFOXFooterMode_first_get, lib_mvIMPACT_acquire.pairstringTBlueFOXFooterMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTBlueFOXFooterMode_second_get, lib_mvIMPACT_acquire.pairstringTBlueFOXFooterMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTBlueFOXFooterMode

# Register pairstringTBlueFOXFooterMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTBlueFOXFooterMode_swigregister(pairstringTBlueFOXFooterMode)

class PropertyIBlueFOXInfoSensorCapabilities(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIBlueFOXInfoSensorCapabilities_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIBlueFOXInfoSensorCapabilities(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXInfoSensorCapabilities_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXInfoSensorCapabilities_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXInfoSensorCapabilities_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXInfoSensorCapabilities_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXInfoSensorCapabilities_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXInfoSensorCapabilities_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities,std::allocator< mvIMPACT::acquire::TBlueFOXInfoSensorCapabilities > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXInfoSensorCapabilities_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIBlueFOXInfoSensorCapabilities

# Register PropertyIBlueFOXInfoSensorCapabilities in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIBlueFOXInfoSensorCapabilities_swigregister(PropertyIBlueFOXInfoSensorCapabilities)

class pairstringTBlueFOXInfoSensorCapabilities(object):
    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):
        lib_mvIMPACT_acquire.pairstringTBlueFOXInfoSensorCapabilities_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTBlueFOXInfoSensorCapabilities(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTBlueFOXInfoSensorCapabilities_first_get, lib_mvIMPACT_acquire.pairstringTBlueFOXInfoSensorCapabilities_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTBlueFOXInfoSensorCapabilities_second_get, lib_mvIMPACT_acquire.pairstringTBlueFOXInfoSensorCapabilities_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTBlueFOXInfoSensorCapabilities

# Register pairstringTBlueFOXInfoSensorCapabilities in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTBlueFOXInfoSensorCapabilities_swigregister(pairstringTBlueFOXInfoSensorCapabilities)

class PropertyIBlueFOXOffsetAutoBlackSpeed(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIBlueFOXOffsetAutoBlackSpeed_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIBlueFOXOffsetAutoBlackSpeed(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXOffsetAutoBlackSpeed_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXOffsetAutoBlackSpeed_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXOffsetAutoBlackSpeed_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXOffsetAutoBlackSpeed_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXOffsetAutoBlackSpeed_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed,std::allocator< mvIMPACT::acquire::TBlueFOXOffsetAutoBlackSpeed > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXOffsetAutoBlackSpeed_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIBlueFOXOffsetAutoBlackSpeed

# Register PropertyIBlueFOXOffsetAutoBlackSpeed in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIBlueFOXOffsetAutoBlackSpeed_swigregister(PropertyIBlueFOXOffsetAutoBlackSpeed)

class pairstringTBlueFOXOffsetAutoBlackSpeed(object):
    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):
        lib_mvIMPACT_acquire.pairstringTBlueFOXOffsetAutoBlackSpeed_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTBlueFOXOffsetAutoBlackSpeed(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTBlueFOXOffsetAutoBlackSpeed_first_get, lib_mvIMPACT_acquire.pairstringTBlueFOXOffsetAutoBlackSpeed_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTBlueFOXOffsetAutoBlackSpeed_second_get, lib_mvIMPACT_acquire.pairstringTBlueFOXOffsetAutoBlackSpeed_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTBlueFOXOffsetAutoBlackSpeed

# Register pairstringTBlueFOXOffsetAutoBlackSpeed in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTBlueFOXOffsetAutoBlackSpeed_swigregister(pairstringTBlueFOXOffsetAutoBlackSpeed)

class PropertyIBlueFOXSensorTiming(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIBlueFOXSensorTiming_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIBlueFOXSensorTiming(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TBlueFOXSensorTiming > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXSensorTiming_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXSensorTiming_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXSensorTiming_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXSensorTiming_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXSensorTiming_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXSensorTiming_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXSensorTiming_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXSensorTiming_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXSensorTiming_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXSensorTiming >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXSensorTiming,std::allocator< mvIMPACT::acquire::TBlueFOXSensorTiming > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXSensorTiming_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIBlueFOXSensorTiming

# Register PropertyIBlueFOXSensorTiming in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIBlueFOXSensorTiming_swigregister(PropertyIBlueFOXSensorTiming)

class pairstringTBlueFOXSensorTiming(object):
    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):
        lib_mvIMPACT_acquire.pairstringTBlueFOXSensorTiming_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTBlueFOXSensorTiming(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTBlueFOXSensorTiming_first_get, lib_mvIMPACT_acquire.pairstringTBlueFOXSensorTiming_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTBlueFOXSensorTiming_second_get, lib_mvIMPACT_acquire.pairstringTBlueFOXSensorTiming_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTBlueFOXSensorTiming

# Register pairstringTBlueFOXSensorTiming in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTBlueFOXSensorTiming_swigregister(pairstringTBlueFOXSensorTiming)

class PropertyIBlueFOXTransferSize(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIBlueFOXTransferSize_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIBlueFOXTransferSize(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TBlueFOXTransferSize > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXTransferSize_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXTransferSize_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXTransferSize_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXTransferSize_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXTransferSize_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXTransferSize_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXTransferSize_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXTransferSize_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXTransferSize_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBlueFOXTransferSize >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TBlueFOXTransferSize,std::allocator< mvIMPACT::acquire::TBlueFOXTransferSize > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIBlueFOXTransferSize_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIBlueFOXTransferSize

# Register PropertyIBlueFOXTransferSize in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIBlueFOXTransferSize_swigregister(PropertyIBlueFOXTransferSize)

class pairstringTBlueFOXTransferSize(object):
    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):
        lib_mvIMPACT_acquire.pairstringTBlueFOXTransferSize_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTBlueFOXTransferSize(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTBlueFOXTransferSize_first_get, lib_mvIMPACT_acquire.pairstringTBlueFOXTransferSize_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTBlueFOXTransferSize_second_get, lib_mvIMPACT_acquire.pairstringTBlueFOXTransferSize_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTBlueFOXTransferSize

# Register pairstringTBlueFOXTransferSize in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTBlueFOXTransferSize_swigregister(pairstringTBlueFOXTransferSize)

class PropertyIBoolean(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIBoolean_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIBoolean(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TBoolean >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TBoolean > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIBoolean_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIBoolean_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIBoolean_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIBoolean_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIBoolean_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIBoolean_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIBoolean_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIBoolean_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIBoolean_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TBoolean >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TBoolean,std::allocator< mvIMPACT::acquire::TBoolean > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIBoolean_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIBoolean

# Register PropertyIBoolean in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIBoolean_swigregister(PropertyIBoolean)

class pairstringTBoolean(object):
    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):
        lib_mvIMPACT_acquire.pairstringTBoolean_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTBoolean(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTBoolean_first_get, lib_mvIMPACT_acquire.pairstringTBoolean_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTBoolean_second_get, lib_mvIMPACT_acquire.pairstringTBoolean_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTBoolean

# Register pairstringTBoolean in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTBoolean_swigregister(pairstringTBoolean)

class PropertyICameraAoiMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyICameraAoiMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyICameraAoiMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraAoiMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyICameraAoiMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraAoiMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraAoiMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyICameraAoiMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyICameraAoiMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraAoiMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraAoiMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraAoiMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraAoiMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraAoiMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraAoiMode,std::allocator< mvIMPACT::acquire::TCameraAoiMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraAoiMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyICameraAoiMode

# Register PropertyICameraAoiMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyICameraAoiMode_swigregister(PropertyICameraAoiMode)

class pairstringTCameraAoiMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTCameraAoiMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTCameraAoiMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTCameraAoiMode_first_get, lib_mvIMPACT_acquire.pairstringTCameraAoiMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTCameraAoiMode_second_get, lib_mvIMPACT_acquire.pairstringTCameraAoiMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTCameraAoiMode

# Register pairstringTCameraAoiMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTCameraAoiMode_swigregister(pairstringTCameraAoiMode)

class PropertyICameraBinningMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyICameraBinningMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyICameraBinningMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraBinningMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyICameraBinningMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraBinningMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraBinningMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyICameraBinningMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyICameraBinningMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraBinningMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraBinningMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraBinningMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraBinningMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraBinningMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraBinningMode,std::allocator< mvIMPACT::acquire::TCameraBinningMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraBinningMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyICameraBinningMode

# Register PropertyICameraBinningMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyICameraBinningMode_swigregister(PropertyICameraBinningMode)

class pairstringTCameraBinningMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTCameraBinningMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTCameraBinningMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTCameraBinningMode_first_get, lib_mvIMPACT_acquire.pairstringTCameraBinningMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTCameraBinningMode_second_get, lib_mvIMPACT_acquire.pairstringTCameraBinningMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTCameraBinningMode

# Register pairstringTCameraBinningMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTCameraBinningMode_swigregister(pairstringTCameraBinningMode)

class PropertyICameraDataFormat(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyICameraDataFormat_swiginit(self, lib_mvIMPACT_acquire.new_PropertyICameraDataFormat(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraDataFormat > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyICameraDataFormat_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraDataFormat_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraDataFormat_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyICameraDataFormat_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyICameraDataFormat_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraDataFormat_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraDataFormat_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraDataFormat_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraDataFormat_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraDataFormat >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraDataFormat,std::allocator< mvIMPACT::acquire::TCameraDataFormat > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraDataFormat_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyICameraDataFormat

# Register PropertyICameraDataFormat in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyICameraDataFormat_swigregister(PropertyICameraDataFormat)

class pairstringTCameraDataFormat(object):
    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):
        lib_mvIMPACT_acquire.pairstringTCameraDataFormat_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTCameraDataFormat(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTCameraDataFormat_first_get, lib_mvIMPACT_acquire.pairstringTCameraDataFormat_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTCameraDataFormat_second_get, lib_mvIMPACT_acquire.pairstringTCameraDataFormat_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTCameraDataFormat

# Register pairstringTCameraDataFormat in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTCameraDataFormat_swigregister(pairstringTCameraDataFormat)

class PropertyICameraExposeMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyICameraExposeMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyICameraExposeMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraExposeMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyICameraExposeMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraExposeMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraExposeMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyICameraExposeMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyICameraExposeMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraExposeMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraExposeMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraExposeMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraExposeMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExposeMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraExposeMode,std::allocator< mvIMPACT::acquire::TCameraExposeMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraExposeMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyICameraExposeMode

# Register PropertyICameraExposeMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyICameraExposeMode_swigregister(PropertyICameraExposeMode)

class pairstringTCameraExposeMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTCameraExposeMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTCameraExposeMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTCameraExposeMode_first_get, lib_mvIMPACT_acquire.pairstringTCameraExposeMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTCameraExposeMode_second_get, lib_mvIMPACT_acquire.pairstringTCameraExposeMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTCameraExposeMode

# Register pairstringTCameraExposeMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTCameraExposeMode_swigregister(pairstringTCameraExposeMode)

class PropertyICameraExternalSyncEdge(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyICameraExternalSyncEdge_swiginit(self, lib_mvIMPACT_acquire.new_PropertyICameraExternalSyncEdge(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncEdge > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyICameraExternalSyncEdge_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraExternalSyncEdge_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraExternalSyncEdge_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyICameraExternalSyncEdge_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyICameraExternalSyncEdge_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraExternalSyncEdge_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraExternalSyncEdge_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraExternalSyncEdge_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraExternalSyncEdge_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncEdge >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraExternalSyncEdge,std::allocator< mvIMPACT::acquire::TCameraExternalSyncEdge > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraExternalSyncEdge_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyICameraExternalSyncEdge

# Register PropertyICameraExternalSyncEdge in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyICameraExternalSyncEdge_swigregister(PropertyICameraExternalSyncEdge)

class pairstringTCameraExternalSyncEdge(object):
    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):
        lib_mvIMPACT_acquire.pairstringTCameraExternalSyncEdge_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTCameraExternalSyncEdge(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTCameraExternalSyncEdge_first_get, lib_mvIMPACT_acquire.pairstringTCameraExternalSyncEdge_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTCameraExternalSyncEdge_second_get, lib_mvIMPACT_acquire.pairstringTCameraExternalSyncEdge_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTCameraExternalSyncEdge

# Register pairstringTCameraExternalSyncEdge in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTCameraExternalSyncEdge_swigregister(pairstringTCameraExternalSyncEdge)

class PropertyICameraExternalSyncOutput(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyICameraExternalSyncOutput_swiginit(self, lib_mvIMPACT_acquire.new_PropertyICameraExternalSyncOutput(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraExternalSyncOutput > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyICameraExternalSyncOutput_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraExternalSyncOutput_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraExternalSyncOutput_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyICameraExternalSyncOutput_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyICameraExternalSyncOutput_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraExternalSyncOutput_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraExternalSyncOutput_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraExternalSyncOutput_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraExternalSyncOutput_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraExternalSyncOutput >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraExternalSyncOutput,std::allocator< mvIMPACT::acquire::TCameraExternalSyncOutput > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraExternalSyncOutput_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyICameraExternalSyncOutput

# Register PropertyICameraExternalSyncOutput in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyICameraExternalSyncOutput_swigregister(PropertyICameraExternalSyncOutput)

class pairstringTCameraExternalSyncOutput(object):
    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):
        lib_mvIMPACT_acquire.pairstringTCameraExternalSyncOutput_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTCameraExternalSyncOutput(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTCameraExternalSyncOutput_first_get, lib_mvIMPACT_acquire.pairstringTCameraExternalSyncOutput_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTCameraExternalSyncOutput_second_get, lib_mvIMPACT_acquire.pairstringTCameraExternalSyncOutput_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTCameraExternalSyncOutput

# Register pairstringTCameraExternalSyncOutput in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTCameraExternalSyncOutput_swigregister(pairstringTCameraExternalSyncOutput)

class PropertyICameraFlashMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyICameraFlashMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyICameraFlashMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraFlashMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyICameraFlashMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraFlashMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraFlashMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyICameraFlashMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyICameraFlashMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraFlashMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraFlashMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraFlashMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraFlashMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraFlashMode,std::allocator< mvIMPACT::acquire::TCameraFlashMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraFlashMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyICameraFlashMode

# Register PropertyICameraFlashMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyICameraFlashMode_swigregister(PropertyICameraFlashMode)

class pairstringTCameraFlashMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTCameraFlashMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTCameraFlashMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTCameraFlashMode_first_get, lib_mvIMPACT_acquire.pairstringTCameraFlashMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTCameraFlashMode_second_get, lib_mvIMPACT_acquire.pairstringTCameraFlashMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTCameraFlashMode

# Register pairstringTCameraFlashMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTCameraFlashMode_swigregister(pairstringTCameraFlashMode)

class PropertyICameraFlashType(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyICameraFlashType_swiginit(self, lib_mvIMPACT_acquire.new_PropertyICameraFlashType(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraFlashType >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraFlashType > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyICameraFlashType_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraFlashType_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraFlashType_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyICameraFlashType_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyICameraFlashType_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraFlashType_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraFlashType_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraFlashType_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraFlashType_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraFlashType >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraFlashType,std::allocator< mvIMPACT::acquire::TCameraFlashType > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraFlashType_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyICameraFlashType

# Register PropertyICameraFlashType in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyICameraFlashType_swigregister(PropertyICameraFlashType)

class pairstringTCameraFlashType(object):
    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):
        lib_mvIMPACT_acquire.pairstringTCameraFlashType_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTCameraFlashType(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTCameraFlashType_first_get, lib_mvIMPACT_acquire.pairstringTCameraFlashType_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTCameraFlashType_second_get, lib_mvIMPACT_acquire.pairstringTCameraFlashType_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTCameraFlashType

# Register pairstringTCameraFlashType in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTCameraFlashType_swigregister(pairstringTCameraFlashType)

class PropertyICameraHDRMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyICameraHDRMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyICameraHDRMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraHDRMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyICameraHDRMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraHDRMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraHDRMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyICameraHDRMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyICameraHDRMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraHDRMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraHDRMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraHDRMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraHDRMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraHDRMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraHDRMode,std::allocator< mvIMPACT::acquire::TCameraHDRMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraHDRMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyICameraHDRMode

# Register PropertyICameraHDRMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyICameraHDRMode_swigregister(PropertyICameraHDRMode)

class pairstringTCameraHDRMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTCameraHDRMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTCameraHDRMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTCameraHDRMode_first_get, lib_mvIMPACT_acquire.pairstringTCameraHDRMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTCameraHDRMode_second_get, lib_mvIMPACT_acquire.pairstringTCameraHDRMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTCameraHDRMode

# Register pairstringTCameraHDRMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTCameraHDRMode_swigregister(pairstringTCameraHDRMode)

class PropertyICameraInterlacedType(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyICameraInterlacedType_swiginit(self, lib_mvIMPACT_acquire.new_PropertyICameraInterlacedType(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraInterlacedType > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyICameraInterlacedType_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraInterlacedType_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraInterlacedType_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyICameraInterlacedType_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyICameraInterlacedType_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraInterlacedType_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraInterlacedType_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraInterlacedType_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraInterlacedType_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraInterlacedType >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraInterlacedType,std::allocator< mvIMPACT::acquire::TCameraInterlacedType > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraInterlacedType_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyICameraInterlacedType

# Register PropertyICameraInterlacedType in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyICameraInterlacedType_swigregister(PropertyICameraInterlacedType)

class pairstringTCameraInterlacedType(object):
    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):
        lib_mvIMPACT_acquire.pairstringTCameraInterlacedType_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTCameraInterlacedType(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTCameraInterlacedType_first_get, lib_mvIMPACT_acquire.pairstringTCameraInterlacedType_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTCameraInterlacedType_second_get, lib_mvIMPACT_acquire.pairstringTCameraInterlacedType_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTCameraInterlacedType

# Register pairstringTCameraInterlacedType in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTCameraInterlacedType_swigregister(pairstringTCameraInterlacedType)

class PropertyICameraLinkDataValidMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyICameraLinkDataValidMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyICameraLinkDataValidMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraLinkDataValidMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyICameraLinkDataValidMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraLinkDataValidMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraLinkDataValidMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyICameraLinkDataValidMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyICameraLinkDataValidMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraLinkDataValidMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraLinkDataValidMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraLinkDataValidMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraLinkDataValidMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraLinkDataValidMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraLinkDataValidMode,std::allocator< mvIMPACT::acquire::TCameraLinkDataValidMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraLinkDataValidMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyICameraLinkDataValidMode

# Register PropertyICameraLinkDataValidMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyICameraLinkDataValidMode_swigregister(PropertyICameraLinkDataValidMode)

class pairstringTCameraLinkDataValidMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTCameraLinkDataValidMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTCameraLinkDataValidMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTCameraLinkDataValidMode_first_get, lib_mvIMPACT_acquire.pairstringTCameraLinkDataValidMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTCameraLinkDataValidMode_second_get, lib_mvIMPACT_acquire.pairstringTCameraLinkDataValidMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTCameraLinkDataValidMode

# Register pairstringTCameraLinkDataValidMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTCameraLinkDataValidMode_swigregister(pairstringTCameraLinkDataValidMode)

class PropertyICameraOutput(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyICameraOutput_swiginit(self, lib_mvIMPACT_acquire.new_PropertyICameraOutput(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraOutput >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraOutput > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyICameraOutput_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraOutput_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraOutput_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyICameraOutput_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyICameraOutput_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraOutput_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraOutput_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraOutput_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraOutput_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraOutput >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraOutput,std::allocator< mvIMPACT::acquire::TCameraOutput > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraOutput_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyICameraOutput

# Register PropertyICameraOutput in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyICameraOutput_swigregister(PropertyICameraOutput)

class pairstringTCameraOutput(object):
    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):
        lib_mvIMPACT_acquire.pairstringTCameraOutput_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTCameraOutput(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTCameraOutput_first_get, lib_mvIMPACT_acquire.pairstringTCameraOutput_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTCameraOutput_second_get, lib_mvIMPACT_acquire.pairstringTCameraOutput_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTCameraOutput

# Register pairstringTCameraOutput in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTCameraOutput_swigregister(pairstringTCameraOutput)

class PropertyICameraPixelClock(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyICameraPixelClock_swiginit(self, lib_mvIMPACT_acquire.new_PropertyICameraPixelClock(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraPixelClock > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyICameraPixelClock_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraPixelClock_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraPixelClock_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyICameraPixelClock_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyICameraPixelClock_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraPixelClock_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraPixelClock_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraPixelClock_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraPixelClock_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraPixelClock >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraPixelClock,std::allocator< mvIMPACT::acquire::TCameraPixelClock > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraPixelClock_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyICameraPixelClock

# Register PropertyICameraPixelClock in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyICameraPixelClock_swigregister(PropertyICameraPixelClock)

class pairstringTCameraPixelClock(object):
    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):
        lib_mvIMPACT_acquire.pairstringTCameraPixelClock_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTCameraPixelClock(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTCameraPixelClock_first_get, lib_mvIMPACT_acquire.pairstringTCameraPixelClock_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTCameraPixelClock_second_get, lib_mvIMPACT_acquire.pairstringTCameraPixelClock_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTCameraPixelClock

# Register pairstringTCameraPixelClock in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTCameraPixelClock_swigregister(pairstringTCameraPixelClock)

class PropertyICameraScanMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyICameraScanMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyICameraScanMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraScanMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraScanMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyICameraScanMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraScanMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraScanMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyICameraScanMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyICameraScanMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraScanMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraScanMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraScanMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraScanMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraScanMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraScanMode,std::allocator< mvIMPACT::acquire::TCameraScanMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraScanMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyICameraScanMode

# Register PropertyICameraScanMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyICameraScanMode_swigregister(PropertyICameraScanMode)

class pairstringTCameraScanMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTCameraScanMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTCameraScanMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTCameraScanMode_first_get, lib_mvIMPACT_acquire.pairstringTCameraScanMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTCameraScanMode_second_get, lib_mvIMPACT_acquire.pairstringTCameraScanMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTCameraScanMode

# Register pairstringTCameraScanMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTCameraScanMode_swigregister(pairstringTCameraScanMode)

class PropertyICameraSerialPortBaudRate(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyICameraSerialPortBaudRate_swiginit(self, lib_mvIMPACT_acquire.new_PropertyICameraSerialPortBaudRate(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraSerialPortBaudRate > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyICameraSerialPortBaudRate_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraSerialPortBaudRate_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraSerialPortBaudRate_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyICameraSerialPortBaudRate_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyICameraSerialPortBaudRate_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraSerialPortBaudRate_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraSerialPortBaudRate_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraSerialPortBaudRate_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraSerialPortBaudRate_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraSerialPortBaudRate >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraSerialPortBaudRate,std::allocator< mvIMPACT::acquire::TCameraSerialPortBaudRate > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraSerialPortBaudRate_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyICameraSerialPortBaudRate

# Register PropertyICameraSerialPortBaudRate in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyICameraSerialPortBaudRate_swigregister(PropertyICameraSerialPortBaudRate)

class pairstringTCameraSerialPortBaudRate(object):
    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):
        lib_mvIMPACT_acquire.pairstringTCameraSerialPortBaudRate_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTCameraSerialPortBaudRate(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTCameraSerialPortBaudRate_first_get, lib_mvIMPACT_acquire.pairstringTCameraSerialPortBaudRate_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTCameraSerialPortBaudRate_second_get, lib_mvIMPACT_acquire.pairstringTCameraSerialPortBaudRate_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTCameraSerialPortBaudRate

# Register pairstringTCameraSerialPortBaudRate in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTCameraSerialPortBaudRate_swigregister(pairstringTCameraSerialPortBaudRate)

class PropertyICameraShutterMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyICameraShutterMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyICameraShutterMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraShutterMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyICameraShutterMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraShutterMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraShutterMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyICameraShutterMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyICameraShutterMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraShutterMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraShutterMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraShutterMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraShutterMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraShutterMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraShutterMode,std::allocator< mvIMPACT::acquire::TCameraShutterMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraShutterMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyICameraShutterMode

# Register PropertyICameraShutterMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyICameraShutterMode_swigregister(PropertyICameraShutterMode)

class pairstringTCameraShutterMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTCameraShutterMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTCameraShutterMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTCameraShutterMode_first_get, lib_mvIMPACT_acquire.pairstringTCameraShutterMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTCameraShutterMode_second_get, lib_mvIMPACT_acquire.pairstringTCameraShutterMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTCameraShutterMode

# Register pairstringTCameraShutterMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTCameraShutterMode_swigregister(pairstringTCameraShutterMode)

class PropertyICameraTapsXGeometry(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyICameraTapsXGeometry_swiginit(self, lib_mvIMPACT_acquire.new_PropertyICameraTapsXGeometry(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraTapsXGeometry > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyICameraTapsXGeometry_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraTapsXGeometry_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraTapsXGeometry_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyICameraTapsXGeometry_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyICameraTapsXGeometry_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraTapsXGeometry_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraTapsXGeometry_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraTapsXGeometry_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraTapsXGeometry_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsXGeometry >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTapsXGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsXGeometry > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraTapsXGeometry_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyICameraTapsXGeometry

# Register PropertyICameraTapsXGeometry in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyICameraTapsXGeometry_swigregister(PropertyICameraTapsXGeometry)

class pairstringTCameraTapsXGeometry(object):
    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):
        lib_mvIMPACT_acquire.pairstringTCameraTapsXGeometry_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTCameraTapsXGeometry(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTCameraTapsXGeometry_first_get, lib_mvIMPACT_acquire.pairstringTCameraTapsXGeometry_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTCameraTapsXGeometry_second_get, lib_mvIMPACT_acquire.pairstringTCameraTapsXGeometry_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTCameraTapsXGeometry

# Register pairstringTCameraTapsXGeometry in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTCameraTapsXGeometry_swigregister(pairstringTCameraTapsXGeometry)

class PropertyICameraTapsYGeometry(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyICameraTapsYGeometry_swiginit(self, lib_mvIMPACT_acquire.new_PropertyICameraTapsYGeometry(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraTapsYGeometry > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyICameraTapsYGeometry_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraTapsYGeometry_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraTapsYGeometry_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyICameraTapsYGeometry_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyICameraTapsYGeometry_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraTapsYGeometry_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraTapsYGeometry_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraTapsYGeometry_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraTapsYGeometry_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTapsYGeometry >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTapsYGeometry,std::allocator< mvIMPACT::acquire::TCameraTapsYGeometry > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraTapsYGeometry_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyICameraTapsYGeometry

# Register PropertyICameraTapsYGeometry in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyICameraTapsYGeometry_swigregister(PropertyICameraTapsYGeometry)

class pairstringTCameraTapsYGeometry(object):
    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):
        lib_mvIMPACT_acquire.pairstringTCameraTapsYGeometry_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTCameraTapsYGeometry(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTCameraTapsYGeometry_first_get, lib_mvIMPACT_acquire.pairstringTCameraTapsYGeometry_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTCameraTapsYGeometry_second_get, lib_mvIMPACT_acquire.pairstringTCameraTapsYGeometry_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTCameraTapsYGeometry

# Register pairstringTCameraTapsYGeometry in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTCameraTapsYGeometry_swigregister(pairstringTCameraTapsYGeometry)

class PropertyICameraTestMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyICameraTestMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyICameraTestMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraTestMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraTestMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyICameraTestMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraTestMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraTestMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyICameraTestMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyICameraTestMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraTestMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraTestMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraTestMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraTestMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTestMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTestMode,std::allocator< mvIMPACT::acquire::TCameraTestMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraTestMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyICameraTestMode

# Register PropertyICameraTestMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyICameraTestMode_swigregister(PropertyICameraTestMode)

class pairstringTCameraTestMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTCameraTestMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTCameraTestMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTCameraTestMode_first_get, lib_mvIMPACT_acquire.pairstringTCameraTestMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTCameraTestMode_second_get, lib_mvIMPACT_acquire.pairstringTCameraTestMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTCameraTestMode

# Register pairstringTCameraTestMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTCameraTestMode_swigregister(pairstringTCameraTestMode)

class PropertyICameraTriggerMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyICameraTriggerMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyICameraTriggerMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraTriggerMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyICameraTriggerMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraTriggerMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraTriggerMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyICameraTriggerMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyICameraTriggerMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraTriggerMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraTriggerMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraTriggerMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraTriggerMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTriggerMode,std::allocator< mvIMPACT::acquire::TCameraTriggerMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraTriggerMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyICameraTriggerMode

# Register PropertyICameraTriggerMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyICameraTriggerMode_swigregister(PropertyICameraTriggerMode)

class pairstringTCameraTriggerMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTCameraTriggerMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTCameraTriggerMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTCameraTriggerMode_first_get, lib_mvIMPACT_acquire.pairstringTCameraTriggerMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTCameraTriggerMode_second_get, lib_mvIMPACT_acquire.pairstringTCameraTriggerMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTCameraTriggerMode

# Register pairstringTCameraTriggerMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTCameraTriggerMode_swigregister(pairstringTCameraTriggerMode)

class PropertyICameraTriggerSource(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyICameraTriggerSource_swiginit(self, lib_mvIMPACT_acquire.new_PropertyICameraTriggerSource(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TCameraTriggerSource > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyICameraTriggerSource_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraTriggerSource_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraTriggerSource_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyICameraTriggerSource_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyICameraTriggerSource_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraTriggerSource_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraTriggerSource_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyICameraTriggerSource_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraTriggerSource_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TCameraTriggerSource >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TCameraTriggerSource,std::allocator< mvIMPACT::acquire::TCameraTriggerSource > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyICameraTriggerSource_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyICameraTriggerSource

# Register PropertyICameraTriggerSource in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyICameraTriggerSource_swigregister(PropertyICameraTriggerSource)

class pairstringTCameraTriggerSource(object):
    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):
        lib_mvIMPACT_acquire.pairstringTCameraTriggerSource_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTCameraTriggerSource(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTCameraTriggerSource_first_get, lib_mvIMPACT_acquire.pairstringTCameraTriggerSource_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTCameraTriggerSource_second_get, lib_mvIMPACT_acquire.pairstringTCameraTriggerSource_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTCameraTriggerSource

# Register pairstringTCameraTriggerSource in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTCameraTriggerSource_swigregister(pairstringTCameraTriggerSource)

class PropertyIChannelSplitMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIChannelSplitMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIChannelSplitMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TChannelSplitMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIChannelSplitMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIChannelSplitMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIChannelSplitMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIChannelSplitMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIChannelSplitMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIChannelSplitMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIChannelSplitMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIChannelSplitMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIChannelSplitMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TChannelSplitMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TChannelSplitMode,std::allocator< mvIMPACT::acquire::TChannelSplitMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIChannelSplitMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIChannelSplitMode

# Register PropertyIChannelSplitMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIChannelSplitMode_swigregister(PropertyIChannelSplitMode)

class pairstringTChannelSplitMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTChannelSplitMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTChannelSplitMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTChannelSplitMode_first_get, lib_mvIMPACT_acquire.pairstringTChannelSplitMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTChannelSplitMode_second_get, lib_mvIMPACT_acquire.pairstringTChannelSplitMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTChannelSplitMode

# Register pairstringTChannelSplitMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTChannelSplitMode_swigregister(pairstringTChannelSplitMode)

class PropertyIClampMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIClampMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIClampMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TClampMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TClampMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIClampMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIClampMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIClampMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIClampMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIClampMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIClampMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIClampMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIClampMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIClampMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TClampMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TClampMode,std::allocator< mvIMPACT::acquire::TClampMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIClampMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIClampMode

# Register PropertyIClampMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIClampMode_swigregister(PropertyIClampMode)

class pairstringTClampMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTClampMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTClampMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTClampMode_first_get, lib_mvIMPACT_acquire.pairstringTClampMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTClampMode_second_get, lib_mvIMPACT_acquire.pairstringTClampMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTClampMode

# Register pairstringTClampMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTClampMode_swigregister(pairstringTClampMode)

class PropertyIColorTwistInputCorrectionMatrixMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIColorTwistInputCorrectionMatrixMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIColorTwistInputCorrectionMatrixMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIColorTwistInputCorrectionMatrixMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIColorTwistInputCorrectionMatrixMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIColorTwistInputCorrectionMatrixMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIColorTwistInputCorrectionMatrixMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIColorTwistInputCorrectionMatrixMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistInputCorrectionMatrixMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIColorTwistInputCorrectionMatrixMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIColorTwistInputCorrectionMatrixMode

# Register PropertyIColorTwistInputCorrectionMatrixMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIColorTwistInputCorrectionMatrixMode_swigregister(PropertyIColorTwistInputCorrectionMatrixMode)

class pairstringTColorTwistInputCorrectionMatrixMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTColorTwistInputCorrectionMatrixMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTColorTwistInputCorrectionMatrixMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTColorTwistInputCorrectionMatrixMode_first_get, lib_mvIMPACT_acquire.pairstringTColorTwistInputCorrectionMatrixMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTColorTwistInputCorrectionMatrixMode_second_get, lib_mvIMPACT_acquire.pairstringTColorTwistInputCorrectionMatrixMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTColorTwistInputCorrectionMatrixMode

# Register pairstringTColorTwistInputCorrectionMatrixMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTColorTwistInputCorrectionMatrixMode_swigregister(pairstringTColorTwistInputCorrectionMatrixMode)

class PropertyIColorTwistOutputCorrectionMatrixMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIColorTwistOutputCorrectionMatrixMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIColorTwistOutputCorrectionMatrixMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIColorTwistOutputCorrectionMatrixMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIColorTwistOutputCorrectionMatrixMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIColorTwistOutputCorrectionMatrixMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIColorTwistOutputCorrectionMatrixMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIColorTwistOutputCorrectionMatrixMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode,std::allocator< mvIMPACT::acquire::TColorTwistOutputCorrectionMatrixMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIColorTwistOutputCorrectionMatrixMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIColorTwistOutputCorrectionMatrixMode

# Register PropertyIColorTwistOutputCorrectionMatrixMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIColorTwistOutputCorrectionMatrixMode_swigregister(PropertyIColorTwistOutputCorrectionMatrixMode)

class pairstringTColorTwistOutputCorrectionMatrixMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTColorTwistOutputCorrectionMatrixMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTColorTwistOutputCorrectionMatrixMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTColorTwistOutputCorrectionMatrixMode_first_get, lib_mvIMPACT_acquire.pairstringTColorTwistOutputCorrectionMatrixMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTColorTwistOutputCorrectionMatrixMode_second_get, lib_mvIMPACT_acquire.pairstringTColorTwistOutputCorrectionMatrixMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTColorTwistOutputCorrectionMatrixMode

# Register pairstringTColorTwistOutputCorrectionMatrixMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTColorTwistOutputCorrectionMatrixMode_swigregister(pairstringTColorTwistOutputCorrectionMatrixMode)

class PropertyIColorProcessingMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIColorProcessingMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIColorProcessingMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TColorProcessingMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIColorProcessingMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIColorProcessingMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIColorProcessingMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIColorProcessingMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIColorProcessingMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIColorProcessingMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIColorProcessingMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIColorProcessingMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIColorProcessingMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TColorProcessingMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TColorProcessingMode,std::allocator< mvIMPACT::acquire::TColorProcessingMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIColorProcessingMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIColorProcessingMode

# Register PropertyIColorProcessingMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIColorProcessingMode_swigregister(PropertyIColorProcessingMode)

class pairstringTColorProcessingMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTColorProcessingMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTColorProcessingMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTColorProcessingMode_first_get, lib_mvIMPACT_acquire.pairstringTColorProcessingMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTColorProcessingMode_second_get, lib_mvIMPACT_acquire.pairstringTColorProcessingMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTColorProcessingMode

# Register pairstringTColorProcessingMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTColorProcessingMode_swigregister(pairstringTColorProcessingMode)

class PropertyIDarkCurrentFilterMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIDarkCurrentFilterMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIDarkCurrentFilterMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDarkCurrentFilterMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIDarkCurrentFilterMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDarkCurrentFilterMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDarkCurrentFilterMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIDarkCurrentFilterMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIDarkCurrentFilterMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDarkCurrentFilterMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDarkCurrentFilterMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDarkCurrentFilterMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDarkCurrentFilterMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDarkCurrentFilterMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDarkCurrentFilterMode,std::allocator< mvIMPACT::acquire::TDarkCurrentFilterMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDarkCurrentFilterMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIDarkCurrentFilterMode

# Register PropertyIDarkCurrentFilterMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIDarkCurrentFilterMode_swigregister(PropertyIDarkCurrentFilterMode)

class pairstringTDarkCurrentFilterMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTDarkCurrentFilterMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTDarkCurrentFilterMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTDarkCurrentFilterMode_first_get, lib_mvIMPACT_acquire.pairstringTDarkCurrentFilterMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTDarkCurrentFilterMode_second_get, lib_mvIMPACT_acquire.pairstringTDarkCurrentFilterMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTDarkCurrentFilterMode

# Register pairstringTDarkCurrentFilterMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTDarkCurrentFilterMode_swigregister(pairstringTDarkCurrentFilterMode)

class PropertyIDefectivePixelsFilterMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIDefectivePixelsFilterMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIDefectivePixelsFilterMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDefectivePixelsFilterMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIDefectivePixelsFilterMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDefectivePixelsFilterMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDefectivePixelsFilterMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIDefectivePixelsFilterMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIDefectivePixelsFilterMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDefectivePixelsFilterMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDefectivePixelsFilterMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDefectivePixelsFilterMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDefectivePixelsFilterMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDefectivePixelsFilterMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDefectivePixelsFilterMode,std::allocator< mvIMPACT::acquire::TDefectivePixelsFilterMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDefectivePixelsFilterMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIDefectivePixelsFilterMode

# Register PropertyIDefectivePixelsFilterMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIDefectivePixelsFilterMode_swigregister(PropertyIDefectivePixelsFilterMode)

class pairstringTDefectivePixelsFilterMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTDefectivePixelsFilterMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTDefectivePixelsFilterMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTDefectivePixelsFilterMode_first_get, lib_mvIMPACT_acquire.pairstringTDefectivePixelsFilterMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTDefectivePixelsFilterMode_second_get, lib_mvIMPACT_acquire.pairstringTDefectivePixelsFilterMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTDefectivePixelsFilterMode

# Register pairstringTDefectivePixelsFilterMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTDefectivePixelsFilterMode_swigregister(pairstringTDefectivePixelsFilterMode)

class PropertyIDeviceAccessMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIDeviceAccessMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIDeviceAccessMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceAccessMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceAccessMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceAccessMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceAccessMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceAccessMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceAccessMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceAccessMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceAccessMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceAccessMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceAccessMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAccessMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceAccessMode,std::allocator< mvIMPACT::acquire::TDeviceAccessMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceAccessMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIDeviceAccessMode

# Register PropertyIDeviceAccessMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIDeviceAccessMode_swigregister(PropertyIDeviceAccessMode)

class pairstringTDeviceAccessMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTDeviceAccessMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTDeviceAccessMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTDeviceAccessMode_first_get, lib_mvIMPACT_acquire.pairstringTDeviceAccessMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTDeviceAccessMode_second_get, lib_mvIMPACT_acquire.pairstringTDeviceAccessMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTDeviceAccessMode

# Register pairstringTDeviceAccessMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTDeviceAccessMode_swigregister(pairstringTDeviceAccessMode)

class PropertyIDeviceAdvancedOptions(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIDeviceAdvancedOptions_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIDeviceAdvancedOptions(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceAdvancedOptions > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceAdvancedOptions_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceAdvancedOptions_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceAdvancedOptions_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceAdvancedOptions_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceAdvancedOptions_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceAdvancedOptions_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceAdvancedOptions_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceAdvancedOptions_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceAdvancedOptions_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceAdvancedOptions >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceAdvancedOptions,std::allocator< mvIMPACT::acquire::TDeviceAdvancedOptions > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceAdvancedOptions_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIDeviceAdvancedOptions

# Register PropertyIDeviceAdvancedOptions in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIDeviceAdvancedOptions_swigregister(PropertyIDeviceAdvancedOptions)

class pairstringTDeviceAdvancedOptions(object):
    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):
        lib_mvIMPACT_acquire.pairstringTDeviceAdvancedOptions_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTDeviceAdvancedOptions(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTDeviceAdvancedOptions_first_get, lib_mvIMPACT_acquire.pairstringTDeviceAdvancedOptions_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTDeviceAdvancedOptions_second_get, lib_mvIMPACT_acquire.pairstringTDeviceAdvancedOptions_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTDeviceAdvancedOptions

# Register pairstringTDeviceAdvancedOptions in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTDeviceAdvancedOptions_swigregister(pairstringTDeviceAdvancedOptions)

class PropertyIDeviceCapability(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIDeviceCapability_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIDeviceCapability(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceCapability >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceCapability > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceCapability_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceCapability_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceCapability_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceCapability_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceCapability_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceCapability_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceCapability_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceCapability_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceCapability_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceCapability >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceCapability,std::allocator< mvIMPACT::acquire::TDeviceCapability > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceCapability_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIDeviceCapability

# Register PropertyIDeviceCapability in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIDeviceCapability_swigregister(PropertyIDeviceCapability)

class pairstringTDeviceCapability(object):
    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):
        lib_mvIMPACT_acquire.pairstringTDeviceCapability_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTDeviceCapability(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTDeviceCapability_first_get, lib_mvIMPACT_acquire.pairstringTDeviceCapability_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTDeviceCapability_second_get, lib_mvIMPACT_acquire.pairstringTDeviceCapability_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTDeviceCapability

# Register pairstringTDeviceCapability in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTDeviceCapability_swigregister(pairstringTDeviceCapability)

class PropertyIDeviceClass(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIDeviceClass_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIDeviceClass(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceClass >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceClass > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceClass_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceClass_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceClass_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceClass_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceClass_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceClass_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceClass_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceClass_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceClass_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceClass >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceClass,std::allocator< mvIMPACT::acquire::TDeviceClass > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceClass_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIDeviceClass

# Register PropertyIDeviceClass in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIDeviceClass_swigregister(PropertyIDeviceClass)

class pairstringTDeviceClass(object):
    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):
        lib_mvIMPACT_acquire.pairstringTDeviceClass_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTDeviceClass(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTDeviceClass_first_get, lib_mvIMPACT_acquire.pairstringTDeviceClass_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTDeviceClass_second_get, lib_mvIMPACT_acquire.pairstringTDeviceClass_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTDeviceClass

# Register pairstringTDeviceClass in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTDeviceClass_swigregister(pairstringTDeviceClass)

class PropertyIDeviceDigitalOutputMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIDeviceDigitalOutputMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIDeviceDigitalOutputMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceDigitalOutputMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceDigitalOutputMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceDigitalOutputMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceDigitalOutputMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceDigitalOutputMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceDigitalOutputMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceDigitalOutputMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceDigitalOutputMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceDigitalOutputMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceDigitalOutputMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceDigitalOutputMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceDigitalOutputMode,std::allocator< mvIMPACT::acquire::TDeviceDigitalOutputMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceDigitalOutputMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIDeviceDigitalOutputMode

# Register PropertyIDeviceDigitalOutputMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIDeviceDigitalOutputMode_swigregister(PropertyIDeviceDigitalOutputMode)

class pairstringTDeviceDigitalOutputMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTDeviceDigitalOutputMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTDeviceDigitalOutputMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTDeviceDigitalOutputMode_first_get, lib_mvIMPACT_acquire.pairstringTDeviceDigitalOutputMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTDeviceDigitalOutputMode_second_get, lib_mvIMPACT_acquire.pairstringTDeviceDigitalOutputMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTDeviceDigitalOutputMode

# Register pairstringTDeviceDigitalOutputMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTDeviceDigitalOutputMode_swigregister(pairstringTDeviceDigitalOutputMode)

class PropertyIDeviceImageTrigger(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIDeviceImageTrigger_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIDeviceImageTrigger(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceImageTrigger > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceImageTrigger_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceImageTrigger_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceImageTrigger_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceImageTrigger_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceImageTrigger_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceImageTrigger_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceImageTrigger_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceImageTrigger_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceImageTrigger_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceImageTrigger >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceImageTrigger,std::allocator< mvIMPACT::acquire::TDeviceImageTrigger > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceImageTrigger_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIDeviceImageTrigger

# Register PropertyIDeviceImageTrigger in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIDeviceImageTrigger_swigregister(PropertyIDeviceImageTrigger)

class pairstringTDeviceImageTrigger(object):
    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):
        lib_mvIMPACT_acquire.pairstringTDeviceImageTrigger_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTDeviceImageTrigger(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTDeviceImageTrigger_first_get, lib_mvIMPACT_acquire.pairstringTDeviceImageTrigger_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTDeviceImageTrigger_second_get, lib_mvIMPACT_acquire.pairstringTDeviceImageTrigger_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTDeviceImageTrigger

# Register pairstringTDeviceImageTrigger in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTDeviceImageTrigger_swigregister(pairstringTDeviceImageTrigger)

class PropertyIDeviceInterfaceLayout(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIDeviceInterfaceLayout_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIDeviceInterfaceLayout(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceInterfaceLayout > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceInterfaceLayout_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceInterfaceLayout_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceInterfaceLayout_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceInterfaceLayout_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceInterfaceLayout_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceInterfaceLayout_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceInterfaceLayout_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceInterfaceLayout_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceInterfaceLayout_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceInterfaceLayout >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceInterfaceLayout,std::allocator< mvIMPACT::acquire::TDeviceInterfaceLayout > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceInterfaceLayout_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIDeviceInterfaceLayout

# Register PropertyIDeviceInterfaceLayout in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIDeviceInterfaceLayout_swigregister(PropertyIDeviceInterfaceLayout)

class pairstringTDeviceInterfaceLayout(object):
    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):
        lib_mvIMPACT_acquire.pairstringTDeviceInterfaceLayout_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTDeviceInterfaceLayout(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTDeviceInterfaceLayout_first_get, lib_mvIMPACT_acquire.pairstringTDeviceInterfaceLayout_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTDeviceInterfaceLayout_second_get, lib_mvIMPACT_acquire.pairstringTDeviceInterfaceLayout_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTDeviceInterfaceLayout

# Register pairstringTDeviceInterfaceLayout in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTDeviceInterfaceLayout_swigregister(pairstringTDeviceInterfaceLayout)

class PropertyIDeviceLoadSettings(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIDeviceLoadSettings_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIDeviceLoadSettings(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceLoadSettings > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceLoadSettings_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceLoadSettings_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceLoadSettings_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceLoadSettings_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceLoadSettings_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceLoadSettings_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceLoadSettings_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceLoadSettings_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceLoadSettings_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceLoadSettings >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceLoadSettings,std::allocator< mvIMPACT::acquire::TDeviceLoadSettings > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceLoadSettings_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIDeviceLoadSettings

# Register PropertyIDeviceLoadSettings in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIDeviceLoadSettings_swigregister(PropertyIDeviceLoadSettings)

class pairstringTDeviceLoadSettings(object):
    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):
        lib_mvIMPACT_acquire.pairstringTDeviceLoadSettings_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTDeviceLoadSettings(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTDeviceLoadSettings_first_get, lib_mvIMPACT_acquire.pairstringTDeviceLoadSettings_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTDeviceLoadSettings_second_get, lib_mvIMPACT_acquire.pairstringTDeviceLoadSettings_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTDeviceLoadSettings

# Register pairstringTDeviceLoadSettings in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTDeviceLoadSettings_swigregister(pairstringTDeviceLoadSettings)

class PropertyIDevicePowerMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIDevicePowerMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIDevicePowerMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDevicePowerMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIDevicePowerMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDevicePowerMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDevicePowerMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIDevicePowerMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIDevicePowerMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDevicePowerMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDevicePowerMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDevicePowerMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDevicePowerMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDevicePowerMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDevicePowerMode,std::allocator< mvIMPACT::acquire::TDevicePowerMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDevicePowerMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIDevicePowerMode

# Register PropertyIDevicePowerMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIDevicePowerMode_swigregister(PropertyIDevicePowerMode)

class pairstringTDevicePowerMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTDevicePowerMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTDevicePowerMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTDevicePowerMode_first_get, lib_mvIMPACT_acquire.pairstringTDevicePowerMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTDevicePowerMode_second_get, lib_mvIMPACT_acquire.pairstringTDevicePowerMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTDevicePowerMode

# Register pairstringTDevicePowerMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTDevicePowerMode_swigregister(pairstringTDevicePowerMode)

class PropertyIDeviceScanRateMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIDeviceScanRateMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIDeviceScanRateMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceScanRateMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceScanRateMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceScanRateMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceScanRateMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceScanRateMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceScanRateMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceScanRateMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceScanRateMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceScanRateMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceScanRateMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceScanRateMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceScanRateMode,std::allocator< mvIMPACT::acquire::TDeviceScanRateMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceScanRateMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIDeviceScanRateMode

# Register PropertyIDeviceScanRateMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIDeviceScanRateMode_swigregister(PropertyIDeviceScanRateMode)

class pairstringTDeviceScanRateMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTDeviceScanRateMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTDeviceScanRateMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTDeviceScanRateMode_first_get, lib_mvIMPACT_acquire.pairstringTDeviceScanRateMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTDeviceScanRateMode_second_get, lib_mvIMPACT_acquire.pairstringTDeviceScanRateMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTDeviceScanRateMode

# Register pairstringTDeviceScanRateMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTDeviceScanRateMode_swigregister(pairstringTDeviceScanRateMode)

class PropertyIDeviceSignalOutputStartEvent(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIDeviceSignalOutputStartEvent_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIDeviceSignalOutputStartEvent(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceSignalOutputStartEvent > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceSignalOutputStartEvent_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceSignalOutputStartEvent_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceSignalOutputStartEvent_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceSignalOutputStartEvent_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceSignalOutputStartEvent_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceSignalOutputStartEvent_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceSignalOutputStartEvent_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceSignalOutputStartEvent_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceSignalOutputStartEvent_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSignalOutputStartEvent >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceSignalOutputStartEvent,std::allocator< mvIMPACT::acquire::TDeviceSignalOutputStartEvent > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceSignalOutputStartEvent_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIDeviceSignalOutputStartEvent

# Register PropertyIDeviceSignalOutputStartEvent in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIDeviceSignalOutputStartEvent_swigregister(PropertyIDeviceSignalOutputStartEvent)

class pairstringTDeviceSignalOutputStartEvent(object):
    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):
        lib_mvIMPACT_acquire.pairstringTDeviceSignalOutputStartEvent_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTDeviceSignalOutputStartEvent(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTDeviceSignalOutputStartEvent_first_get, lib_mvIMPACT_acquire.pairstringTDeviceSignalOutputStartEvent_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTDeviceSignalOutputStartEvent_second_get, lib_mvIMPACT_acquire.pairstringTDeviceSignalOutputStartEvent_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTDeviceSignalOutputStartEvent

# Register pairstringTDeviceSignalOutputStartEvent in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTDeviceSignalOutputStartEvent_swigregister(pairstringTDeviceSignalOutputStartEvent)

class PropertyIDeviceState(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIDeviceState_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIDeviceState(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceState >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceState > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceState_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceState_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceState_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceState_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceState_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceState_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceState_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceState_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceState_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceState >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceState,std::allocator< mvIMPACT::acquire::TDeviceState > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceState_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIDeviceState

# Register PropertyIDeviceState in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIDeviceState_swigregister(PropertyIDeviceState)

class pairstringTDeviceState(object):
    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):
        lib_mvIMPACT_acquire.pairstringTDeviceState_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTDeviceState(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTDeviceState_first_get, lib_mvIMPACT_acquire.pairstringTDeviceState_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTDeviceState_second_get, lib_mvIMPACT_acquire.pairstringTDeviceState_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTDeviceState

# Register pairstringTDeviceState in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTDeviceState_swigregister(pairstringTDeviceState)

class PropertyIDeviceSyncOutMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIDeviceSyncOutMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIDeviceSyncOutMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceSyncOutMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceSyncOutMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceSyncOutMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceSyncOutMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceSyncOutMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceSyncOutMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceSyncOutMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceSyncOutMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceSyncOutMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceSyncOutMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceSyncOutMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceSyncOutMode,std::allocator< mvIMPACT::acquire::TDeviceSyncOutMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceSyncOutMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIDeviceSyncOutMode

# Register PropertyIDeviceSyncOutMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIDeviceSyncOutMode_swigregister(PropertyIDeviceSyncOutMode)

class pairstringTDeviceSyncOutMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTDeviceSyncOutMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTDeviceSyncOutMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTDeviceSyncOutMode_first_get, lib_mvIMPACT_acquire.pairstringTDeviceSyncOutMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTDeviceSyncOutMode_second_get, lib_mvIMPACT_acquire.pairstringTDeviceSyncOutMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTDeviceSyncOutMode

# Register pairstringTDeviceSyncOutMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTDeviceSyncOutMode_swigregister(pairstringTDeviceSyncOutMode)

class PropertyIDeviceTriggerInterface(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIDeviceTriggerInterface_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIDeviceTriggerInterface(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerInterface > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceTriggerInterface_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceTriggerInterface_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceTriggerInterface_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceTriggerInterface_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceTriggerInterface_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceTriggerInterface_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceTriggerInterface_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceTriggerInterface_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceTriggerInterface_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerInterface >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerInterface,std::allocator< mvIMPACT::acquire::TDeviceTriggerInterface > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceTriggerInterface_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIDeviceTriggerInterface

# Register PropertyIDeviceTriggerInterface in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIDeviceTriggerInterface_swigregister(PropertyIDeviceTriggerInterface)

class pairstringTDeviceTriggerInterface(object):
    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):
        lib_mvIMPACT_acquire.pairstringTDeviceTriggerInterface_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTDeviceTriggerInterface(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTDeviceTriggerInterface_first_get, lib_mvIMPACT_acquire.pairstringTDeviceTriggerInterface_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTDeviceTriggerInterface_second_get, lib_mvIMPACT_acquire.pairstringTDeviceTriggerInterface_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTDeviceTriggerInterface

# Register pairstringTDeviceTriggerInterface in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTDeviceTriggerInterface_swigregister(pairstringTDeviceTriggerInterface)

class PropertyIDeviceTriggerMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIDeviceTriggerMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIDeviceTriggerMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceTriggerMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceTriggerMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceTriggerMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceTriggerMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceTriggerMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceTriggerMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceTriggerMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceTriggerMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceTriggerMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDeviceTriggerMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerMode,std::allocator< mvIMPACT::acquire::TDeviceTriggerMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDeviceTriggerMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIDeviceTriggerMode

# Register PropertyIDeviceTriggerMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIDeviceTriggerMode_swigregister(PropertyIDeviceTriggerMode)

class pairstringTDeviceTriggerMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTDeviceTriggerMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTDeviceTriggerMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTDeviceTriggerMode_first_get, lib_mvIMPACT_acquire.pairstringTDeviceTriggerMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTDeviceTriggerMode_second_get, lib_mvIMPACT_acquire.pairstringTDeviceTriggerMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTDeviceTriggerMode

# Register pairstringTDeviceTriggerMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTDeviceTriggerMode_swigregister(pairstringTDeviceTriggerMode)

class PropertyIDigIOState(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIDigIOState_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIDigIOState(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDigIOState >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDigIOState > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIDigIOState_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDigIOState_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDigIOState_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIDigIOState_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIDigIOState_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDigIOState_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDigIOState_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDigIOState_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDigIOState_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigIOState >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDigIOState,std::allocator< mvIMPACT::acquire::TDigIOState > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDigIOState_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIDigIOState

# Register PropertyIDigIOState in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIDigIOState_swigregister(PropertyIDigIOState)

class pairstringTDigIOState(object):
    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):
        lib_mvIMPACT_acquire.pairstringTDigIOState_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTDigIOState(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTDigIOState_first_get, lib_mvIMPACT_acquire.pairstringTDigIOState_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTDigIOState_second_get, lib_mvIMPACT_acquire.pairstringTDigIOState_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTDigIOState

# Register pairstringTDigIOState in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTDigIOState_swigregister(pairstringTDigIOState)

class PropertyIDigitalIOMeasurementMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIDigitalIOMeasurementMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIDigitalIOMeasurementMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIDigitalIOMeasurementMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDigitalIOMeasurementMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDigitalIOMeasurementMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIDigitalIOMeasurementMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIDigitalIOMeasurementMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDigitalIOMeasurementMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDigitalIOMeasurementMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDigitalIOMeasurementMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDigitalIOMeasurementMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDigitalIOMeasurementMode,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDigitalIOMeasurementMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIDigitalIOMeasurementMode

# Register PropertyIDigitalIOMeasurementMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIDigitalIOMeasurementMode_swigregister(PropertyIDigitalIOMeasurementMode)

class pairstringTDigitalIOMeasurementMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTDigitalIOMeasurementMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTDigitalIOMeasurementMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTDigitalIOMeasurementMode_first_get, lib_mvIMPACT_acquire.pairstringTDigitalIOMeasurementMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTDigitalIOMeasurementMode_second_get, lib_mvIMPACT_acquire.pairstringTDigitalIOMeasurementMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTDigitalIOMeasurementMode

# Register pairstringTDigitalIOMeasurementMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTDigitalIOMeasurementMode_swigregister(pairstringTDigitalIOMeasurementMode)

class PropertyIDigitalIOMeasurementSource(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIDigitalIOMeasurementSource_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIDigitalIOMeasurementSource(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDigitalIOMeasurementSource > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIDigitalIOMeasurementSource_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDigitalIOMeasurementSource_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDigitalIOMeasurementSource_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIDigitalIOMeasurementSource_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIDigitalIOMeasurementSource_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDigitalIOMeasurementSource_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDigitalIOMeasurementSource_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDigitalIOMeasurementSource_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDigitalIOMeasurementSource_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalIOMeasurementSource >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDigitalIOMeasurementSource,std::allocator< mvIMPACT::acquire::TDigitalIOMeasurementSource > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDigitalIOMeasurementSource_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIDigitalIOMeasurementSource

# Register PropertyIDigitalIOMeasurementSource in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIDigitalIOMeasurementSource_swigregister(PropertyIDigitalIOMeasurementSource)

class pairstringTDigitalIOMeasurementSource(object):
    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):
        lib_mvIMPACT_acquire.pairstringTDigitalIOMeasurementSource_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTDigitalIOMeasurementSource(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTDigitalIOMeasurementSource_first_get, lib_mvIMPACT_acquire.pairstringTDigitalIOMeasurementSource_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTDigitalIOMeasurementSource_second_get, lib_mvIMPACT_acquire.pairstringTDigitalIOMeasurementSource_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTDigitalIOMeasurementSource

# Register pairstringTDigitalIOMeasurementSource in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTDigitalIOMeasurementSource_swigregister(pairstringTDigitalIOMeasurementSource)

class PropertyIDigitalOutputControlMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIDigitalOutputControlMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIDigitalOutputControlMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDigitalOutputControlMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIDigitalOutputControlMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDigitalOutputControlMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDigitalOutputControlMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIDigitalOutputControlMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIDigitalOutputControlMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDigitalOutputControlMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDigitalOutputControlMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDigitalOutputControlMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDigitalOutputControlMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalOutputControlMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDigitalOutputControlMode,std::allocator< mvIMPACT::acquire::TDigitalOutputControlMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDigitalOutputControlMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIDigitalOutputControlMode

# Register PropertyIDigitalOutputControlMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIDigitalOutputControlMode_swigregister(PropertyIDigitalOutputControlMode)

class pairstringTDigitalOutputControlMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTDigitalOutputControlMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTDigitalOutputControlMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTDigitalOutputControlMode_first_get, lib_mvIMPACT_acquire.pairstringTDigitalOutputControlMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTDigitalOutputControlMode_second_get, lib_mvIMPACT_acquire.pairstringTDigitalOutputControlMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTDigitalOutputControlMode

# Register pairstringTDigitalOutputControlMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTDigitalOutputControlMode_swigregister(pairstringTDigitalOutputControlMode)

class PropertyIDigitalSignal(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIDigitalSignal_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIDigitalSignal(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDigitalSignal >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDigitalSignal > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIDigitalSignal_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDigitalSignal_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDigitalSignal_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIDigitalSignal_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIDigitalSignal_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDigitalSignal_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDigitalSignal_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIDigitalSignal_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDigitalSignal_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TDigitalSignal >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDigitalSignal,std::allocator< mvIMPACT::acquire::TDigitalSignal > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIDigitalSignal_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIDigitalSignal

# Register PropertyIDigitalSignal in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIDigitalSignal_swigregister(PropertyIDigitalSignal)

class pairstringTDigitalSignal(object):
    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):
        lib_mvIMPACT_acquire.pairstringTDigitalSignal_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTDigitalSignal(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTDigitalSignal_first_get, lib_mvIMPACT_acquire.pairstringTDigitalSignal_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTDigitalSignal_second_get, lib_mvIMPACT_acquire.pairstringTDigitalSignal_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTDigitalSignal

# Register pairstringTDigitalSignal in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTDigitalSignal_swigregister(pairstringTDigitalSignal)

class PropertyIFieldGateMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIFieldGateMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIFieldGateMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TFieldGateMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TFieldGateMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIFieldGateMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIFieldGateMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIFieldGateMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIFieldGateMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIFieldGateMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIFieldGateMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIFieldGateMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIFieldGateMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIFieldGateMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFieldGateMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TFieldGateMode,std::allocator< mvIMPACT::acquire::TFieldGateMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIFieldGateMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIFieldGateMode

# Register PropertyIFieldGateMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIFieldGateMode_swigregister(PropertyIFieldGateMode)

class pairstringTFieldGateMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTFieldGateMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTFieldGateMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTFieldGateMode_first_get, lib_mvIMPACT_acquire.pairstringTFieldGateMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTFieldGateMode_second_get, lib_mvIMPACT_acquire.pairstringTFieldGateMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTFieldGateMode

# Register pairstringTFieldGateMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTFieldGateMode_swigregister(pairstringTFieldGateMode)

class PropertyIFlatFieldFilterCorrectionMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIFlatFieldFilterCorrectionMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIFlatFieldFilterCorrectionMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIFlatFieldFilterCorrectionMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIFlatFieldFilterCorrectionMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIFlatFieldFilterCorrectionMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIFlatFieldFilterCorrectionMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIFlatFieldFilterCorrectionMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIFlatFieldFilterCorrectionMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIFlatFieldFilterCorrectionMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIFlatFieldFilterCorrectionMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIFlatFieldFilterCorrectionMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterCorrectionMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIFlatFieldFilterCorrectionMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIFlatFieldFilterCorrectionMode

# Register PropertyIFlatFieldFilterCorrectionMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIFlatFieldFilterCorrectionMode_swigregister(PropertyIFlatFieldFilterCorrectionMode)

class pairstringTFlatFieldFilterCorrectionMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTFlatFieldFilterCorrectionMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTFlatFieldFilterCorrectionMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTFlatFieldFilterCorrectionMode_first_get, lib_mvIMPACT_acquire.pairstringTFlatFieldFilterCorrectionMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTFlatFieldFilterCorrectionMode_second_get, lib_mvIMPACT_acquire.pairstringTFlatFieldFilterCorrectionMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTFlatFieldFilterCorrectionMode

# Register pairstringTFlatFieldFilterCorrectionMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTFlatFieldFilterCorrectionMode_swigregister(pairstringTFlatFieldFilterCorrectionMode)

class PropertyIFlatFieldFilterMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIFlatFieldFilterMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIFlatFieldFilterMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TFlatFieldFilterMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIFlatFieldFilterMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIFlatFieldFilterMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIFlatFieldFilterMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIFlatFieldFilterMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIFlatFieldFilterMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIFlatFieldFilterMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIFlatFieldFilterMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIFlatFieldFilterMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIFlatFieldFilterMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TFlatFieldFilterMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TFlatFieldFilterMode,std::allocator< mvIMPACT::acquire::TFlatFieldFilterMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIFlatFieldFilterMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIFlatFieldFilterMode

# Register PropertyIFlatFieldFilterMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIFlatFieldFilterMode_swigregister(PropertyIFlatFieldFilterMode)

class pairstringTFlatFieldFilterMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTFlatFieldFilterMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTFlatFieldFilterMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTFlatFieldFilterMode_first_get, lib_mvIMPACT_acquire.pairstringTFlatFieldFilterMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTFlatFieldFilterMode_second_get, lib_mvIMPACT_acquire.pairstringTFlatFieldFilterMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTFlatFieldFilterMode

# Register pairstringTFlatFieldFilterMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTFlatFieldFilterMode_swigregister(pairstringTFlatFieldFilterMode)

class PropertyIHWUpdateResult(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIHWUpdateResult_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIHWUpdateResult(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::THWUpdateResult >,std::allocator< std::pair< std::string,mvIMPACT::acquire::THWUpdateResult > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIHWUpdateResult_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIHWUpdateResult_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIHWUpdateResult_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIHWUpdateResult_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIHWUpdateResult_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIHWUpdateResult_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIHWUpdateResult_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIHWUpdateResult_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIHWUpdateResult_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::THWUpdateResult >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::THWUpdateResult,std::allocator< mvIMPACT::acquire::THWUpdateResult > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIHWUpdateResult_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIHWUpdateResult

# Register PropertyIHWUpdateResult in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIHWUpdateResult_swigregister(PropertyIHWUpdateResult)

class pairstringTHWUpdateResult(object):
    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):
        lib_mvIMPACT_acquire.pairstringTHWUpdateResult_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTHWUpdateResult(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTHWUpdateResult_first_get, lib_mvIMPACT_acquire.pairstringTHWUpdateResult_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTHWUpdateResult_second_get, lib_mvIMPACT_acquire.pairstringTHWUpdateResult_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTHWUpdateResult

# Register pairstringTHWUpdateResult in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTHWUpdateResult_swigregister(pairstringTHWUpdateResult)

class PropertyII2COperationMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyII2COperationMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyII2COperationMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TI2COperationMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TI2COperationMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyII2COperationMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyII2COperationMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyII2COperationMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyII2COperationMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyII2COperationMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyII2COperationMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyII2COperationMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyII2COperationMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyII2COperationMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TI2COperationMode,std::allocator< mvIMPACT::acquire::TI2COperationMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyII2COperationMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyII2COperationMode

# Register PropertyII2COperationMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyII2COperationMode_swigregister(PropertyII2COperationMode)

class pairstringTI2COperationMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTI2COperationMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTI2COperationMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTI2COperationMode_first_get, lib_mvIMPACT_acquire.pairstringTI2COperationMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTI2COperationMode_second_get, lib_mvIMPACT_acquire.pairstringTI2COperationMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTI2COperationMode

# Register pairstringTI2COperationMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTI2COperationMode_swigregister(pairstringTI2COperationMode)

class PropertyII2COperationStatus(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyII2COperationStatus_swiginit(self, lib_mvIMPACT_acquire.new_PropertyII2COperationStatus(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TI2COperationStatus > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyII2COperationStatus_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyII2COperationStatus_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyII2COperationStatus_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyII2COperationStatus_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyII2COperationStatus_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyII2COperationStatus_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyII2COperationStatus_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyII2COperationStatus_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyII2COperationStatus_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TI2COperationStatus >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TI2COperationStatus,std::allocator< mvIMPACT::acquire::TI2COperationStatus > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyII2COperationStatus_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyII2COperationStatus

# Register PropertyII2COperationStatus in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyII2COperationStatus_swigregister(PropertyII2COperationStatus)

class pairstringTI2COperationStatus(object):
    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):
        lib_mvIMPACT_acquire.pairstringTI2COperationStatus_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTI2COperationStatus(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTI2COperationStatus_first_get, lib_mvIMPACT_acquire.pairstringTI2COperationStatus_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTI2COperationStatus_second_get, lib_mvIMPACT_acquire.pairstringTI2COperationStatus_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTI2COperationStatus

# Register pairstringTI2COperationStatus in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTI2COperationStatus_swigregister(pairstringTI2COperationStatus)

class PropertyIImageBufferPixelFormat(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIImageBufferPixelFormat_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIImageBufferPixelFormat(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TImageBufferPixelFormat > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIImageBufferPixelFormat_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIImageBufferPixelFormat_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIImageBufferPixelFormat_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIImageBufferPixelFormat_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIImageBufferPixelFormat_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIImageBufferPixelFormat_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIImageBufferPixelFormat_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIImageBufferPixelFormat_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIImageBufferPixelFormat_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferPixelFormat >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TImageBufferPixelFormat,std::allocator< mvIMPACT::acquire::TImageBufferPixelFormat > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIImageBufferPixelFormat_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIImageBufferPixelFormat

# Register PropertyIImageBufferPixelFormat in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIImageBufferPixelFormat_swigregister(PropertyIImageBufferPixelFormat)

class pairstringTImageBufferPixelFormat(object):
    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):
        lib_mvIMPACT_acquire.pairstringTImageBufferPixelFormat_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTImageBufferPixelFormat(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTImageBufferPixelFormat_first_get, lib_mvIMPACT_acquire.pairstringTImageBufferPixelFormat_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTImageBufferPixelFormat_second_get, lib_mvIMPACT_acquire.pairstringTImageBufferPixelFormat_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTImageBufferPixelFormat

# Register pairstringTImageBufferPixelFormat in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTImageBufferPixelFormat_swigregister(pairstringTImageBufferPixelFormat)

class PropertyIImageBufferFormatReinterpreterMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIImageBufferFormatReinterpreterMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIImageBufferFormatReinterpreterMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIImageBufferFormatReinterpreterMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIImageBufferFormatReinterpreterMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIImageBufferFormatReinterpreterMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIImageBufferFormatReinterpreterMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIImageBufferFormatReinterpreterMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIImageBufferFormatReinterpreterMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIImageBufferFormatReinterpreterMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIImageBufferFormatReinterpreterMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIImageBufferFormatReinterpreterMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode,std::allocator< mvIMPACT::acquire::TImageBufferFormatReinterpreterMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIImageBufferFormatReinterpreterMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIImageBufferFormatReinterpreterMode

# Register PropertyIImageBufferFormatReinterpreterMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIImageBufferFormatReinterpreterMode_swigregister(PropertyIImageBufferFormatReinterpreterMode)

class pairstringTImageBufferFormatReinterpreterMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTImageBufferFormatReinterpreterMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTImageBufferFormatReinterpreterMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTImageBufferFormatReinterpreterMode_first_get, lib_mvIMPACT_acquire.pairstringTImageBufferFormatReinterpreterMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTImageBufferFormatReinterpreterMode_second_get, lib_mvIMPACT_acquire.pairstringTImageBufferFormatReinterpreterMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTImageBufferFormatReinterpreterMode

# Register pairstringTImageBufferFormatReinterpreterMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTImageBufferFormatReinterpreterMode_swigregister(pairstringTImageBufferFormatReinterpreterMode)

class PropertyIImageDestinationPixelFormat(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIImageDestinationPixelFormat_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIImageDestinationPixelFormat(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TImageDestinationPixelFormat > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIImageDestinationPixelFormat_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIImageDestinationPixelFormat_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIImageDestinationPixelFormat_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIImageDestinationPixelFormat_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIImageDestinationPixelFormat_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIImageDestinationPixelFormat_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIImageDestinationPixelFormat_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIImageDestinationPixelFormat_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIImageDestinationPixelFormat_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageDestinationPixelFormat >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TImageDestinationPixelFormat,std::allocator< mvIMPACT::acquire::TImageDestinationPixelFormat > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIImageDestinationPixelFormat_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIImageDestinationPixelFormat

# Register PropertyIImageDestinationPixelFormat in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIImageDestinationPixelFormat_swigregister(PropertyIImageDestinationPixelFormat)

class pairstringTImageDestinationPixelFormat(object):
    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):
        lib_mvIMPACT_acquire.pairstringTImageDestinationPixelFormat_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTImageDestinationPixelFormat(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTImageDestinationPixelFormat_first_get, lib_mvIMPACT_acquire.pairstringTImageDestinationPixelFormat_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTImageDestinationPixelFormat_second_get, lib_mvIMPACT_acquire.pairstringTImageDestinationPixelFormat_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTImageDestinationPixelFormat

# Register pairstringTImageDestinationPixelFormat in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTImageDestinationPixelFormat_swigregister(pairstringTImageDestinationPixelFormat)

class PropertyIImageProcessingFilter(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIImageProcessingFilter_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIImageProcessingFilter(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TImageProcessingFilter > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIImageProcessingFilter_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIImageProcessingFilter_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIImageProcessingFilter_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIImageProcessingFilter_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIImageProcessingFilter_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIImageProcessingFilter_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIImageProcessingFilter_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIImageProcessingFilter_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIImageProcessingFilter_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingFilter >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TImageProcessingFilter,std::allocator< mvIMPACT::acquire::TImageProcessingFilter > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIImageProcessingFilter_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIImageProcessingFilter

# Register PropertyIImageProcessingFilter in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIImageProcessingFilter_swigregister(PropertyIImageProcessingFilter)

class pairstringTImageProcessingFilter(object):
    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):
        lib_mvIMPACT_acquire.pairstringTImageProcessingFilter_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTImageProcessingFilter(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTImageProcessingFilter_first_get, lib_mvIMPACT_acquire.pairstringTImageProcessingFilter_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTImageProcessingFilter_second_get, lib_mvIMPACT_acquire.pairstringTImageProcessingFilter_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTImageProcessingFilter

# Register pairstringTImageProcessingFilter in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTImageProcessingFilter_swigregister(pairstringTImageProcessingFilter)

class PropertyIImageProcessingMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIImageProcessingMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIImageProcessingMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TImageProcessingMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIImageProcessingMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIImageProcessingMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIImageProcessingMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIImageProcessingMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIImageProcessingMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIImageProcessingMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIImageProcessingMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIImageProcessingMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIImageProcessingMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TImageProcessingMode,std::allocator< mvIMPACT::acquire::TImageProcessingMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIImageProcessingMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIImageProcessingMode

# Register PropertyIImageProcessingMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIImageProcessingMode_swigregister(PropertyIImageProcessingMode)

class pairstringTImageProcessingMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTImageProcessingMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTImageProcessingMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTImageProcessingMode_first_get, lib_mvIMPACT_acquire.pairstringTImageProcessingMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTImageProcessingMode_second_get, lib_mvIMPACT_acquire.pairstringTImageProcessingMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTImageProcessingMode

# Register pairstringTImageProcessingMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTImageProcessingMode_swigregister(pairstringTImageProcessingMode)

class PropertyIImageProcessingOptimization(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIImageProcessingOptimization_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIImageProcessingOptimization(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TImageProcessingOptimization > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIImageProcessingOptimization_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIImageProcessingOptimization_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIImageProcessingOptimization_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIImageProcessingOptimization_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIImageProcessingOptimization_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIImageProcessingOptimization_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIImageProcessingOptimization_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIImageProcessingOptimization_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIImageProcessingOptimization_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingOptimization >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TImageProcessingOptimization,std::allocator< mvIMPACT::acquire::TImageProcessingOptimization > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIImageProcessingOptimization_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIImageProcessingOptimization

# Register PropertyIImageProcessingOptimization in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIImageProcessingOptimization_swigregister(PropertyIImageProcessingOptimization)

class pairstringTImageProcessingOptimization(object):
    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):
        lib_mvIMPACT_acquire.pairstringTImageProcessingOptimization_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTImageProcessingOptimization(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTImageProcessingOptimization_first_get, lib_mvIMPACT_acquire.pairstringTImageProcessingOptimization_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTImageProcessingOptimization_second_get, lib_mvIMPACT_acquire.pairstringTImageProcessingOptimization_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTImageProcessingOptimization

# Register pairstringTImageProcessingOptimization in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTImageProcessingOptimization_swigregister(pairstringTImageProcessingOptimization)

class PropertyIImageProcessingResult(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIImageProcessingResult_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIImageProcessingResult(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TImageProcessingResult > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIImageProcessingResult_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIImageProcessingResult_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIImageProcessingResult_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIImageProcessingResult_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIImageProcessingResult_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIImageProcessingResult_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIImageProcessingResult_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIImageProcessingResult_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIImageProcessingResult_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageProcessingResult >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TImageProcessingResult,std::allocator< mvIMPACT::acquire::TImageProcessingResult > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIImageProcessingResult_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIImageProcessingResult

# Register PropertyIImageProcessingResult in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIImageProcessingResult_swigregister(PropertyIImageProcessingResult)

class pairstringTImageProcessingResult(object):
    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):
        lib_mvIMPACT_acquire.pairstringTImageProcessingResult_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTImageProcessingResult(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTImageProcessingResult_first_get, lib_mvIMPACT_acquire.pairstringTImageProcessingResult_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTImageProcessingResult_second_get, lib_mvIMPACT_acquire.pairstringTImageProcessingResult_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTImageProcessingResult

# Register pairstringTImageProcessingResult in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTImageProcessingResult_swigregister(pairstringTImageProcessingResult)

class PropertyIRequestImageMemoryMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIRequestImageMemoryMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIRequestImageMemoryMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TRequestImageMemoryMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIRequestImageMemoryMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIRequestImageMemoryMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIRequestImageMemoryMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIRequestImageMemoryMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIRequestImageMemoryMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIRequestImageMemoryMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIRequestImageMemoryMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIRequestImageMemoryMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIRequestImageMemoryMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestImageMemoryMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TRequestImageMemoryMode,std::allocator< mvIMPACT::acquire::TRequestImageMemoryMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIRequestImageMemoryMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIRequestImageMemoryMode

# Register PropertyIRequestImageMemoryMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIRequestImageMemoryMode_swigregister(PropertyIRequestImageMemoryMode)

class pairstringTRequestImageMemoryMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTRequestImageMemoryMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTRequestImageMemoryMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTRequestImageMemoryMode_first_get, lib_mvIMPACT_acquire.pairstringTRequestImageMemoryMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTRequestImageMemoryMode_second_get, lib_mvIMPACT_acquire.pairstringTRequestImageMemoryMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTRequestImageMemoryMode

# Register pairstringTRequestImageMemoryMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTRequestImageMemoryMode_swigregister(pairstringTRequestImageMemoryMode)

class PropertyIImageRequestControlMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIImageRequestControlMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIImageRequestControlMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TImageRequestControlMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIImageRequestControlMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIImageRequestControlMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIImageRequestControlMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIImageRequestControlMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIImageRequestControlMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIImageRequestControlMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIImageRequestControlMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIImageRequestControlMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIImageRequestControlMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TImageRequestControlMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TImageRequestControlMode,std::allocator< mvIMPACT::acquire::TImageRequestControlMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIImageRequestControlMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIImageRequestControlMode

# Register PropertyIImageRequestControlMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIImageRequestControlMode_swigregister(PropertyIImageRequestControlMode)

class pairstringTImageRequestControlMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTImageRequestControlMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTImageRequestControlMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTImageRequestControlMode_first_get, lib_mvIMPACT_acquire.pairstringTImageRequestControlMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTImageRequestControlMode_second_get, lib_mvIMPACT_acquire.pairstringTImageRequestControlMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTImageRequestControlMode

# Register pairstringTImageRequestControlMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTImageRequestControlMode_swigregister(pairstringTImageRequestControlMode)

class PropertyIInfoSensorColorMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIInfoSensorColorMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIInfoSensorColorMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TInfoSensorColorMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIInfoSensorColorMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIInfoSensorColorMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIInfoSensorColorMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIInfoSensorColorMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIInfoSensorColorMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIInfoSensorColorMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIInfoSensorColorMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIInfoSensorColorMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIInfoSensorColorMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorColorMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TInfoSensorColorMode,std::allocator< mvIMPACT::acquire::TInfoSensorColorMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIInfoSensorColorMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIInfoSensorColorMode

# Register PropertyIInfoSensorColorMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIInfoSensorColorMode_swigregister(PropertyIInfoSensorColorMode)

class pairstringTInfoSensorColorMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTInfoSensorColorMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTInfoSensorColorMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTInfoSensorColorMode_first_get, lib_mvIMPACT_acquire.pairstringTInfoSensorColorMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTInfoSensorColorMode_second_get, lib_mvIMPACT_acquire.pairstringTInfoSensorColorMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTInfoSensorColorMode

# Register pairstringTInfoSensorColorMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTInfoSensorColorMode_swigregister(pairstringTInfoSensorColorMode)

class PropertyIInfoSensorType(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIInfoSensorType_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIInfoSensorType(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TInfoSensorType >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TInfoSensorType > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIInfoSensorType_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIInfoSensorType_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIInfoSensorType_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIInfoSensorType_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIInfoSensorType_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIInfoSensorType_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIInfoSensorType_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIInfoSensorType_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIInfoSensorType_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInfoSensorType >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TInfoSensorType,std::allocator< mvIMPACT::acquire::TInfoSensorType > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIInfoSensorType_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIInfoSensorType

# Register PropertyIInfoSensorType in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIInfoSensorType_swigregister(PropertyIInfoSensorType)

class pairstringTInfoSensorType(object):
    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):
        lib_mvIMPACT_acquire.pairstringTInfoSensorType_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTInfoSensorType(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTInfoSensorType_first_get, lib_mvIMPACT_acquire.pairstringTInfoSensorType_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTInfoSensorType_second_get, lib_mvIMPACT_acquire.pairstringTInfoSensorType_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTInfoSensorType

# Register pairstringTInfoSensorType in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTInfoSensorType_swigregister(pairstringTInfoSensorType)

class PropertyIInterfaceEnumerationBehaviour(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIInterfaceEnumerationBehaviour_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIInterfaceEnumerationBehaviour(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TInterfaceEnumerationBehaviour > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIInterfaceEnumerationBehaviour_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIInterfaceEnumerationBehaviour_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIInterfaceEnumerationBehaviour_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIInterfaceEnumerationBehaviour_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIInterfaceEnumerationBehaviour_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIInterfaceEnumerationBehaviour_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIInterfaceEnumerationBehaviour_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIInterfaceEnumerationBehaviour_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIInterfaceEnumerationBehaviour_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterfaceEnumerationBehaviour >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TInterfaceEnumerationBehaviour,std::allocator< mvIMPACT::acquire::TInterfaceEnumerationBehaviour > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIInterfaceEnumerationBehaviour_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIInterfaceEnumerationBehaviour

# Register PropertyIInterfaceEnumerationBehaviour in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIInterfaceEnumerationBehaviour_swigregister(PropertyIInterfaceEnumerationBehaviour)

class pairstringTInterfaceEnumerationBehaviour(object):
    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):
        lib_mvIMPACT_acquire.pairstringTInterfaceEnumerationBehaviour_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTInterfaceEnumerationBehaviour(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTInterfaceEnumerationBehaviour_first_get, lib_mvIMPACT_acquire.pairstringTInterfaceEnumerationBehaviour_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTInterfaceEnumerationBehaviour_second_get, lib_mvIMPACT_acquire.pairstringTInterfaceEnumerationBehaviour_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTInterfaceEnumerationBehaviour

# Register pairstringTInterfaceEnumerationBehaviour in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTInterfaceEnumerationBehaviour_swigregister(pairstringTInterfaceEnumerationBehaviour)

class PropertyIInterlacedMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIInterlacedMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIInterlacedMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TInterlacedMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TInterlacedMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIInterlacedMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIInterlacedMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIInterlacedMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIInterlacedMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIInterlacedMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIInterlacedMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIInterlacedMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIInterlacedMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIInterlacedMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TInterlacedMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TInterlacedMode,std::allocator< mvIMPACT::acquire::TInterlacedMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIInterlacedMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIInterlacedMode

# Register PropertyIInterlacedMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIInterlacedMode_swigregister(PropertyIInterlacedMode)

class pairstringTInterlacedMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTInterlacedMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTInterlacedMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTInterlacedMode_first_get, lib_mvIMPACT_acquire.pairstringTInterlacedMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTInterlacedMode_second_get, lib_mvIMPACT_acquire.pairstringTInterlacedMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTInterlacedMode

# Register pairstringTInterlacedMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTInterlacedMode_swigregister(pairstringTInterlacedMode)

class PropertyILineCounter(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyILineCounter_swiginit(self, lib_mvIMPACT_acquire.new_PropertyILineCounter(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TLineCounter >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TLineCounter > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyILineCounter_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyILineCounter_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyILineCounter_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyILineCounter_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyILineCounter_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyILineCounter_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyILineCounter_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyILineCounter_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyILineCounter_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLineCounter >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TLineCounter,std::allocator< mvIMPACT::acquire::TLineCounter > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyILineCounter_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyILineCounter

# Register PropertyILineCounter in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyILineCounter_swigregister(PropertyILineCounter)

class pairstringTLineCounter(object):
    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):
        lib_mvIMPACT_acquire.pairstringTLineCounter_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTLineCounter(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTLineCounter_first_get, lib_mvIMPACT_acquire.pairstringTLineCounter_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTLineCounter_second_get, lib_mvIMPACT_acquire.pairstringTLineCounter_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTLineCounter

# Register pairstringTLineCounter in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTLineCounter_swigregister(pairstringTLineCounter)

class PropertyILUTGammaMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyILUTGammaMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyILUTGammaMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TLUTGammaMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyILUTGammaMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyILUTGammaMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyILUTGammaMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyILUTGammaMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyILUTGammaMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyILUTGammaMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyILUTGammaMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyILUTGammaMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyILUTGammaMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTGammaMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTGammaMode,std::allocator< mvIMPACT::acquire::TLUTGammaMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyILUTGammaMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyILUTGammaMode

# Register PropertyILUTGammaMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyILUTGammaMode_swigregister(PropertyILUTGammaMode)

class pairstringTLUTGammaMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTLUTGammaMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTLUTGammaMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTLUTGammaMode_first_get, lib_mvIMPACT_acquire.pairstringTLUTGammaMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTLUTGammaMode_second_get, lib_mvIMPACT_acquire.pairstringTLUTGammaMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTLUTGammaMode

# Register pairstringTLUTGammaMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTLUTGammaMode_swigregister(pairstringTLUTGammaMode)

class PropertyILUTImplementation(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyILUTImplementation_swiginit(self, lib_mvIMPACT_acquire.new_PropertyILUTImplementation(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TLUTImplementation >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TLUTImplementation > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyILUTImplementation_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyILUTImplementation_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyILUTImplementation_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyILUTImplementation_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyILUTImplementation_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyILUTImplementation_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyILUTImplementation_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyILUTImplementation_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyILUTImplementation_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTImplementation >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTImplementation,std::allocator< mvIMPACT::acquire::TLUTImplementation > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyILUTImplementation_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyILUTImplementation

# Register PropertyILUTImplementation in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyILUTImplementation_swigregister(PropertyILUTImplementation)

class pairstringTLUTImplementation(object):
    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):
        lib_mvIMPACT_acquire.pairstringTLUTImplementation_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTLUTImplementation(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTLUTImplementation_first_get, lib_mvIMPACT_acquire.pairstringTLUTImplementation_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTLUTImplementation_second_get, lib_mvIMPACT_acquire.pairstringTLUTImplementation_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTLUTImplementation

# Register pairstringTLUTImplementation in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTLUTImplementation_swigregister(pairstringTLUTImplementation)

class PropertyILUTInterpolationMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyILUTInterpolationMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyILUTInterpolationMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TLUTInterpolationMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyILUTInterpolationMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyILUTInterpolationMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyILUTInterpolationMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyILUTInterpolationMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyILUTInterpolationMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyILUTInterpolationMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyILUTInterpolationMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyILUTInterpolationMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyILUTInterpolationMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTInterpolationMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTInterpolationMode,std::allocator< mvIMPACT::acquire::TLUTInterpolationMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyILUTInterpolationMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyILUTInterpolationMode

# Register PropertyILUTInterpolationMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyILUTInterpolationMode_swigregister(PropertyILUTInterpolationMode)

class pairstringTLUTInterpolationMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTLUTInterpolationMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTLUTInterpolationMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTLUTInterpolationMode_first_get, lib_mvIMPACT_acquire.pairstringTLUTInterpolationMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTLUTInterpolationMode_second_get, lib_mvIMPACT_acquire.pairstringTLUTInterpolationMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTLUTInterpolationMode

# Register pairstringTLUTInterpolationMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTLUTInterpolationMode_swigregister(pairstringTLUTInterpolationMode)

class PropertyILUTMapping(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyILUTMapping_swiginit(self, lib_mvIMPACT_acquire.new_PropertyILUTMapping(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TLUTMapping >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TLUTMapping > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyILUTMapping_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyILUTMapping_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyILUTMapping_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyILUTMapping_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyILUTMapping_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyILUTMapping_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyILUTMapping_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyILUTMapping_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyILUTMapping_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMapping >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTMapping,std::allocator< mvIMPACT::acquire::TLUTMapping > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyILUTMapping_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyILUTMapping

# Register PropertyILUTMapping in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyILUTMapping_swigregister(PropertyILUTMapping)

class pairstringTLUTMapping(object):
    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):
        lib_mvIMPACT_acquire.pairstringTLUTMapping_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTLUTMapping(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTLUTMapping_first_get, lib_mvIMPACT_acquire.pairstringTLUTMapping_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTLUTMapping_second_get, lib_mvIMPACT_acquire.pairstringTLUTMapping_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTLUTMapping

# Register pairstringTLUTMapping in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTLUTMapping_swigregister(pairstringTLUTMapping)

class PropertyILUTMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyILUTMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyILUTMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TLUTMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TLUTMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyILUTMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyILUTMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyILUTMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyILUTMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyILUTMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyILUTMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyILUTMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyILUTMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyILUTMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TLUTMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TLUTMode,std::allocator< mvIMPACT::acquire::TLUTMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyILUTMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyILUTMode

# Register PropertyILUTMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyILUTMode_swigregister(PropertyILUTMode)

class pairstringTLUTMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTLUTMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTLUTMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTLUTMode_first_get, lib_mvIMPACT_acquire.pairstringTLUTMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTLUTMode_second_get, lib_mvIMPACT_acquire.pairstringTLUTMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTLUTMode

# Register pairstringTLUTMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTLUTMode_swigregister(pairstringTLUTMode)

class PropertyIMemoryManagerMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIMemoryManagerMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIMemoryManagerMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TMemoryManagerMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIMemoryManagerMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIMemoryManagerMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIMemoryManagerMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIMemoryManagerMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIMemoryManagerMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIMemoryManagerMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIMemoryManagerMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIMemoryManagerMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIMemoryManagerMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TMemoryManagerMode,std::allocator< mvIMPACT::acquire::TMemoryManagerMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIMemoryManagerMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIMemoryManagerMode

# Register PropertyIMemoryManagerMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIMemoryManagerMode_swigregister(PropertyIMemoryManagerMode)

class pairstringTMemoryManagerMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTMemoryManagerMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTMemoryManagerMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTMemoryManagerMode_first_get, lib_mvIMPACT_acquire.pairstringTMemoryManagerMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTMemoryManagerMode_second_get, lib_mvIMPACT_acquire.pairstringTMemoryManagerMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTMemoryManagerMode

# Register pairstringTMemoryManagerMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTMemoryManagerMode_swigregister(pairstringTMemoryManagerMode)

class PropertyIMemoryManagerPoolMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIMemoryManagerPoolMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIMemoryManagerPoolMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TMemoryManagerPoolMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIMemoryManagerPoolMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIMemoryManagerPoolMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIMemoryManagerPoolMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIMemoryManagerPoolMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIMemoryManagerPoolMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIMemoryManagerPoolMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIMemoryManagerPoolMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIMemoryManagerPoolMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIMemoryManagerPoolMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMemoryManagerPoolMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TMemoryManagerPoolMode,std::allocator< mvIMPACT::acquire::TMemoryManagerPoolMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIMemoryManagerPoolMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIMemoryManagerPoolMode

# Register PropertyIMemoryManagerPoolMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIMemoryManagerPoolMode_swigregister(PropertyIMemoryManagerPoolMode)

class pairstringTMemoryManagerPoolMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTMemoryManagerPoolMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTMemoryManagerPoolMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTMemoryManagerPoolMode_first_get, lib_mvIMPACT_acquire.pairstringTMemoryManagerPoolMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTMemoryManagerPoolMode_second_get, lib_mvIMPACT_acquire.pairstringTMemoryManagerPoolMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTMemoryManagerPoolMode

# Register pairstringTMemoryManagerPoolMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTMemoryManagerPoolMode_swigregister(pairstringTMemoryManagerPoolMode)

class PropertyIMirrorMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIMirrorMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIMirrorMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TMirrorMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TMirrorMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIMirrorMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIMirrorMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIMirrorMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIMirrorMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIMirrorMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIMirrorMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIMirrorMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIMirrorMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIMirrorMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TMirrorMode,std::allocator< mvIMPACT::acquire::TMirrorMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIMirrorMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIMirrorMode

# Register PropertyIMirrorMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIMirrorMode_swigregister(PropertyIMirrorMode)

class pairstringTMirrorMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTMirrorMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTMirrorMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTMirrorMode_first_get, lib_mvIMPACT_acquire.pairstringTMirrorMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTMirrorMode_second_get, lib_mvIMPACT_acquire.pairstringTMirrorMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTMirrorMode

# Register pairstringTMirrorMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTMirrorMode_swigregister(pairstringTMirrorMode)

class PropertyIMirrorOperationMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIMirrorOperationMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIMirrorOperationMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TMirrorOperationMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIMirrorOperationMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIMirrorOperationMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIMirrorOperationMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIMirrorOperationMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIMirrorOperationMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIMirrorOperationMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIMirrorOperationMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIMirrorOperationMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIMirrorOperationMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TMirrorOperationMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TMirrorOperationMode,std::allocator< mvIMPACT::acquire::TMirrorOperationMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIMirrorOperationMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIMirrorOperationMode

# Register PropertyIMirrorOperationMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIMirrorOperationMode_swigregister(PropertyIMirrorOperationMode)

class pairstringTMirrorOperationMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTMirrorOperationMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTMirrorOperationMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTMirrorOperationMode_first_get, lib_mvIMPACT_acquire.pairstringTMirrorOperationMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTMirrorOperationMode_second_get, lib_mvIMPACT_acquire.pairstringTMirrorOperationMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTMirrorOperationMode

# Register pairstringTMirrorOperationMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTMirrorOperationMode_swigregister(pairstringTMirrorOperationMode)

class PropertyIOnBoardMemoryMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIOnBoardMemoryMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIOnBoardMemoryMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TOnBoardMemoryMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIOnBoardMemoryMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIOnBoardMemoryMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIOnBoardMemoryMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIOnBoardMemoryMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIOnBoardMemoryMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIOnBoardMemoryMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIOnBoardMemoryMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIOnBoardMemoryMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIOnBoardMemoryMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TOnBoardMemoryMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TOnBoardMemoryMode,std::allocator< mvIMPACT::acquire::TOnBoardMemoryMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIOnBoardMemoryMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIOnBoardMemoryMode

# Register PropertyIOnBoardMemoryMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIOnBoardMemoryMode_swigregister(PropertyIOnBoardMemoryMode)

class pairstringTOnBoardMemoryMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTOnBoardMemoryMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTOnBoardMemoryMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTOnBoardMemoryMode_first_get, lib_mvIMPACT_acquire.pairstringTOnBoardMemoryMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTOnBoardMemoryMode_second_get, lib_mvIMPACT_acquire.pairstringTOnBoardMemoryMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTOnBoardMemoryMode

# Register pairstringTOnBoardMemoryMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTOnBoardMemoryMode_swigregister(pairstringTOnBoardMemoryMode)

class PropertyIPolarizedDataExtractionMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIPolarizedDataExtractionMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIPolarizedDataExtractionMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIPolarizedDataExtractionMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIPolarizedDataExtractionMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIPolarizedDataExtractionMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIPolarizedDataExtractionMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIPolarizedDataExtractionMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIPolarizedDataExtractionMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIPolarizedDataExtractionMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIPolarizedDataExtractionMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIPolarizedDataExtractionMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TPolarizedDataExtractionMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIPolarizedDataExtractionMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIPolarizedDataExtractionMode

# Register PropertyIPolarizedDataExtractionMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIPolarizedDataExtractionMode_swigregister(PropertyIPolarizedDataExtractionMode)

class pairstringTPolarizedDataExtractionMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTPolarizedDataExtractionMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTPolarizedDataExtractionMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTPolarizedDataExtractionMode_first_get, lib_mvIMPACT_acquire.pairstringTPolarizedDataExtractionMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTPolarizedDataExtractionMode_second_get, lib_mvIMPACT_acquire.pairstringTPolarizedDataExtractionMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTPolarizedDataExtractionMode

# Register pairstringTPolarizedDataExtractionMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTPolarizedDataExtractionMode_swigregister(pairstringTPolarizedDataExtractionMode)

class PropertyIPolarizedDataExtractionInterpolationMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIPolarizedDataExtractionInterpolationMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIPolarizedDataExtractionInterpolationMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIPolarizedDataExtractionInterpolationMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIPolarizedDataExtractionInterpolationMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIPolarizedDataExtractionInterpolationMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIPolarizedDataExtractionInterpolationMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIPolarizedDataExtractionInterpolationMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode,std::allocator< mvIMPACT::acquire::TPolarizedDataExtractionInterpolationMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIPolarizedDataExtractionInterpolationMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIPolarizedDataExtractionInterpolationMode

# Register PropertyIPolarizedDataExtractionInterpolationMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIPolarizedDataExtractionInterpolationMode_swigregister(PropertyIPolarizedDataExtractionInterpolationMode)

class pairstringTPolarizedDataExtractionInterpolationMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTPolarizedDataExtractionInterpolationMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTPolarizedDataExtractionInterpolationMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTPolarizedDataExtractionInterpolationMode_first_get, lib_mvIMPACT_acquire.pairstringTPolarizedDataExtractionInterpolationMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTPolarizedDataExtractionInterpolationMode_second_get, lib_mvIMPACT_acquire.pairstringTPolarizedDataExtractionInterpolationMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTPolarizedDataExtractionInterpolationMode

# Register pairstringTPolarizedDataExtractionInterpolationMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTPolarizedDataExtractionInterpolationMode_swigregister(pairstringTPolarizedDataExtractionInterpolationMode)

class PropertyIPulseStartTrigger(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIPulseStartTrigger_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIPulseStartTrigger(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TPulseStartTrigger > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIPulseStartTrigger_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIPulseStartTrigger_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIPulseStartTrigger_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIPulseStartTrigger_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIPulseStartTrigger_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIPulseStartTrigger_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIPulseStartTrigger_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIPulseStartTrigger_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIPulseStartTrigger_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TPulseStartTrigger >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TPulseStartTrigger,std::allocator< mvIMPACT::acquire::TPulseStartTrigger > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIPulseStartTrigger_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIPulseStartTrigger

# Register PropertyIPulseStartTrigger in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIPulseStartTrigger_swigregister(PropertyIPulseStartTrigger)

class pairstringTPulseStartTrigger(object):
    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):
        lib_mvIMPACT_acquire.pairstringTPulseStartTrigger_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTPulseStartTrigger(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTPulseStartTrigger_first_get, lib_mvIMPACT_acquire.pairstringTPulseStartTrigger_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTPulseStartTrigger_second_get, lib_mvIMPACT_acquire.pairstringTPulseStartTrigger_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTPulseStartTrigger

# Register pairstringTPulseStartTrigger in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTPulseStartTrigger_swigregister(pairstringTPulseStartTrigger)

class PropertyIRequestResult(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIRequestResult_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIRequestResult(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TRequestResult >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TRequestResult > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIRequestResult_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIRequestResult_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIRequestResult_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIRequestResult_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIRequestResult_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIRequestResult_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIRequestResult_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIRequestResult_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIRequestResult_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestResult >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TRequestResult,std::allocator< mvIMPACT::acquire::TRequestResult > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIRequestResult_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIRequestResult

# Register PropertyIRequestResult in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIRequestResult_swigregister(PropertyIRequestResult)

class pairstringTRequestResult(object):
    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):
        lib_mvIMPACT_acquire.pairstringTRequestResult_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTRequestResult(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTRequestResult_first_get, lib_mvIMPACT_acquire.pairstringTRequestResult_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTRequestResult_second_get, lib_mvIMPACT_acquire.pairstringTRequestResult_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTRequestResult

# Register pairstringTRequestResult in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTRequestResult_swigregister(pairstringTRequestResult)

class PropertyIRequestState(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIRequestState_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIRequestState(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TRequestState >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TRequestState > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIRequestState_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIRequestState_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIRequestState_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIRequestState_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIRequestState_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIRequestState_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIRequestState_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIRequestState_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIRequestState_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRequestState >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TRequestState,std::allocator< mvIMPACT::acquire::TRequestState > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIRequestState_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIRequestState

# Register PropertyIRequestState in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIRequestState_swigregister(PropertyIRequestState)

class pairstringTRequestState(object):
    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):
        lib_mvIMPACT_acquire.pairstringTRequestState_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTRequestState(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTRequestState_first_get, lib_mvIMPACT_acquire.pairstringTRequestState_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTRequestState_second_get, lib_mvIMPACT_acquire.pairstringTRequestState_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTRequestState

# Register pairstringTRequestState in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTRequestState_swigregister(pairstringTRequestState)

class PropertyIRTCtrlModes(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIRTCtrlModes_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIRTCtrlModes(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TRTCtrlModes > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIRTCtrlModes_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIRTCtrlModes_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIRTCtrlModes_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIRTCtrlModes_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIRTCtrlModes_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIRTCtrlModes_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIRTCtrlModes_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIRTCtrlModes_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIRTCtrlModes_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTCtrlModes >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TRTCtrlModes,std::allocator< mvIMPACT::acquire::TRTCtrlModes > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIRTCtrlModes_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIRTCtrlModes

# Register PropertyIRTCtrlModes in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIRTCtrlModes_swigregister(PropertyIRTCtrlModes)

class pairstringTRTCtrlModes(object):
    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):
        lib_mvIMPACT_acquire.pairstringTRTCtrlModes_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTRTCtrlModes(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTRTCtrlModes_first_get, lib_mvIMPACT_acquire.pairstringTRTCtrlModes_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTRTCtrlModes_second_get, lib_mvIMPACT_acquire.pairstringTRTCtrlModes_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTRTCtrlModes

# Register pairstringTRTCtrlModes in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTRTCtrlModes_swigregister(pairstringTRTCtrlModes)

class PropertyIRTProgOpCodes(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIRTProgOpCodes_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIRTProgOpCodes(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TRTProgOpCodes > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIRTProgOpCodes_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIRTProgOpCodes_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIRTProgOpCodes_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIRTProgOpCodes_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIRTProgOpCodes_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIRTProgOpCodes_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIRTProgOpCodes_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIRTProgOpCodes_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIRTProgOpCodes_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TRTProgOpCodes >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TRTProgOpCodes,std::allocator< mvIMPACT::acquire::TRTProgOpCodes > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIRTProgOpCodes_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIRTProgOpCodes

# Register PropertyIRTProgOpCodes in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIRTProgOpCodes_swigregister(PropertyIRTProgOpCodes)

class pairstringTRTProgOpCodes(object):
    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):
        lib_mvIMPACT_acquire.pairstringTRTProgOpCodes_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTRTProgOpCodes(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTRTProgOpCodes_first_get, lib_mvIMPACT_acquire.pairstringTRTProgOpCodes_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTRTProgOpCodes_second_get, lib_mvIMPACT_acquire.pairstringTRTProgOpCodes_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTRTProgOpCodes

# Register pairstringTRTProgOpCodes in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTRTProgOpCodes_swigregister(pairstringTRTProgOpCodes)

class PropertyIScalerMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIScalerMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIScalerMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TScalerMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TScalerMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIScalerMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIScalerMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIScalerMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIScalerMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIScalerMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIScalerMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIScalerMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIScalerMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIScalerMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TScalerMode,std::allocator< mvIMPACT::acquire::TScalerMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIScalerMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIScalerMode

# Register PropertyIScalerMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIScalerMode_swigregister(PropertyIScalerMode)

class pairstringTScalerMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTScalerMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTScalerMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTScalerMode_first_get, lib_mvIMPACT_acquire.pairstringTScalerMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTScalerMode_second_get, lib_mvIMPACT_acquire.pairstringTScalerMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTScalerMode

# Register pairstringTScalerMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTScalerMode_swigregister(pairstringTScalerMode)

class PropertyIScalerInterpolationMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIScalerInterpolationMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIScalerInterpolationMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TScalerInterpolationMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIScalerInterpolationMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIScalerInterpolationMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIScalerInterpolationMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIScalerInterpolationMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIScalerInterpolationMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIScalerInterpolationMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIScalerInterpolationMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIScalerInterpolationMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIScalerInterpolationMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScalerInterpolationMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TScalerInterpolationMode,std::allocator< mvIMPACT::acquire::TScalerInterpolationMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIScalerInterpolationMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIScalerInterpolationMode

# Register PropertyIScalerInterpolationMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIScalerInterpolationMode_swigregister(PropertyIScalerInterpolationMode)

class pairstringTScalerInterpolationMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTScalerInterpolationMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTScalerInterpolationMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTScalerInterpolationMode_first_get, lib_mvIMPACT_acquire.pairstringTScalerInterpolationMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTScalerInterpolationMode_second_get, lib_mvIMPACT_acquire.pairstringTScalerInterpolationMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTScalerInterpolationMode

# Register pairstringTScalerInterpolationMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTScalerInterpolationMode_swigregister(pairstringTScalerInterpolationMode)

class PropertyIScanClock(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIScanClock_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIScanClock(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TScanClock >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TScanClock > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIScanClock_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIScanClock_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIScanClock_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIScanClock_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIScanClock_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIScanClock_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIScanClock_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIScanClock_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIScanClock_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanClock >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TScanClock,std::allocator< mvIMPACT::acquire::TScanClock > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIScanClock_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIScanClock

# Register PropertyIScanClock in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIScanClock_swigregister(PropertyIScanClock)

class pairstringTScanClock(object):
    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):
        lib_mvIMPACT_acquire.pairstringTScanClock_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTScanClock(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTScanClock_first_get, lib_mvIMPACT_acquire.pairstringTScanClock_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTScanClock_second_get, lib_mvIMPACT_acquire.pairstringTScanClock_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTScanClock

# Register pairstringTScanClock in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTScanClock_swigregister(pairstringTScanClock)

class PropertyIScanStandard(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIScanStandard_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIScanStandard(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TScanStandard >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TScanStandard > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIScanStandard_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIScanStandard_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIScanStandard_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIScanStandard_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIScanStandard_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIScanStandard_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIScanStandard_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIScanStandard_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIScanStandard_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TScanStandard >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TScanStandard,std::allocator< mvIMPACT::acquire::TScanStandard > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIScanStandard_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIScanStandard

# Register PropertyIScanStandard in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIScanStandard_swigregister(PropertyIScanStandard)

class pairstringTScanStandard(object):
    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):
        lib_mvIMPACT_acquire.pairstringTScanStandard_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTScanStandard(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTScanStandard_first_get, lib_mvIMPACT_acquire.pairstringTScanStandard_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTScanStandard_second_get, lib_mvIMPACT_acquire.pairstringTScanStandard_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTScanStandard

# Register pairstringTScanStandard in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTScanStandard_swigregister(pairstringTScanStandard)

class PropertyITriggerMoment(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyITriggerMoment_swiginit(self, lib_mvIMPACT_acquire.new_PropertyITriggerMoment(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TTriggerMoment >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TTriggerMoment > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyITriggerMoment_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyITriggerMoment_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyITriggerMoment_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyITriggerMoment_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyITriggerMoment_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyITriggerMoment_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyITriggerMoment_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyITriggerMoment_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyITriggerMoment_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TTriggerMoment >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TTriggerMoment,std::allocator< mvIMPACT::acquire::TTriggerMoment > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyITriggerMoment_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyITriggerMoment

# Register PropertyITriggerMoment in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyITriggerMoment_swigregister(PropertyITriggerMoment)

class pairstringTTriggerMoment(object):
    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):
        lib_mvIMPACT_acquire.pairstringTTriggerMoment_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTTriggerMoment(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTTriggerMoment_first_get, lib_mvIMPACT_acquire.pairstringTTriggerMoment_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTTriggerMoment_second_get, lib_mvIMPACT_acquire.pairstringTTriggerMoment_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTTriggerMoment

# Register pairstringTTriggerMoment in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTTriggerMoment_swigregister(pairstringTTriggerMoment)

class PropertyIUserDataAccessRight(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIUserDataAccessRight_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIUserDataAccessRight(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TUserDataAccessRight > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIUserDataAccessRight_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIUserDataAccessRight_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIUserDataAccessRight_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIUserDataAccessRight_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIUserDataAccessRight_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIUserDataAccessRight_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIUserDataAccessRight_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIUserDataAccessRight_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIUserDataAccessRight_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataAccessRight >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TUserDataAccessRight,std::allocator< mvIMPACT::acquire::TUserDataAccessRight > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIUserDataAccessRight_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIUserDataAccessRight

# Register PropertyIUserDataAccessRight in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIUserDataAccessRight_swigregister(PropertyIUserDataAccessRight)

class pairstringTUserDataAccessRight(object):
    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):
        lib_mvIMPACT_acquire.pairstringTUserDataAccessRight_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTUserDataAccessRight(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTUserDataAccessRight_first_get, lib_mvIMPACT_acquire.pairstringTUserDataAccessRight_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTUserDataAccessRight_second_get, lib_mvIMPACT_acquire.pairstringTUserDataAccessRight_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTUserDataAccessRight

# Register pairstringTUserDataAccessRight in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTUserDataAccessRight_swigregister(pairstringTUserDataAccessRight)

class PropertyIUserDataReconnectBehaviour(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIUserDataReconnectBehaviour_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIUserDataReconnectBehaviour(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TUserDataReconnectBehaviour > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIUserDataReconnectBehaviour_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIUserDataReconnectBehaviour_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIUserDataReconnectBehaviour_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIUserDataReconnectBehaviour_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIUserDataReconnectBehaviour_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIUserDataReconnectBehaviour_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIUserDataReconnectBehaviour_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIUserDataReconnectBehaviour_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIUserDataReconnectBehaviour_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TUserDataReconnectBehaviour >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TUserDataReconnectBehaviour,std::allocator< mvIMPACT::acquire::TUserDataReconnectBehaviour > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIUserDataReconnectBehaviour_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIUserDataReconnectBehaviour

# Register PropertyIUserDataReconnectBehaviour in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIUserDataReconnectBehaviour_swigregister(PropertyIUserDataReconnectBehaviour)

class pairstringTUserDataReconnectBehaviour(object):
    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):
        lib_mvIMPACT_acquire.pairstringTUserDataReconnectBehaviour_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTUserDataReconnectBehaviour(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTUserDataReconnectBehaviour_first_get, lib_mvIMPACT_acquire.pairstringTUserDataReconnectBehaviour_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTUserDataReconnectBehaviour_second_get, lib_mvIMPACT_acquire.pairstringTUserDataReconnectBehaviour_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTUserDataReconnectBehaviour

# Register pairstringTUserDataReconnectBehaviour in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTUserDataReconnectBehaviour_swigregister(pairstringTUserDataReconnectBehaviour)

class PropertyIVideoStandard(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIVideoStandard_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIVideoStandard(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TVideoStandard >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TVideoStandard > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIVideoStandard_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIVideoStandard_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIVideoStandard_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIVideoStandard_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIVideoStandard_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIVideoStandard_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIVideoStandard_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIVideoStandard_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIVideoStandard_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVideoStandard >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TVideoStandard,std::allocator< mvIMPACT::acquire::TVideoStandard > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIVideoStandard_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIVideoStandard

# Register PropertyIVideoStandard in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIVideoStandard_swigregister(PropertyIVideoStandard)

class pairstringTVideoStandard(object):
    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):
        lib_mvIMPACT_acquire.pairstringTVideoStandard_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTVideoStandard(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTVideoStandard_first_get, lib_mvIMPACT_acquire.pairstringTVideoStandard_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTVideoStandard_second_get, lib_mvIMPACT_acquire.pairstringTVideoStandard_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTVideoStandard

# Register pairstringTVideoStandard in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTVideoStandard_swigregister(pairstringTVideoStandard)

class PropertyIVirtualDeviceImageType(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIVirtualDeviceImageType_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIVirtualDeviceImageType(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceImageType > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIVirtualDeviceImageType_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIVirtualDeviceImageType_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIVirtualDeviceImageType_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIVirtualDeviceImageType_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIVirtualDeviceImageType_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIVirtualDeviceImageType_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIVirtualDeviceImageType_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIVirtualDeviceImageType_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIVirtualDeviceImageType_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceImageType >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TVirtualDeviceImageType,std::allocator< mvIMPACT::acquire::TVirtualDeviceImageType > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIVirtualDeviceImageType_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIVirtualDeviceImageType

# Register PropertyIVirtualDeviceImageType in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIVirtualDeviceImageType_swigregister(PropertyIVirtualDeviceImageType)

class pairstringTVirtualDeviceImageType(object):
    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):
        lib_mvIMPACT_acquire.pairstringTVirtualDeviceImageType_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTVirtualDeviceImageType(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTVirtualDeviceImageType_first_get, lib_mvIMPACT_acquire.pairstringTVirtualDeviceImageType_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTVirtualDeviceImageType_second_get, lib_mvIMPACT_acquire.pairstringTVirtualDeviceImageType_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTVirtualDeviceImageType

# Register pairstringTVirtualDeviceImageType in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTVirtualDeviceImageType_swigregister(pairstringTVirtualDeviceImageType)

class PropertyIVirtualDeviceTestMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIVirtualDeviceTestMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIVirtualDeviceTestMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TVirtualDeviceTestMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIVirtualDeviceTestMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIVirtualDeviceTestMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIVirtualDeviceTestMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIVirtualDeviceTestMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIVirtualDeviceTestMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIVirtualDeviceTestMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIVirtualDeviceTestMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIVirtualDeviceTestMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIVirtualDeviceTestMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TVirtualDeviceTestMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TVirtualDeviceTestMode,std::allocator< mvIMPACT::acquire::TVirtualDeviceTestMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIVirtualDeviceTestMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIVirtualDeviceTestMode

# Register PropertyIVirtualDeviceTestMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIVirtualDeviceTestMode_swigregister(PropertyIVirtualDeviceTestMode)

class pairstringTVirtualDeviceTestMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTVirtualDeviceTestMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTVirtualDeviceTestMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTVirtualDeviceTestMode_first_get, lib_mvIMPACT_acquire.pairstringTVirtualDeviceTestMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTVirtualDeviceTestMode_second_get, lib_mvIMPACT_acquire.pairstringTVirtualDeviceTestMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTVirtualDeviceTestMode

# Register pairstringTVirtualDeviceTestMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTVirtualDeviceTestMode_swigregister(pairstringTVirtualDeviceTestMode)

class PropertyIWhiteBalanceCalibrationMode(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIWhiteBalanceCalibrationMode_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIWhiteBalanceCalibrationMode(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceCalibrationMode > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIWhiteBalanceCalibrationMode_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIWhiteBalanceCalibrationMode_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIWhiteBalanceCalibrationMode_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIWhiteBalanceCalibrationMode_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIWhiteBalanceCalibrationMode_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIWhiteBalanceCalibrationMode_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIWhiteBalanceCalibrationMode_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIWhiteBalanceCalibrationMode_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIWhiteBalanceCalibrationMode_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceCalibrationMode >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TWhiteBalanceCalibrationMode,std::allocator< mvIMPACT::acquire::TWhiteBalanceCalibrationMode > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIWhiteBalanceCalibrationMode_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIWhiteBalanceCalibrationMode

# Register PropertyIWhiteBalanceCalibrationMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIWhiteBalanceCalibrationMode_swigregister(PropertyIWhiteBalanceCalibrationMode)

class pairstringTWhiteBalanceCalibrationMode(object):
    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):
        lib_mvIMPACT_acquire.pairstringTWhiteBalanceCalibrationMode_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTWhiteBalanceCalibrationMode(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTWhiteBalanceCalibrationMode_first_get, lib_mvIMPACT_acquire.pairstringTWhiteBalanceCalibrationMode_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTWhiteBalanceCalibrationMode_second_get, lib_mvIMPACT_acquire.pairstringTWhiteBalanceCalibrationMode_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTWhiteBalanceCalibrationMode

# Register pairstringTWhiteBalanceCalibrationMode in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTWhiteBalanceCalibrationMode_swigregister(pairstringTWhiteBalanceCalibrationMode)

class PropertyIWhiteBalanceParameter(Property):
    r"""
    A template class to represent 32 bit integer properties and 32 bit enumerated integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** object.
        :type hProp: int
        :param hProp: [in] A valid handle to an integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyIWhiteBalanceParameter_swiginit(self, lib_mvIMPACT_acquire.new_PropertyIWhiteBalanceParameter(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TWhiteBalanceParameter > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyIWhiteBalanceParameter_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIWhiteBalanceParameter_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIWhiteBalanceParameter_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIWhiteBalanceParameter_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyIWhiteBalanceParameter_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIWhiteBalanceParameter_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIWhiteBalanceParameter_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyIWhiteBalanceParameter_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyIWhiteBalanceParameter_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI< mvIMPACT::acquire::TWhiteBalanceParameter >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TWhiteBalanceParameter,std::allocator< mvIMPACT::acquire::TWhiteBalanceParameter > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyIWhiteBalanceParameter_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyIWhiteBalanceParameter

# Register PropertyIWhiteBalanceParameter in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyIWhiteBalanceParameter_swigregister(PropertyIWhiteBalanceParameter)

class pairstringTWhiteBalanceParameter(object):
    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):
        lib_mvIMPACT_acquire.pairstringTWhiteBalanceParameter_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTWhiteBalanceParameter(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTWhiteBalanceParameter_first_get, lib_mvIMPACT_acquire.pairstringTWhiteBalanceParameter_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTWhiteBalanceParameter_second_get, lib_mvIMPACT_acquire.pairstringTWhiteBalanceParameter_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTWhiteBalanceParameter

# Register pairstringTWhiteBalanceParameter in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTWhiteBalanceParameter_swigregister(pairstringTWhiteBalanceParameter)

class PropertyI64(Property):
    r"""
    A template class to represent 64 bit integer properties and enumerated 64 bit integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI64** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI64** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI64** object.
        :type hProp: int
        :param hProp: [in] A valid handle to a 64-bit integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI64** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI64** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyI64_swiginit(self, lib_mvIMPACT_acquire.new_PropertyI64(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI64::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI64::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::int64_type >,std::allocator< std::pair< std::string,mvIMPACT::acquire::int64_type > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyI64_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyI64_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI64::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyI64_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI64::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyI64_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI64::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyI64_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyI64_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyI64_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyI64_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyI64_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::int64_type >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::int64_type,std::allocator< mvIMPACT::acquire::int64_type > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyI64_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyI64

# Register PropertyI64 in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyI64_swigregister(PropertyI64)

class pairstringint64_type(object):
    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):
        lib_mvIMPACT_acquire.pairstringint64_type_swiginit(self, lib_mvIMPACT_acquire.new_pairstringint64_type(*args))
    first = property(lib_mvIMPACT_acquire.pairstringint64_type_first_get, lib_mvIMPACT_acquire.pairstringint64_type_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringint64_type_second_get, lib_mvIMPACT_acquire.pairstringint64_type_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringint64_type

# Register pairstringint64_type in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringint64_type_swigregister(pairstringint64_type)

class PropertyI64BufferPartDataType(Property):
    r"""
    A template class to represent 64 bit integer properties and enumerated 64 bit integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI64** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI64** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI64** object.
        :type hProp: int
        :param hProp: [in] A valid handle to a 64-bit integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI64** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI64** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyI64BufferPartDataType_swiginit(self, lib_mvIMPACT_acquire.new_PropertyI64BufferPartDataType(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI64::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI64::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TBufferPartDataType > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyI64BufferPartDataType_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyI64BufferPartDataType_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI64::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyI64BufferPartDataType_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI64::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyI64BufferPartDataType_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI64::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyI64BufferPartDataType_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyI64BufferPartDataType_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyI64BufferPartDataType_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyI64BufferPartDataType_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyI64BufferPartDataType_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TBufferPartDataType >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TBufferPartDataType,std::allocator< mvIMPACT::acquire::TBufferPartDataType > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyI64BufferPartDataType_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyI64BufferPartDataType

# Register PropertyI64BufferPartDataType in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyI64BufferPartDataType_swigregister(PropertyI64BufferPartDataType)

class pairstringTBufferPartDataType(object):
    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):
        lib_mvIMPACT_acquire.pairstringTBufferPartDataType_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTBufferPartDataType(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTBufferPartDataType_first_get, lib_mvIMPACT_acquire.pairstringTBufferPartDataType_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTBufferPartDataType_second_get, lib_mvIMPACT_acquire.pairstringTBufferPartDataType_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTBufferPartDataType

# Register pairstringTBufferPartDataType in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTBufferPartDataType_swigregister(pairstringTBufferPartDataType)

class PropertyI64DeviceTriggerOverlap(Property):
    r"""
    A template class to represent 64 bit integer properties and enumerated 64 bit integer properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for integer values.
    To use a normal int (not enumerated) properties use the **mvIMPACT::acquire::PropertyI64** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyI64** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI64** object.
        :type hProp: int
        :param hProp: [in] A valid handle to a 64-bit integer property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyI64** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyI64** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyI64DeviceTriggerOverlap_swiginit(self, lib_mvIMPACT_acquire.new_PropertyI64DeviceTriggerOverlap(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI64::getTranslationDictString** and
         **mvIMPACT::acquire::EnumPropertyI64::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap >,std::allocator< std::pair< std::string,mvIMPACT::acquire::TDeviceTriggerOverlap > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyI64DeviceTriggerOverlap_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyI64DeviceTriggerOverlap_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyI64::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyI64DeviceTriggerOverlap_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI64::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyI64DeviceTriggerOverlap_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyI64::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >
         :return: A const reference to the calling property.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyI64DeviceTriggerOverlap_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyI64DeviceTriggerOverlap_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyI64DeviceTriggerOverlap_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyI64DeviceTriggerOverlap_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: int
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyI64DeviceTriggerOverlap_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >
         :return: A const 'self' reference.

        :type value: int
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyI64< mvIMPACT::acquire::TDeviceTriggerOverlap >
         :return: A const 'self' reference.

        :type sequence: std::vector< mvIMPACT::acquire::TDeviceTriggerOverlap,std::allocator< mvIMPACT::acquire::TDeviceTriggerOverlap > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyI64DeviceTriggerOverlap_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyI64DeviceTriggerOverlap

# Register PropertyI64DeviceTriggerOverlap in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyI64DeviceTriggerOverlap_swigregister(PropertyI64DeviceTriggerOverlap)

class pairstringTDeviceTriggerOverlap(object):
    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):
        lib_mvIMPACT_acquire.pairstringTDeviceTriggerOverlap_swiginit(self, lib_mvIMPACT_acquire.new_pairstringTDeviceTriggerOverlap(*args))
    first = property(lib_mvIMPACT_acquire.pairstringTDeviceTriggerOverlap_first_get, lib_mvIMPACT_acquire.pairstringTDeviceTriggerOverlap_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringTDeviceTriggerOverlap_second_get, lib_mvIMPACT_acquire.pairstringTDeviceTriggerOverlap_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringTDeviceTriggerOverlap

# Register pairstringTDeviceTriggerOverlap in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringTDeviceTriggerOverlap_swigregister(pairstringTDeviceTriggerOverlap)

class PropertyF(Property):
    r"""
    A template class to represent float properties and enumerated float properties.
    The template parameter specifies the enum to use as the value type for this
    enumerated property. The class itself however is restricted for float values.
    To use a normal float (not enumerated) properties use the **mvIMPACT::acquire::PropertyF** type.
    """

    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"""
        *Overload 1:*
         Constructs a new unbound **mvIMPACT::acquire::EnumPropertyF** object.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyF** object.
        :type hProp: int
        :param hProp: [in] A valid handle to a float property

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::EnumPropertyF** from an existing one.
        :type src: mvIMPACT::acquire::EnumPropertyF< double >
        :param src: [in] A constant reference to the **mvIMPACT::acquire::EnumPropertyF** object, this object shall be created from
        """
        lib_mvIMPACT_acquire.PropertyF_swiginit(self, lib_mvIMPACT_acquire.new_PropertyF(*args))

    def getTranslationDict(self, sequence):
        r"""
         This function queries the property's translation table.
         If this property defines a translation table the strings and their corresponding
         translation values will be written into *sequence*. If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **EnumPropertyF::getTranslationDictString** and
         **EnumPropertyF::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         :rtype: mvIMPACT::acquire::EnumPropertyF< double >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::pair< std::string,double >,std::allocator< std::pair< std::string,double > > >
        :param sequence: [out] A reference to a container which will receive the data from the properties translation dictionary.
        """
        return lib_mvIMPACT_acquire.PropertyF_getTranslationDict(self, sequence)

    def getTranslationDictString(self, index=0):
        r"""
         This function reads a single translation table string entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the string representation of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyF_getTranslationDictString(self, index)

    def getTranslationDictValue(self, index=0):
        r"""
         This function reads a single translation table value entry from a property.
         If this property defines a translation table and *index* specifies a valid entry
         the value of this entry will be returned.
         If the property does **NOT** define a translation table or *index* specifies
         an invalid entry an exception will be thrown.
         See also: **mvIMPACT::acquire::EnumPropertyF::getTranslationDictValues** to query all valid
         values efficiently in a single call.

        :type index: int
        :param index: [in] The index of the entry to read from the property.
        """
        return lib_mvIMPACT_acquire.PropertyF_getTranslationDictValue(self, index)

    def getTranslationDictStrings(self, sequence):
        r"""
         This function queries a list of valid strings for this property.
         If this property defines a translation table all valid strings will be written into *sequence*.
         If the property does **NOT** define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyF::getTranslationDictString** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 2.5.0
         :rtype: mvIMPACT::acquire::EnumPropertyF< double >
         :return: A const reference to the calling property.

        :type sequence: std::vector< std::string,std::allocator< std::string > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyF_getTranslationDictStrings(self, sequence)

    def getTranslationDictValues(self, sequence):
        r"""
         This function queries a list of valid values for this property.
         If this property defines a translation table all valid values will be written into *sequence*.
         If the property does **NOT**
         define a translation table *sequence* will be empty after this function call.

         Notes: 
         This function is much more efficient than calling
         **mvIMPACT::acquire::EnumPropertyF::getTranslationDictValue** multiple times and
         therefore this function should be called whenever all entries are required.
         Since: 1.12.68

         :rtype: mvIMPACT::acquire::EnumPropertyF< double >
         :return: A const reference to the calling property.

        :type sequence: std::vector< double,std::allocator< double > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        """
        return lib_mvIMPACT_acquire.PropertyF_getTranslationDictValues(self, sequence)

    def getMaxValue(self):
        r"""
        Reads the maximum value from a property.
        Notes: 
        To find out if the property defines a maximum value **mvIMPACT::acquire::Property::hasMaxValue**
        should be called first.


        If the property does not define a maximum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyF_getMaxValue(self)

    def getMinValue(self):
        r"""
        Reads the minimum value from a property.
        Notes: 
        To find out if the property defines a minimum value **mvIMPACT::acquire::Property::hasMinValue**
        should be called first.


        If the property does not define a minimum value calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyF_getMinValue(self)

    def getStepWidth(self):
        r"""
        Reads the step width from a property.
        Notes: 
        To find out if the property defines a step width **mvIMPACT::acquire::Property::hasStepWidth**
        should be called first.


        If the property does not define a step width calling this function will raise
        an exception.

        Since: 1.12.63
        """
        return lib_mvIMPACT_acquire.PropertyF_getStepWidth(self)

    def read(self, *args):
        r"""
        *Overload 1:*
         Reads a value from a property.
         This function queries a single value stored under index *index* in the property.
         :rtype: float
         :return: The value stored at *index* within the property.

        :type index: int
        :param index: [in] The index of the value to read from the property.

        |

        *Overload 2:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< double,std::allocator< double > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 3:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< double,std::allocator< double > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 4:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< double,std::allocator< double > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 5:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< double,std::allocator< double > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :type end: int
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 6:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< double,std::allocator< double > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :type start: int
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.

        |

        *Overload 7:*
         Reads a set of values from a property.
         This function queries a set of values from a property and stores these values
         into *sequence*.
         :rtype: void
         :return: Nothing.

        :type sequence: std::vector< double,std::allocator< double > >
        :param sequence: [out] A reference to a container to store the data read from the property into.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to get all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be read one after the other
        :param start: [in] The index from where to start reading values from the property.
        :param end: [in] The index where to stop reading values from the property.
        """
        return lib_mvIMPACT_acquire.PropertyF_read(self, *args)

    def write(self, *args):
        r"""
        *Overload 1:*
         Writes one value to the property.
         This function writes a single value under index *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyF< double >
         :return: A const 'self' reference.

        :type value: float
        :param value: [in] The value to write to the property.
        :type index: int
        :param index: [in] The index defining at which position to write the value.

        |

        *Overload 2:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyF< double >
         :return: A const 'self' reference.

        :type sequence: std::vector< double,std::allocator< double > >
        :param sequence: [in] An array containing the values to write to the property.
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 3:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyF< double >
         :return: A const 'self' reference.

        :type sequence: std::vector< double,std::allocator< double > >
        :param sequence: [in] An array containing the values to write to the property.
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 4:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyF< double >
         :return: A const 'self' reference.

        :type sequence: std::vector< double,std::allocator< double > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :type index: int
        :param index: [in] The index where to write the first value to the property.

        |

        *Overload 5:*
         Writes a set of values to the property.
         This function writes a set of values starting at *index* to the property.

         :rtype: mvIMPACT::acquire::EnumPropertyF< double >
         :return: A const 'self' reference.

        :type sequence: std::vector< double,std::allocator< double > >
        :param sequence: [in] An array containing the values to write to the property.
        :type boAtomic: boolean
        :param boAtomic: [in] Set this parameter to *true* to set all values at once(recommended). If set to false the function will need more time and all values in *sequence* will be set one after the other
        :param index: [in] The index where to write the first value to the property.
        """
        return lib_mvIMPACT_acquire.PropertyF_write(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_PropertyF

# Register PropertyF in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.PropertyF_swigregister(PropertyF)

class pairstringdouble(object):
    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):
        lib_mvIMPACT_acquire.pairstringdouble_swiginit(self, lib_mvIMPACT_acquire.new_pairstringdouble(*args))
    first = property(lib_mvIMPACT_acquire.pairstringdouble_first_get, lib_mvIMPACT_acquire.pairstringdouble_first_set)
    second = property(lib_mvIMPACT_acquire.pairstringdouble_second_get, lib_mvIMPACT_acquire.pairstringdouble_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_pairstringdouble

# Register pairstringdouble in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.pairstringdouble_swigregister(pairstringdouble)

class DeviceControl(object):
    r"""
    Classes and functions that will be available if the device is used with the *GenICam* interface layout.
    This group contains classes and functions that will be available if the device is used
    with the **mvIMPACT::acquire::dilGenICam** interface layout.
     Category for device information and control.
    A category for device information and control.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::GenICam::DeviceControl** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.DeviceControl_swiginit(self, lib_mvIMPACT_acquire.new_DeviceControl(*args))
    deviceType = property(lib_mvIMPACT_acquire.DeviceControl_deviceType_get, doc=r"""
    An enumerated integer property. Returns the device type.
    Returns the device type.

    The following string values might be valid for this feature:
    - **Transmitter** (Display string: 'Transmitter'): Data stream transmitter device.
    - **Receiver** (Display string: 'Receiver'): Data stream receiver device.
    - **Transceiver** (Display string: 'Transceiver'): Data stream receiver and transmitter device.
    - **Peripheral** (Display string: 'Peripheral'): Controllable device (with no data stream handling).
    - **Mixed** (Display string: 'Mixed'): This enumeration value indicates that this is a device for a mixed protocol.
    - **Custom** (Display string: 'Custom'): This enumeration value indicates that this is a device for a custom protocol.
    - **GEV** (Display string: 'GigE Vision'): This enumeration value indicates that this is a device for the GigE Vision protocol.
    - **CameraLink** (Display string: 'CameraLink'): This enumeration value indicates that this is a device for the CameraLink protocol.
    - **CoaXPress** (Display string: 'CoaXPress'): This enumeration value indicates that this is a device for the CoaXPress protocol.
    - **CameraLinkHS** (Display string: 'CameraLink HS'): This enumeration value indicates that this is a device for the CameraLink HS protocol.
    - **U3V** (Display string: 'USB3 Vision'): This enumeration value indicates that this is a device for the USB3 Vision protocol.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    deviceScanType = property(lib_mvIMPACT_acquire.DeviceControl_deviceScanType_get, doc=r"""
    An enumerated integer property. Scan type of the sensor of the device.
    Scan type of the sensor of the device.

    The following string values might be valid for this feature:
    - **Areascan** (Display string: 'Areascan'): 2D sensor.
    - **Linescan** (Display string: 'Linescan'): 1D sensor.
    - **Areascan3D** (Display string: 'Areascan 3D'): device outputs 2D range image.
    - **Linescan3D** (Display string: 'Linescan 3D'): device outputs 1D range image.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    deviceVendorName = property(lib_mvIMPACT_acquire.DeviceControl_deviceVendorName_get, doc=r"""
    A string property. Name of the manufacturer of the device.
    Name of the manufacturer of the device.
    """)
    deviceModelName = property(lib_mvIMPACT_acquire.DeviceControl_deviceModelName_get, doc=r"""
    A string property. Model of the device.
    Model of the device.
    """)
    deviceFamilyName = property(lib_mvIMPACT_acquire.DeviceControl_deviceFamilyName_get, doc=r"""
    A string property. Identifier of the product family of the device.
    Identifier of the product family of the device.
    """)
    deviceManufacturerInfo = property(lib_mvIMPACT_acquire.DeviceControl_deviceManufacturerInfo_get, doc=r"""
    A string property. Manufacturer information about the device.
    Manufacturer information about the device.
    """)
    deviceVersion = property(lib_mvIMPACT_acquire.DeviceControl_deviceVersion_get, doc=r"""
    A string property. Version of the device.
    Version of the device.
    """)
    deviceFirmwareVersion = property(lib_mvIMPACT_acquire.DeviceControl_deviceFirmwareVersion_get, doc=r"""
    A string property. Version of the firmware in the device.
    Version of the firmware in the device.
    """)
    mvDeviceFirmwareBuildDate = property(lib_mvIMPACT_acquire.DeviceControl_mvDeviceFirmwareBuildDate_get, doc=r"""
    A string property. The build time and date of the firmware
    The build time and date of the firmware
    """)
    deviceSerialNumber = property(lib_mvIMPACT_acquire.DeviceControl_deviceSerialNumber_get, doc=r"""
    A string property. Device's serial number.
    Device's serial number. This string is a unique identifier of the device.
    """)
    deviceID = property(lib_mvIMPACT_acquire.DeviceControl_deviceID_get, doc=r"""
    A string property. This feature is deprecated (See DeviceSerialNumber).
    Deprecated: 
    This feature is deprecated (See DeviceSerialNumber). It was representing the Device unique identifier (serial number).
    """)
    deviceUserID = property(lib_mvIMPACT_acquire.DeviceControl_deviceUserID_get, doc=r"""
    A string property. User-programmable device identifier.
    User-programmable device identifier.
    """)
    deviceSFNCVersionMajor = property(lib_mvIMPACT_acquire.DeviceControl_deviceSFNCVersionMajor_get, doc=r"""
    An integer property. Major version of the Standard Features Naming Convention that was used to create the device's GenICam XML.
    Major version of the Standard Features Naming Convention that was used to create the device's GenICam XML.
    """)
    deviceSFNCVersionMinor = property(lib_mvIMPACT_acquire.DeviceControl_deviceSFNCVersionMinor_get, doc=r"""
    An integer property. Minor version of the Standard Features Naming Convention that was used to create the device's GenICam XML.
    Minor version of the Standard Features Naming Convention that was used to create the device's GenICam XML.
    """)
    deviceSFNCVersionSubMinor = property(lib_mvIMPACT_acquire.DeviceControl_deviceSFNCVersionSubMinor_get, doc=r"""
    An integer property. Sub minor version of Standard Features Naming Convention that was used to create the device's GenICam XML.
    Sub minor version of Standard Features Naming Convention that was used to create the device's GenICam XML.
    """)
    deviceManifestEntrySelector = property(lib_mvIMPACT_acquire.DeviceControl_deviceManifestEntrySelector_get, doc=r"""
    An integer property. Selects the manifest entry to reference.
    Selects the manifest entry to reference.
    """)
    deviceManifestXMLMajorVersion = property(lib_mvIMPACT_acquire.DeviceControl_deviceManifestXMLMajorVersion_get, doc=r"""
    An integer property. Indicates the major version number of the GenICam XML file of the selected manifest entry.
    Indicates the major version number of the GenICam XML file of the selected manifest entry.
    """)
    deviceManifestXMLMinorVersion = property(lib_mvIMPACT_acquire.DeviceControl_deviceManifestXMLMinorVersion_get, doc=r"""
    An integer property. Indicates the minor version number of the GenICam XML file of the selected manifest entry.
    Indicates the minor version number of the GenICam XML file of the selected manifest entry.
    """)
    deviceManifestXMLSubMinorVersion = property(lib_mvIMPACT_acquire.DeviceControl_deviceManifestXMLSubMinorVersion_get, doc=r"""
    An integer property. Indicates the subminor version number of the GenICam XML file of the selected manifest entry.
    Indicates the subminor version number of the GenICam XML file of the selected manifest entry.
    """)
    deviceManifestSchemaMajorVersion = property(lib_mvIMPACT_acquire.DeviceControl_deviceManifestSchemaMajorVersion_get, doc=r"""
    An integer property. Indicates the major version number of the schema file of the selected manifest entry.
    Indicates the major version number of the schema file of the selected manifest entry.
    """)
    deviceManifestSchemaMinorVersion = property(lib_mvIMPACT_acquire.DeviceControl_deviceManifestSchemaMinorVersion_get, doc=r"""
    An integer property. Indicates the minor version number of the schema file of the selected manifest entry.
    Indicates the minor version number of the schema file of the selected manifest entry.
    """)
    deviceManifestPrimaryURL = property(lib_mvIMPACT_acquire.DeviceControl_deviceManifestPrimaryURL_get, doc=r"""
    A string property. Indicates the first URL to the GenICam XML device description file of the selected manifest entry.
    Indicates the first URL to the GenICam XML device description file of the selected manifest entry.
    """)
    deviceManifestSecondaryURL = property(lib_mvIMPACT_acquire.DeviceControl_deviceManifestSecondaryURL_get, doc=r"""
    A string property. Indicates the second URL to the GenICam XML device description file of the selected manifest entry.
    Indicates the second URL to the GenICam XML device description file of the selected manifest entry.
    """)
    deviceTLType = property(lib_mvIMPACT_acquire.DeviceControl_deviceTLType_get, doc=r"""
    An enumerated integer property. Transport Layer type of the device.
    Transport Layer type of the device.

    The following string values might be valid for this feature:
    - **GigEVision** (Display string: 'GigE Vision'): GigE Vision.
    - **CameraLink** (Display string: 'Camera Link'): Camera Link.
    - **CameraLinkHS** (Display string: 'Camera Link HS'): Camera Link High Speed.
    - **CoaXPress** (Display string: 'CoaXPress'): CoaXPress.
    - **USB3Vision** (Display string: 'USB3 Vision'): USB3 Vision.
    - **Custom** (Display string: 'Custom'): Custom Transport Layer.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    deviceTLVersionMajor = property(lib_mvIMPACT_acquire.DeviceControl_deviceTLVersionMajor_get, doc=r"""
    An integer property. Major version of the Transport Layer of the device.
    Major version of the Transport Layer of the device.
    """)
    deviceTLVersionMinor = property(lib_mvIMPACT_acquire.DeviceControl_deviceTLVersionMinor_get, doc=r"""
    An integer property. Minor version of the Transport Layer of the device.
    Minor version of the Transport Layer of the device.
    """)
    deviceTLVersionSubMinor = property(lib_mvIMPACT_acquire.DeviceControl_deviceTLVersionSubMinor_get, doc=r"""
    An integer property. Sub minor version of the Transport Layer of the device.
    Sub minor version of the Transport Layer of the device.
    """)
    deviceGenCPVersionMajor = property(lib_mvIMPACT_acquire.DeviceControl_deviceGenCPVersionMajor_get, doc=r"""
    An integer property. Major version of the GenCP protocol supported by the device.
    Major version of the GenCP protocol supported by the device.
    """)
    deviceGenCPVersionMinor = property(lib_mvIMPACT_acquire.DeviceControl_deviceGenCPVersionMinor_get, doc=r"""
    An integer property. Minor version of the GenCP protocol supported by the device.
    Minor version of the GenCP protocol supported by the device.
    """)
    deviceMaxThroughput = property(lib_mvIMPACT_acquire.DeviceControl_deviceMaxThroughput_get, doc=r"""
    An integer property. Maximum bandwidth of the data that can be streamed out of the device.
    Maximum bandwidth of the data that can be streamed out of the device. This can be used to estimate if the physical connection(s) can sustain transfer of free-running images from the camera at its maximum speed.
    """)
    deviceConnectionSelector = property(lib_mvIMPACT_acquire.DeviceControl_deviceConnectionSelector_get, doc=r"""
    An integer property. Selects which Connection of the device to control.
    Selects which Connection of the device to control.
    """)
    deviceConnectionSpeed = property(lib_mvIMPACT_acquire.DeviceControl_deviceConnectionSpeed_get, doc=r"""
    An integer property. Indicates the speed of transmission of the specified Connection.
    Indicates the speed of transmission of the specified Connection
    """)
    deviceConnectionStatus = property(lib_mvIMPACT_acquire.DeviceControl_deviceConnectionStatus_get, doc=r"""
    An enumerated integer property. Indicates the status of the specified Connection.
    Indicates the status of the specified Connection.

    The following string values might be valid for this feature:
    - **Active** (Display string: 'Active'): Connection is in use.
    - **Inactive** (Display string: 'Inactive'): Connection is not in use.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    deviceLinkSelector = property(lib_mvIMPACT_acquire.DeviceControl_deviceLinkSelector_get, doc=r"""
    An integer property. Selects which Link of the device to control.
    Selects which Link of the device to control.
    """)
    deviceLinkSpeed = property(lib_mvIMPACT_acquire.DeviceControl_deviceLinkSpeed_get, doc=r"""
    An integer property. Indicates the speed of transmission negotiated on the specified Link.
    Indicates the speed of transmission negotiated on the specified Link.
    """)
    deviceLinkThroughputLimitMode = property(lib_mvIMPACT_acquire.DeviceControl_deviceLinkThroughputLimitMode_get, doc=r"""
    An enumerated integer property. Controls if the DeviceLinkThroughputLimit is active.
    Controls if the DeviceLinkThroughputLimit is active. When disabled, lower level TL specific features are expected to control the throughput. When enabled, DeviceLinkThroughputLimit controls the overall throughput.

    The following string values might be valid for this feature:
    - **On** (Display string: 'On'): Enables the DeviceLinkThroughputLimit feature.
    - **Off** (Display string: 'Off'): Disables the DeviceLinkThroughputLimit feature.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    deviceLinkThroughputLimit = property(lib_mvIMPACT_acquire.DeviceControl_deviceLinkThroughputLimit_get, doc=r"""
    An integer property. Limits the maximum bandwidth of the data that will be streamed out by the device on the selected Link.
    Limits the maximum bandwidth of the data that will be streamed out by the device on the selected Link. If necessary, delays will be uniformly inserted between transport layer packets in order to control the peak bandwidth.
    """)
    deviceLinkConnectionCount = property(lib_mvIMPACT_acquire.DeviceControl_deviceLinkConnectionCount_get, doc=r"""
    An integer property. Returns the number of physical connection of the device used by a particular Link.
    Returns the number of physical connection of the device used by a particular Link.
    """)
    deviceLinkHeartbeatMode = property(lib_mvIMPACT_acquire.DeviceControl_deviceLinkHeartbeatMode_get, doc=r"""
    An enumerated integer property. Activate or deactivate the Link's heartbeat.
    Activate or deactivate the Link's heartbeat.

    The following string values might be valid for this feature:
    - **On** (Display string: 'On'): Enables the Link heartbeat.
    - **Off** (Display string: 'Off'): Disables the Link heartbeat.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    deviceLinkHeartbeatTimeout = property(lib_mvIMPACT_acquire.DeviceControl_deviceLinkHeartbeatTimeout_get, doc=r"""
    A floating point property. Controls the current heartbeat timeout of the specific Link.
    Controls the current heartbeat timeout of the specific Link.
    """)
    deviceLinkCommandTimeout = property(lib_mvIMPACT_acquire.DeviceControl_deviceLinkCommandTimeout_get, doc=r"""
    A floating point property. Indicates the command timeout of the specified Link.
    Indicates the command timeout of the specified Link. This corresponds to the maximum response time of the device for a command sent on that link.
    """)
    deviceStreamChannelCount = property(lib_mvIMPACT_acquire.DeviceControl_deviceStreamChannelCount_get, doc=r"""
    An integer property. Indicates the number of streaming channels supported by the device.
    Indicates the number of streaming channels supported by the device.
    """)
    deviceStreamChannelSelector = property(lib_mvIMPACT_acquire.DeviceControl_deviceStreamChannelSelector_get, doc=r"""
    An integer property. Selects the stream channel to control.
    Selects the stream channel to control.
    """)
    deviceStreamChannelType = property(lib_mvIMPACT_acquire.DeviceControl_deviceStreamChannelType_get, doc=r"""
    An enumerated integer property. Reports the type of the stream channel.
    Reports the type of the stream channel.

    The following string values might be valid for this feature:
    - **Transmitter** (Display string: 'Transmitter'): Data stream transmitter channel.
    - **Receiver** (Display string: 'Receiver'): Data stream receiver channel.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    deviceStreamChannelLink = property(lib_mvIMPACT_acquire.DeviceControl_deviceStreamChannelLink_get, doc=r"""
    An integer property. Index of device's Link to use for streaming the specified stream channel.
    Index of device's Link to use for streaming the specified stream channel.
    """)
    deviceStreamChannelEndianness = property(lib_mvIMPACT_acquire.DeviceControl_deviceStreamChannelEndianness_get, doc=r"""
    An enumerated integer property. Endianness of multi-byte pixel data for this stream.
    Endianness of multi-byte pixel data for this stream.

    The following string values might be valid for this feature:
    - **Big** (Display string: 'Big'): Stream channel data is big Endian.
    - **Little** (Display string: 'Little'): Stream channel data is little Endian.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    deviceStreamChannelPacketSize = property(lib_mvIMPACT_acquire.DeviceControl_deviceStreamChannelPacketSize_get, doc=r"""
    An integer property. Specifies the stream packet size, in bytes, to send on the selected channel for a Transmitter or specifies the maximum packet size supported by a receiver.
    Specifies the stream packet size, in bytes, to send on the selected channel for a Transmitter or specifies the maximum packet size supported by a receiver.
    """)
    deviceEventChannelCount = property(lib_mvIMPACT_acquire.DeviceControl_deviceEventChannelCount_get, doc=r"""
    An integer property. Indicates the number of event channels supported by the device.
    Indicates the number of event channels supported by the device.
    """)
    deviceMessageChannelCount = property(lib_mvIMPACT_acquire.DeviceControl_deviceMessageChannelCount_get, doc=r"""
    An integer property. This feature is deprecated (See DeviceEventChannelCount).
    Deprecated: 
    This feature is deprecated (See DeviceEventChannelCount). It indicates the number of message/event channels supported by the device.
    """)
    deviceCharacterSet = property(lib_mvIMPACT_acquire.DeviceControl_deviceCharacterSet_get, doc=r"""
    An enumerated integer property. Character set used by the strings of the device.
    Character set used by the strings of the device.

    The following string values might be valid for this feature:
    - **UTF8** (Display string: 'UTF 8'): Device use UTF8 character set.
    - **ASCII** (Display string: 'ASCII'): Device use ASCII character set.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    deviceReset = property(lib_mvIMPACT_acquire.DeviceControl_deviceReset_get, doc=r"""
    A method object. Resets the device to its power up state.
    Resets the device to its power up state. After reset, the device must be rediscovered.
    """)
    deviceIndicatorMode = property(lib_mvIMPACT_acquire.DeviceControl_deviceIndicatorMode_get, doc=r"""
    An enumerated integer property. Controls the behavior of the indicators (such as LEDs) showing the status of the Device.
    Controls the behavior of the indicators (such as LEDs) showing the status of the Device.

    The following string values might be valid for this feature:
    - **Inactive** (Display string: 'Inactive'): Device's indicators are inactive (Off).
    - **Active** (Display string: 'Active'): Device's indicators are active showing their respective status.
    - **ErrorStatus** (Display string: 'Error Status'): Device's indicators are inactive unless an error occurs.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    deviceFeaturePersistenceStart = property(lib_mvIMPACT_acquire.DeviceControl_deviceFeaturePersistenceStart_get, doc=r"""
    A method object. Indicate to the device and GenICam XML to get ready for persisting of all streamable features.
    Indicate to the device and GenICam XML to get ready for persisting of all streamable features.
    """)
    deviceFeaturePersistenceEnd = property(lib_mvIMPACT_acquire.DeviceControl_deviceFeaturePersistenceEnd_get, doc=r"""
    A method object. Indicate to the device the end of feature persistence.
    Indicate to the device the end of feature persistence.
    """)
    deviceRegistersStreamingStart = property(lib_mvIMPACT_acquire.DeviceControl_deviceRegistersStreamingStart_get, doc=r"""
    A method object. Prepare the device for registers streaming without checking for consistency.
    Prepare the device for registers streaming without checking for consistency.
    """)
    deviceRegistersStreamingEnd = property(lib_mvIMPACT_acquire.DeviceControl_deviceRegistersStreamingEnd_get, doc=r"""
    A method object. Announce the end of registers streaming.
    Announce the end of registers streaming. This will do a register set validation for consistency and activate it. This will also update the DeviceRegistersValid flag.
    """)
    deviceRegistersCheck = property(lib_mvIMPACT_acquire.DeviceControl_deviceRegistersCheck_get, doc=r"""
    A method object. Perform the validation of the current register set for consistency.
    Perform the validation of the current register set for consistency. This will update the DeviceRegistersValid flag.
    """)
    deviceRegistersValid = property(lib_mvIMPACT_acquire.DeviceControl_deviceRegistersValid_get, doc=r"""
    A boolean property. Returns if the current register set is valid and consistent.
    Returns if the current register set is valid and consistent.
    """)
    mvDeviceRegistersStatus = property(lib_mvIMPACT_acquire.DeviceControl_mvDeviceRegistersStatus_get, doc=r"""
    An enumerated integer property. Will give a hint where to find the invalid register settings if any.
    Will give a hint where to find the invalid register settings if any.

    The following string values might be valid for this feature:
    - **Valid** (Display string: 'Valid'): The current register settings are in a consistent state.
    - **Invalid** (Display string: 'Invalid'): The current register settings are in an invalid and/or inconsistent state.
    - **BinningHorizontalValueInvalid** (Display string: 'Binning Horizontal Value Invalid'): The current BinningHorizontal value is not supported.
    - **BinningVerticalValueInvalid** (Display string: 'Binning Vertical Value Invalid'): The current BinningVertical value is not supported.
    - **DecimationHorizontalValueInvalid** (Display string: 'Decimation Horizontal Value Invalid'): The current DecimationHorizontal value is not supported.
    - **DecimationVerticalValueInvalid** (Display string: 'Decimation Vertical Value Invalid'): The current DecimationVertical value is not supported.
    - **BinningDecimationCombinationInvalid** (Display string: 'Binning Decimation Combination Invalid'): The current combination of binning and decimation is not valid.
    - **BinningDecimationImageTooWide** (Display string: 'Binning Decimation Image Too Wide'): The current Width is too wide for the BinningVertical and/or DecimationVertical settings. Please reduce the Width or add BinningHorizontal orDecimationHorizontal.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    deviceRegistersEndianness = property(lib_mvIMPACT_acquire.DeviceControl_deviceRegistersEndianness_get, doc=r"""
    An enumerated integer property. Endianness of the registers of the device.
    Endianness of the registers of the device.

    The following string values might be valid for this feature:
    - **Big** (Display string: 'Big'): Device's registers are big Endian.
    - **Little** (Display string: 'Little'): Device's registers are little Endian.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    deviceTemperatureSelector = property(lib_mvIMPACT_acquire.DeviceControl_deviceTemperatureSelector_get, doc=r"""
    An enumerated integer property. Selects the location within the device, where the temperature will be measured.
    Selects the location within the device, where the temperature will be measured.

    The following string values might be valid for this feature:
    - **Sensor** (Display string: 'Sensor'): Temperature of the image sensor of the camera.
    - **Mainboard** (Display string: 'Mainboard'): Temperature of the device's mainboard.
    - **XLamp** (Display string: 'X Lamp')
    - **SensorCMVx000** (Display string: 'Sensor CM Vx 000')
    - **SensorInternal** (Display string: 'Sensor Internal')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    deviceTemperature = property(lib_mvIMPACT_acquire.DeviceControl_deviceTemperature_get, doc=r"""
    A floating point property. Device temperature in degrees Celsius (C).
    Device temperature in degrees Celsius (C). It is measured at the location selected by DeviceTemperatureSelector.
    """)
    deviceClockSelector = property(lib_mvIMPACT_acquire.DeviceControl_deviceClockSelector_get, doc=r"""
    An enumerated integer property. Selects the clock frequency to access from the device.
    Selects the clock frequency to access from the device.

    The following string values might be valid for this feature:
    - **Sensor** (Display string: 'Sensor'): Clock frequency of the image sensor of the camera.
    - **SensorDigitization** (Display string: 'Sensor Digitization'): Clock frequency of the camera A/D conversion stage.
    - **CameraLink** (Display string: 'Camera Link'): Frequency of the Camera Link clock.
    - **DeviceSpecific** (Display string: 'Device Specific')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    deviceClockFrequency = property(lib_mvIMPACT_acquire.DeviceControl_deviceClockFrequency_get, doc=r"""
    A floating point property. Returns the frequency of the selected Clock.
    Returns the frequency of the selected Clock.
    """)
    deviceSerialPortSelector = property(lib_mvIMPACT_acquire.DeviceControl_deviceSerialPortSelector_get, doc=r"""
    An enumerated integer property. Selects which serial port of the device to control.
    Selects which serial port of the device to control.

    The following string values might be valid for this feature:
    - **CameraLink** (Display string: 'Camera Link'): Serial port associated to the Camera link connection.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    deviceSerialPortBaudRate = property(lib_mvIMPACT_acquire.DeviceControl_deviceSerialPortBaudRate_get, doc=r"""
    An enumerated integer property. This feature controls the baud rate used by the selected serial port.
    This feature controls the baud rate used by the selected serial port.

    The following string values might be valid for this feature:
    - **Baud9600** (Display string: 'Baud 9600'): Serial port speed of 9600 baud.
    - **Baud19200** (Display string: 'Baud 19200'): Serial port speed of 19200 baud.
    - **Baud38400** (Display string: 'Baud 38400'): Serial port speed of 38400 baud.
    - **Baud57600** (Display string: 'Baud 57600'): Serial port speed of 57600 baud.
    - **Baud115200** (Display string: 'Baud 115200'): Serial port speed of 115200 baud.
    - **Baud230400** (Display string: 'Baud 230400'): Serial port speed of 230400 baud.
    - **Baud460800** (Display string: 'Baud 460800'): Serial port speed of 460800 baud.
    - **Baud921600** (Display string: 'Baud 921600'): Serial port speed of 921600 baud.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    timestamp = property(lib_mvIMPACT_acquire.DeviceControl_timestamp_get, doc=r"""
    An integer property. Reports the current value of the device timestamp counter.
    Reports the current value of the device timestamp counter.
    """)
    timestampReset = property(lib_mvIMPACT_acquire.DeviceControl_timestampReset_get, doc=r"""
    A method object. Resets the current value of the device timestamp counter.
    Resets the current value of the device timestamp counter.
    """)
    timestampLatch = property(lib_mvIMPACT_acquire.DeviceControl_timestampLatch_get, doc=r"""
    A method object. Latches the current timestamp counter into TimestampLatchValue.
    Latches the current timestamp counter into TimestampLatchValue.
    """)
    timestampLatchValue = property(lib_mvIMPACT_acquire.DeviceControl_timestampLatchValue_get, doc=r"""
    An integer property. Returns the latched value of the timestamp counter.
    Returns the latched value of the timestamp counter.
    """)
    mvDeviceTemperatureRaw = property(lib_mvIMPACT_acquire.DeviceControl_mvDeviceTemperatureRaw_get, doc=r"""
    An integer property. Device temperature in degrees Celsius (C).
    Device temperature in degrees Celsius (C). It is measured at the location selected by DeviceTemperatureSelector.
    """)
    mvDeviceTemperatureUpperLimit = property(lib_mvIMPACT_acquire.DeviceControl_mvDeviceTemperatureUpperLimit_get, doc=r"""
    An integer property. Upper limit in degrees Celsius(C) for the TemperatureOutOfRange signal.
    Upper limit in degrees Celsius(C) for the TemperatureOutOfRange signal.
    """)
    mvDeviceTemperatureLowerLimit = property(lib_mvIMPACT_acquire.DeviceControl_mvDeviceTemperatureLowerLimit_get, doc=r"""
    An integer property. Lower limit in degrees Celsius(C) for the TemperatureOutOfRange signal.
    Lower limit in degrees Celsius(C) for the TemperatureOutOfRange signal.
    """)
    mvDeviceTemperatureLimitHysteresis = property(lib_mvIMPACT_acquire.DeviceControl_mvDeviceTemperatureLimitHysteresis_get, doc=r"""
    An enumerated integer property. Hysteresis in degrees Celsius(C) for temperature limits.
    Hysteresis in degrees Celsius(C) for temperature limits.

    The following string values might be valid for this feature:
    - **deg_0p0** (Display string: 'deg 0p 0')
    - **deg_1p5** (Display string: 'deg 1p 5')
    - **deg_3p0** (Display string: 'deg 3p 0')
    - **deg_6p0** (Display string: 'deg 6p 0')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvDeviceClockFrequency = property(lib_mvIMPACT_acquire.DeviceControl_mvDeviceClockFrequency_get, doc=r"""
    An enumerated integer property. Clock frequency of the image sensor of the camera.
    Clock frequency of the image sensor of the camera.

    The following string values might be valid for this feature:
    - **kHz_08000** (Display string: '8000 kHz')
    - **kHz_10000** (Display string: '10000 kHz')
    - **kHz_11000** (Display string: '11000 kHz')
    - **kHz_12000** (Display string: '12000 kHz')
    - **kHz_20000** (Display string: '20000 kHz')
    - **kHz_22000** (Display string: '22000 kHz')
    - **kHz_23000** (Display string: '23000 kHz')
    - **kHz_24000** (Display string: '24000 kHz')
    - **kHz_24540** (Display string: '24540 kHz')
    - **kHz_25000** (Display string: '25000 kHz')
    - **kHz_26000** (Display string: '26000 kHz')
    - **kHz_27000** (Display string: '27000 kHz')
    - **kHz_28000** (Display string: '28000 kHz')
    - **kHz_29000** (Display string: '29000 kHz')
    - **kHz_29500** (Display string: '29500 kHz')
    - **kHz_30000** (Display string: '30000 kHz')
    - **kHz_32000** (Display string: '32000 kHz')
    - **kHz_36000** (Display string: '36000 kHz')
    - **kHz_37120** (Display string: '37120 kHz')
    - **kHz_40000** (Display string: '40000 kHz')
    - **kHz_45000** (Display string: '45000 kHz')
    - **kHz_48000** (Display string: '48000 kHz')
    - **kHz_50000** (Display string: '50000 kHz')
    - **kHz_56000** (Display string: '56000 kHz')
    - **kHz_60000** (Display string: '60000 kHz')
    - **kHz_65000** (Display string: '65000 kHz')
    - **kHz_66000** (Display string: '66000 kHz')
    - **kHz_74250** (Display string: '74250 kHz')
    - **kHz_80000** (Display string: '80000 kHz')
    - **kHz_85000** (Display string: '85000 kHz')
    - **kHz_96000** (Display string: '96000 kHz')
    - **kHz_98000** (Display string: '98000 kHz')
    - **kHz_120000** (Display string: '120000 kHz')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvDeviceSensorColorMode = property(lib_mvIMPACT_acquire.DeviceControl_mvDeviceSensorColorMode_get, doc=r"""
    An enumerated integer property. Shows color mode of the sensor.
    Shows color mode of the sensor.

    The following string values might be valid for this feature:
    - **Unknown** (Display string: 'Unknown')
    - **Grey** (Display string: 'Grey')
    - **BayerMosaic** (Display string: 'Bayer Mosaic')
    - **NearInfraRed** (Display string: 'Near Infra Red')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvDeviceFPGAVersion = property(lib_mvIMPACT_acquire.DeviceControl_mvDeviceFPGAVersion_get, doc=r"""
    A string property. Shows version number of the FPGA.
    Shows version number of the FPGA.
    """)
    mvDeviceFirmwareSource = property(lib_mvIMPACT_acquire.DeviceControl_mvDeviceFirmwareSource_get, doc=r"""
    An enumerated integer property. Shows the location from where the firmware was loaded.
    Shows the location from where the firmware was loaded.

    The following string values might be valid for this feature:
    - **BootSection** (Display string: 'Boot Section')
    - **ProgramSection** (Display string: 'Program Section')
    - **Upload** (Display string: 'Upload')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvDeviceProcessingUnitSelector = property(lib_mvIMPACT_acquire.DeviceControl_mvDeviceProcessingUnitSelector_get, doc=r"""
    An integer property. Selects the device processing unit.
    Selects the device processing unit.
    """)
    mvDeviceProcessingUnit = property(lib_mvIMPACT_acquire.DeviceControl_mvDeviceProcessingUnit_get, doc=r"""
    An enumerated integer property. The processing unit to activate for the selected processing unit.
    The processing unit to activate for the selected processing unit.

    The following string values might be valid for this feature:
    - **mvFFC** (Display string: 'mv FFC'): Selects the Flat-field correction engine for this processing unit.
    - **mvFrameAverage** (Display string: 'mv Frame Average'): Selects the frame average engine for this processing unit.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvDeviceStatusLEDEnable = property(lib_mvIMPACT_acquire.DeviceControl_mvDeviceStatusLEDEnable_get, doc=r"""
    A boolean property. This feature is deprecated (See DeviceIndicatorMode). If enabled, the color of the LED changes depending on the state of the camera. Otherwise the LED is Off.
    Deprecated: 
    This feature is deprecated (See DeviceIndicatorMode). If enabled, the color of the LED changes depending on the state of the camera. Otherwise the LED is Off.
    """)
    mvDevicePowerMode = property(lib_mvIMPACT_acquire.DeviceControl_mvDevicePowerMode_get, doc=r"""
    An enumerated integer property. Selects the device power mode.
    Selects the device power mode.

    The following string values might be valid for this feature:
    - **mvActive** (Display string: 'mv Active'): Puts the device to power-active mode. Going back to 'mvActive' will take about 10 seconds.
    - **mvStandby** (Display string: 'mv Standby'): Puts the device in power-saving mode. In this mode the device will only consume up to 20 percent of its normal power consumption. Going back to 'mvActive' will take about 10 seconds.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvDeviceStandbyTimeoutEnable = property(lib_mvIMPACT_acquire.DeviceControl_mvDeviceStandbyTimeoutEnable_get, doc=r"""
    A boolean property. If enabled, the device switch to standby after a configurable time if no register is read.
    If enabled, the device switch to standby after a configurable time if no register is read.
    """)
    mvDeviceStandbyTimeout = property(lib_mvIMPACT_acquire.DeviceControl_mvDeviceStandbyTimeout_get, doc=r"""
    An integer property. Defines the time in seconds after which the device automatically switches to standby if no register is read.
    Defines the time in seconds after which the device automatically switches to standby if no register is read.
    """)
    mvDeviceFirmwareHashCode = property(lib_mvIMPACT_acquire.DeviceControl_mvDeviceFirmwareHashCode_get, doc=r"""
    A string property. Shows the hash code of the firmware.
    Shows the hash code of the firmware.
    """)
    mvCalculateHashCode = property(lib_mvIMPACT_acquire.DeviceControl_mvCalculateHashCode_get, doc=r"""
    A method object. Do a new calculation of the hash code. This might serve as a means to check whether the firmware has been changed in flash.
    Do a new calculation of the hash code. This might serve as a means to check whether the firmware has been changed in flash. Caution: This needs approximately 15-20 seconds!
    """)
    mvDeviceFirmwareHashAlgorithm = property(lib_mvIMPACT_acquire.DeviceControl_mvDeviceFirmwareHashAlgorithm_get, doc=r"""
    An enumerated integer property. The algorithm used for the hash calculation.
    The algorithm used for the hash calculation.

    The following string values might be valid for this feature:
    - **mvCRC32b** (Display string: 'mv CRC 32b'): CRC32b will be used.
    - **mvSHA1** (Display string: 'mv SHA 1'): SHA1 will be used.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvDeviceLaserCurrent = property(lib_mvIMPACT_acquire.DeviceControl_mvDeviceLaserCurrent_get, doc=r"""
    An integer property. Laser current consumption value (mA).
    Laser current consumption value (mA).
    """)
    mvTimestampPPSSync = property(lib_mvIMPACT_acquire.DeviceControl_mvTimestampPPSSync_get, doc=r"""
    An enumerated integer property. Will synchronize the internal clock to an external GPS(PPS) signal.
    Will synchronize the internal clock to an external GPS(PPS) signal.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off')
    - **Line4** (Display string: 'Line 4')
    - **Line5** (Display string: 'Line 5')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvTimestampResetValue = property(lib_mvIMPACT_acquire.DeviceControl_mvTimestampResetValue_get, doc=r"""
    An integer property. Defines the initial value after the cameras timestamp timer has been reset.
    Defines the initial value after the cameras timestamp timer has been reset.
    """)
    mvTemperatureState = property(lib_mvIMPACT_acquire.DeviceControl_mvTemperatureState_get, doc=r"""
    An enumerated integer property. Indicates the current temperature state of the camera
    Indicates the current temperature state of the camera

    The following string values might be valid for this feature:
    - **Normal** (Display string: 'Normal')
    - **Critical** (Display string: 'Critical')
    - **OverTemperature** (Display string: 'Over Temperature')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvTemperatureStateCriticalThreshold = property(lib_mvIMPACT_acquire.DeviceControl_mvTemperatureStateCriticalThreshold_get, doc=r"""
    An integer property. If the temperature of the camera exceeds this value mvTemperatureState switches from normal to critical
    If the temperature of the camera exceeds this value mvTemperatureState switches from normal to critical
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_DeviceControl

# Register DeviceControl in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.DeviceControl_swigregister(DeviceControl)

class ImageFormatControl(object):
    r"""
    Category for Image Format Control features.
    A category for Image Format Control features.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::GenICam::ImageFormatControl** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.ImageFormatControl_swiginit(self, lib_mvIMPACT_acquire.new_ImageFormatControl(*args))
    sensorWidth = property(lib_mvIMPACT_acquire.ImageFormatControl_sensorWidth_get, doc=r"""
    An integer property. Effective width of the sensor in pixels.
    Effective width of the sensor in pixels.
    """)
    sensorHeight = property(lib_mvIMPACT_acquire.ImageFormatControl_sensorHeight_get, doc=r"""
    An integer property. Effective height of the sensor in pixels.
    Effective height of the sensor in pixels.
    """)
    sensorPixelWidth = property(lib_mvIMPACT_acquire.ImageFormatControl_sensorPixelWidth_get, doc=r"""
    A floating point property. Physical size (pitch) in the x direction of a photo sensitive pixel unit.
    Physical size (pitch) in the x direction of a photo sensitive pixel unit.
    """)
    sensorPixelHeight = property(lib_mvIMPACT_acquire.ImageFormatControl_sensorPixelHeight_get, doc=r"""
    A floating point property. Physical size (pitch) in the y direction of a photo sensitive pixel unit.
    Physical size (pitch) in the y direction of a photo sensitive pixel unit.
    """)
    sensorName = property(lib_mvIMPACT_acquire.ImageFormatControl_sensorName_get, doc=r"""
    A string property. Product name of the imaging Sensor.
    Product name of the imaging Sensor.
    """)
    sensorShutterMode = property(lib_mvIMPACT_acquire.ImageFormatControl_sensorShutterMode_get, doc=r"""
    An enumerated integer property. Specifies the shutter mode of the device.
    Specifies the shutter mode of the device.

    The following string values might be valid for this feature:
    - **Global** (Display string: 'Global'): The shutter opens and closes at the same time for all pixels. All the pixels are exposed for the same length of time at the same time.
    - **Rolling** (Display string: 'Rolling'): The shutter opens and closes sequentially for groups (typically lines) of pixels. All the pixels are exposed for the same length of time but not at the same time.
    - **GlobalReset** (Display string: 'Global Reset'): The shutter opens at the same time for all pixels but ends in a sequential manner. The pixels are exposed for different lengths of time.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    sensorTaps = property(lib_mvIMPACT_acquire.ImageFormatControl_sensorTaps_get, doc=r"""
    An enumerated integer property. Number of taps of the camera sensor.
    Number of taps of the camera sensor.

    The following string values might be valid for this feature:
    - **One** (Display string: 'One'): 1 tap.
    - **Two** (Display string: 'Two'): 2 taps.
    - **Three** (Display string: 'Three'): 3 taps.
    - **Four** (Display string: 'Four'): 4 taps.
    - **Eight** (Display string: 'Eight'): 8 taps.
    - **Ten** (Display string: 'Ten'): 10 taps.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    sensorDigitizationTaps = property(lib_mvIMPACT_acquire.ImageFormatControl_sensorDigitizationTaps_get, doc=r"""
    An enumerated integer property. Number of digitized samples outputted simultaneously by the camera A/D conversion stage.
    Number of digitized samples outputted simultaneously by the camera A/D conversion stage.

    The following string values might be valid for this feature:
    - **One** (Display string: 'One'): 1 tap.
    - **Two** (Display string: 'Two'): 2 taps.
    - **Three** (Display string: 'Three'): 3 taps.
    - **Four** (Display string: 'Four'): 4 taps.
    - **Eight** (Display string: 'Eight'): 8 taps.
    - **Ten** (Display string: 'Ten'): 10 taps.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    widthMax = property(lib_mvIMPACT_acquire.ImageFormatControl_widthMax_get, doc=r"""
    An integer property. Maximum width of the image (in pixels).
    Maximum width of the image (in pixels). The dimension is calculated after horizontal binning, decimation or any other function changing the horizontal dimension of the image.
    """)
    heightMax = property(lib_mvIMPACT_acquire.ImageFormatControl_heightMax_get, doc=r"""
    An integer property. Maximum height of the image (in pixels).
    Maximum height of the image (in pixels). This dimension is calculated after vertical binning, decimation or any other function changing the vertical dimension of the image.
    """)
    regionSelector = property(lib_mvIMPACT_acquire.ImageFormatControl_regionSelector_get, doc=r"""
    An enumerated integer property. Selects the Region of interest to control.
    Selects the Region of interest to control. The RegionSelector feature allows devices that are able to extract multiple regions out of an image, to configure the features of those individual regions independently.

    The following string values might be valid for this feature:
    - **Region0** (Display string: 'Region 0'): Selected feature will control the region 0.
    - **Region1** (Display string: 'Region 1'): Selected feature will control the region 1.
    - **Region2** (Display string: 'Region 2'): Selected feature will control the region 2.
    - **Region**#3# (Display string: 'Region #3#'): Selected feature will control the region #3#.
    - **Scan3dExtraction0** (Display string: 'Scan 3d Extraction 0'): Selected feature will control the Scan3dExtraction0 output Region.
    - **Scan3dExtraction1** (Display string: 'Scan 3d Extraction 1'): Selected feature will control the Scan3dExtraction1 output Region.
    - **Scan3dExtraction2** (Display string: 'Scan 3d Extraction 2'): Selected feature will control the Scan3dExtraction2 output Region.
    - **All** (Display string: 'All'): Selected features will control all the regions at the same time.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    regionMode = property(lib_mvIMPACT_acquire.ImageFormatControl_regionMode_get, doc=r"""
    An enumerated integer property. Controls if the selected Region of interest is active and streaming.
    Controls if the selected Region of interest is active and streaming.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off'): Disable the usage of the Region.
    - **On** (Display string: 'On'): Enable the usage of the Region.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    regionDestination = property(lib_mvIMPACT_acquire.ImageFormatControl_regionDestination_get, doc=r"""
    An enumerated integer property. Control the destination of the selected region.
    Control the destination of the selected region.

    The following string values might be valid for this feature:
    - **Stream0** (Display string: 'Stream 0'): The destination of the region is the data stream 0.
    - **Stream1** (Display string: 'Stream 1'): The destination of the region is the data stream 1.
    - **Stream2** (Display string: 'Stream 2'): The destination of the region is the data stream 2.
    - **Stream**#3# (Display string: 'Stream #3#'): The destination of the region is the data stream #3#.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    regionIDValue = property(lib_mvIMPACT_acquire.ImageFormatControl_regionIDValue_get, doc=r"""
    An integer property. Returns a unique Identifier value that corresponds to the selected Region.
    Returns a unique Identifier value that corresponds to the selected Region.
    """)
    componentSelector = property(lib_mvIMPACT_acquire.ImageFormatControl_componentSelector_get, doc=r"""
    An enumerated integer property. Selects a component to activate/deactivate its data streaming.
    Selects a component to activate/deactivate its data streaming.

    The following string values might be valid for this feature:
    - **Intensity** (Display string: 'Intensity'): The acquisition of intensity (monochrome or color) of the visible reflected light is controlled.
    - **Infrared** (Display string: 'Infrared'): The acquisition of non-visible infrared light is controlled.
    - **Ultraviolet** (Display string: 'Ultraviolet'): The acquisition of non-visible ultraviolet light is controlled.
    - **Range** (Display string: 'Range'): The acquisition of range (distance) data is controlled. The data produced may be only range (2.5D) or a point cloud giving the 3D coordinates depending on the Scan3dControl features.
    - **Reflectance** (Display string: 'Reflectance'): The reflected intensity acquired together with Range in a Linescan3D sensor acquiring a single linescan profile for each exposure of the sensor.
    - **Confidence** (Display string: 'Confidence'): The acquisition of confidence map of the acquired image is controlled. Confidence data may be binary (0 - invalid) or an integer where 0 is invalid and increasing value is increased confidence in the data in the corresponding pixel. If floating point representation is used the confidence image is normalized to the range [0,1], for integer representation the maximum possible integer represents maximum confidence.
    - **Disparity** (Display string: 'Disparity'): The acquisition of stereo camera disparity data is controlled. Disparity is a more specific range format approximately inversely proportional to distance. Disparity is typically given in pixel units.
    - **Scatter** (Display string: 'Scatter'): The acquisition of data measuring how much light is scattered around the reflected light. In processing this is used as an additional intensity image, often together with the standard intensity or reflectance.
    - **Multispectral** (Display string: 'Multispectral'): The acquisition of multiple spectral bands corresponding to various light wavelenghts is controlled.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    componentEnable = property(lib_mvIMPACT_acquire.ImageFormatControl_componentEnable_get, doc=r"""
    A boolean property. Controls if the selected component streaming is active.
    Controls if the selected component streaming is active.
    """)
    componentIDValue = property(lib_mvIMPACT_acquire.ImageFormatControl_componentIDValue_get, doc=r"""
    An integer property. Returns a unique Identifier value that corresponds to type of the component selected by ComponentSelector.
    Returns a unique Identifier value that corresponds to type of the component selected by ComponentSelector.
    """)
    groupSelector = property(lib_mvIMPACT_acquire.ImageFormatControl_groupSelector_get, doc=r"""
    An enumerated integer property. Selects a Group of component to control or inquire.
    Selects a Group of component to control or inquire. The GroupSelector determines which components Group will be used for the selected features.

    The following string values might be valid for this feature:
    - **Group0** (Display string: 'Group 0'): Group 0
    - **Group1** (Display string: 'Group 1'): Group 1
    - **Group2** (Display string: 'Group 2'): Group 2
    - **Group**#3# (Display string: 'Group #3#'): Group #3#
    - **Group3** (Display string: 'Group 3'): Group 3

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    groupIDValue = property(lib_mvIMPACT_acquire.ImageFormatControl_groupIDValue_get, doc=r"""
    An integer property. Returns a unique Identifier value corresponding to the selected Group of Components.
    Returns a unique Identifier value corresponding to the selected Group of Components. If no grouping is required, this value should be set to 0.
    """)
    imageComponentSelector = property(lib_mvIMPACT_acquire.ImageFormatControl_imageComponentSelector_get, doc=r"""
    An enumerated integer property. This feature is deprecated (See ComponentSelector).
    Deprecated: 
    This feature is deprecated (See ComponentSelector). It was used to select a component.

    The following string values might be valid for this feature:
    - **Intensity** (Display string: 'Intensity'): The acquisition of intensity (monochrome or color) of the visible reflected light is controlled.
    - **Color** (Display string: 'Color'): The acquisition of color of the reflected light is controlled
    - **Infrared** (Display string: 'Infrared'): The acquisition of non-visible infrared light is controlled.
    - **Ultraviolet** (Display string: 'Ultraviolet'): The acquisition of non-visible ultraviolet light is controlled.
    - **Range** (Display string: 'Range'): The acquisition of range (distance) data is controlled. The data produced may be only range (2.5D) or a point cloud 3D coordinates depending on the Scan3dControl features.
    - **Confidence** (Display string: 'Confidence'): The acquisition of confidence map of the acquired image is controlled. Confidence data may be binary (0 - invalid) or an integer where 0 is invalid and increasing value is increased confidence in the data in the corresponding pixel. If floating point representation is used the confidence image is normalized to the range [0,1], for integer representation the maximum possible integer represents maximum confidence.
    - **Disparity** (Display string: 'Disparity'): The acquisition of stereo camera disparity data is controlled. Disparity is a more specific range format approximately inversely proportional to distance. Disparity is typically given in pixel units.
    - **Scatter** (Display string: 'Scatter'): The acquisition of data measuring how much light is scattered around the reflected light. In processing this is used as an additional intensity image, often together with the standard intensity.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    imageComponentEnable = property(lib_mvIMPACT_acquire.ImageFormatControl_imageComponentEnable_get, doc=r"""
    A boolean property. This feature is deprecated (See ComponentEnable).
    Deprecated: 
    This feature is deprecated (See ComponentEnable). It was used to control if the selected component streaming is active.
    """)
    width = property(lib_mvIMPACT_acquire.ImageFormatControl_width_get, doc=r"""
    An integer property. Width of the image provided by the device (in pixels).
    Width of the image provided by the device (in pixels).
    """)
    height = property(lib_mvIMPACT_acquire.ImageFormatControl_height_get, doc=r"""
    An integer property. Height of the image provided by the device (in pixels).
    Height of the image provided by the device (in pixels).
    """)
    offsetX = property(lib_mvIMPACT_acquire.ImageFormatControl_offsetX_get, doc=r"""
    An integer property. Horizontal offset from the origin to the region of interest (in pixels).
    Horizontal offset from the origin to the region of interest (in pixels).
    """)
    offsetY = property(lib_mvIMPACT_acquire.ImageFormatControl_offsetY_get, doc=r"""
    An integer property. Vertical offset from the origin to the region of interest (in pixels).
    Vertical offset from the origin to the region of interest (in pixels).
    """)
    mvBlockscanLinesPerBlock = property(lib_mvIMPACT_acquire.ImageFormatControl_mvBlockscanLinesPerBlock_get, doc=r"""
    An integer property. Blockscan mode only: Number of lines per block.
    Blockscan mode only: Number of lines per block.
    """)
    mvBlockscanBlockCount = property(lib_mvIMPACT_acquire.ImageFormatControl_mvBlockscanBlockCount_get, doc=r"""
    An integer property. Blockscan mode only: Number of blocks combined to one frame.
    Blockscan mode only: Number of blocks combined to one frame
    """)
    mvMultiAreaMode = property(lib_mvIMPACT_acquire.ImageFormatControl_mvMultiAreaMode_get, doc=r"""
    An enumerated integer property. Selects the overall multi area mode.
    Selects the overall multi area mode.

    The following string values might be valid for this feature:
    - **mvOff** (Display string: 'mv Off'): Multi area mode is altogether switched off. Only one single AOI as defined in Width, Height, OffsetX and OffsetY properties is used and valid.
    - **mvMultiAreasCombined** (Display string: 'mv Multi Areas Combined'): Image is combined from multiple areas. The overlapping of areas is allowed. The camera decides which areas it needs to crop from the image and combines all areas into one image.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvAreaSelector = property(lib_mvIMPACT_acquire.ImageFormatControl_mvAreaSelector_get, doc=r"""
    An enumerated integer property. Selects the area in multi area context.
    Selects the area in multi area context.

    The following string values might be valid for this feature:
    - **mvArea0** (Display string: 'mv Area 0'): First area in multi area context.
    - **mvArea1** (Display string: 'mv Area 1'): Second area in multi area context.
    - **mvArea2** (Display string: 'mv Area 2'): Third area in multi area context.
    - **mvArea3** (Display string: 'mv Area 3'): Fourth area in multi area context.
    - **mvArea4** (Display string: 'mv Area 4'): Fifth area in multi area context.
    - **mvArea5** (Display string: 'mv Area 5'): Sixth area in multi area context.
    - **mvArea6** (Display string: 'mv Area 6'): Seventh area in multi area context.
    - **mvArea7** (Display string: 'mv Area 7'): Eighth area in multi area context.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvAreaEnable = property(lib_mvIMPACT_acquire.ImageFormatControl_mvAreaEnable_get, doc=r"""
    A boolean property. This feature controls whether the selected area is active during streaming or not.
    This feature controls whether the selected area is active during streaming or not.
    """)
    mvAreaWidth = property(lib_mvIMPACT_acquire.ImageFormatControl_mvAreaWidth_get, doc=r"""
    An integer property. Width of this area's part of the image (in pixels).
    Width of this area's part of the image (in pixels).
    """)
    mvAreaHeight = property(lib_mvIMPACT_acquire.ImageFormatControl_mvAreaHeight_get, doc=r"""
    An integer property. Height of this area's part of the image (in pixels).
    Height of this area's part of the image (in pixels).
    """)
    mvAreaOffsetX = property(lib_mvIMPACT_acquire.ImageFormatControl_mvAreaOffsetX_get, doc=r"""
    An integer property. Horizontal offset of this area within the image (in pixels).
    Horizontal offset of this area within the image (in pixels).
    """)
    mvAreaOffsetY = property(lib_mvIMPACT_acquire.ImageFormatControl_mvAreaOffsetY_get, doc=r"""
    An integer property. Vertical offset of this area within the image (in pixels).
    Vertical offset of this area within the image (in pixels).
    """)
    mvAreaResultingOffsetX = property(lib_mvIMPACT_acquire.ImageFormatControl_mvAreaResultingOffsetX_get, doc=r"""
    An integer property. Horizontal offset of this area within the resulting image (in pixels).
    Horizontal offset of this area within the resulting image (in pixels).
    """)
    mvAreaResultingOffsetY = property(lib_mvIMPACT_acquire.ImageFormatControl_mvAreaResultingOffsetY_get, doc=r"""
    An integer property. Vertical offset of this area within the resulting image (in pixels).
    Vertical offset of this area within the resulting image (in pixels).
    """)
    linePitchEnable = property(lib_mvIMPACT_acquire.ImageFormatControl_linePitchEnable_get, doc=r"""
    A boolean property. This feature controls whether the LinePitch feature is writable.
    This feature controls whether the LinePitch feature is writable. Otherwise LinePitch is implicitly controlled by the combination of features like Width, PixelFormat, etc...
    """)
    linePitch = property(lib_mvIMPACT_acquire.ImageFormatControl_linePitch_get, doc=r"""
    An integer property. Total number of bytes between the starts of 2 consecutive lines.
    Total number of bytes between the starts of 2 consecutive lines. This feature is used to facilitate alignment of image data.
    """)
    binningSelector = property(lib_mvIMPACT_acquire.ImageFormatControl_binningSelector_get, doc=r"""
    An enumerated integer property. Selects which binning engine is controlled by the BinningHorizontal and BinningVertical features.
    Selects which binning engine is controlled by the BinningHorizontal and BinningVertical features.

    The following string values might be valid for this feature:
    - **Sensor** (Display string: 'Sensor'): Selected features will control the sensor binning.
    - **Region0** (Display string: 'Region 0'): Selected feature will control the region 0 binning.
    - **Region1** (Display string: 'Region 1'): Selected feature will control the region 1 binning.
    - **Region2** (Display string: 'Region 2'): Selected feature will control the region 2 binning.
    - **Region**#3# (Display string: 'Region #3#'): Selected feature will control the region #3# binning.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    binningHorizontalMode = property(lib_mvIMPACT_acquire.ImageFormatControl_binningHorizontalMode_get, doc=r"""
    An enumerated integer property. Sets the mode to use to combine horizontal photo-sensitive cells together when BinningHorizontal is used.
    Sets the mode to use to combine horizontal photo-sensitive cells together when BinningHorizontal is used.

    The following string values might be valid for this feature:
    - **Sum** (Display string: 'Sum'): The response from the combined cells will be added, resulting in increased sensitivity.
    - **Average** (Display string: 'Average'): The response from the combined cells will be averaged, resulting in increased signal/noise ratio.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    binningHorizontal = property(lib_mvIMPACT_acquire.ImageFormatControl_binningHorizontal_get, doc=r"""
    An integer property. Number of horizontal photo-sensitive cells to combine together.
    Number of horizontal photo-sensitive cells to combine together. This reduces the horizontal resolution (width) of the image.
    """)
    binningVerticalMode = property(lib_mvIMPACT_acquire.ImageFormatControl_binningVerticalMode_get, doc=r"""
    An enumerated integer property. Sets the mode to use to combine vertical photo-sensitive cells together when BinningVertical is used.
    Sets the mode to use to combine vertical photo-sensitive cells together when BinningVertical is used.

    The following string values might be valid for this feature:
    - **Sum** (Display string: 'Sum'): The response from the combined cells will be added, resulting in increased sensitivity.
    - **Average** (Display string: 'Average'): The response from the combined cells will be averaged, resulting in increased signal/noise ratio.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    binningVertical = property(lib_mvIMPACT_acquire.ImageFormatControl_binningVertical_get, doc=r"""
    An integer property. Number of vertical photo-sensitive cells to combine together.
    Number of vertical photo-sensitive cells to combine together. This reduces the vertical resolution (height) of the image.
    """)
    decimationHorizontalMode = property(lib_mvIMPACT_acquire.ImageFormatControl_decimationHorizontalMode_get, doc=r"""
    An enumerated integer property. Sets the mode used to reduce the horizontal resolution when DecimationHorizontal is used.
    Sets the mode used to reduce the horizontal resolution when DecimationHorizontal is used.

    The following string values might be valid for this feature:
    - **Discard** (Display string: 'Discard'): The value of every Nth pixel is kept, others are discarded.
    - **Average** (Display string: 'Average'): The values of a group of N adjacent pixels are averaged.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    decimationHorizontal = property(lib_mvIMPACT_acquire.ImageFormatControl_decimationHorizontal_get, doc=r"""
    An integer property. Horizontal sub-sampling of the image.
    Horizontal sub-sampling of the image. This reduces the horizontal resolution (width) of the image by the specified horizontal decimation factor.
    """)
    decimationVerticalMode = property(lib_mvIMPACT_acquire.ImageFormatControl_decimationVerticalMode_get, doc=r"""
    An enumerated integer property. Sets the mode used to reduce the Vertical resolution when DecimationVertical is used.
    Sets the mode used to reduce the Vertical resolution when DecimationVertical is used.

    The following string values might be valid for this feature:
    - **Discard** (Display string: 'Discard'): The value of every Nth pixel is kept, others are discarded.
    - **Average** (Display string: 'Average'): The values of a group of N adjacent pixels are averaged.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    decimationVertical = property(lib_mvIMPACT_acquire.ImageFormatControl_decimationVertical_get, doc=r"""
    An integer property. Vertical sub-sampling of the image.
    Vertical sub-sampling of the image. This reduces the vertical resolution (height) of the image by the specified vertical decimation factor.
    """)
    reverseX = property(lib_mvIMPACT_acquire.ImageFormatControl_reverseX_get, doc=r"""
    A boolean property. Flip horizontally the image sent by the device.
    Flip horizontally the image sent by the device. The Region of interest is applied after the flipping.
    """)
    reverseY = property(lib_mvIMPACT_acquire.ImageFormatControl_reverseY_get, doc=r"""
    A boolean property. Flip vertically the image sent by the device.
    Flip vertically the image sent by the device. The Region of interest is applied after the flipping.
    """)
    pixelFormat = property(lib_mvIMPACT_acquire.ImageFormatControl_pixelFormat_get, doc=r"""
    An enumerated integer property. Format of the pixels provided by the device.
    Format of the pixels provided by the device. It represents all the information provided by PixelSize, PixelColorFilter combined in a single feature.

    The following string values might be valid for this feature:
    - **Mono1p** (Display string: 'Mono1p'): Mono 1 bit packed.
    - **Mono2p** (Display string: 'Mono2p'): Mono 2 bit packed.
    - **Mono4p** (Display string: 'Mono4p'): Mono 4 bit packed.
    - **Mono8** (Display string: 'Mono8'): Mono 8 bit packed.
    - **Mono8s** (Display string: 'Mono8s'): Mono 1 bit signed.
    - **Mono10** (Display string: 'Mono10'): Mono 10 bit.
    - **Mono10p** (Display string: 'Mono10p'): Mono 10 bit packed.
    - **Mono12** (Display string: 'Mono12'): Mono 12 bit.
    - **Mono12p** (Display string: 'Mono12p'): Mono 12 bit packed.
    - **Mono14** (Display string: 'Mono14'): Mono 14 bit.
    - **Mono16** (Display string: 'Mono16'): Mono 16 bit.
    - **R8** (Display string: 'R8'): Red 8 bit.
    - **G8** (Display string: 'G8'): Green 8 bit.
    - **B8** (Display string: 'B8'): Blue 8 bit.
    - **RGB8** (Display string: 'RGB8'): Red, Green, Blue 8 bit
    - **RGB8_Planar** (Display string: 'RGB8_Planar'): Red, Green, Blue 8 bit planar.
    - **RGBa8** (Display string: 'RGBa8'): Red, Green, Blue 8 bit aligned on 8 bit
    - **RGB10** (Display string: 'RGB10'): Red, Green, Blue 10 bit.
    - **RGB10_Planar** (Display string: 'RGB10_Planar'): Red, Green, Blue 10 bit planar.
    - **RGB10p32** (Display string: 'RGB10p32'): Red, Green, Blue 10 bit packed in 32 bit pixel.
    - **RGB12** (Display string: 'RGB12'): Red, Green, Blue 12 bit.
    - **RGB12_Planar** (Display string: 'RGB12_Planar'): Red, Green, Blue 12 bit planar.
    - **RGB16** (Display string: 'RGB16'): Red, Green, Blue 16 bit.
    - **RGB16_Planar** (Display string: 'RGB16_Planar'): Red, Green, Blue 16 bit planar.
    - **RGB565p** (Display string: 'RGB565p'): Red, Green, Blue 16 bit packet in 5, 6, 5 bits.
    - **BGR10** (Display string: 'BGR10'): Blue, Green, Red, 10 bit.
    - **BGR12** (Display string: 'BGR12'): Blue, Green, Red, 12 bit.
    - **BGR16** (Display string: 'BGR16'): Blue, Green, Red, 16 bit.
    - **BGR565p** (Display string: 'BGR565p'): Blue, Green, Red, 16 bit packet in 5, 6, 5 bits.
    - **BGR8** (Display string: 'BGR8'): Blue, Green, Red, 8 bit.
    - **BGRa8** (Display string: 'BGRa8'): Blue, Green, Red, Alpha 8 bit.
    - **YUV422_8** (Display string: 'YUV422_8'): YUV 422 8 bit.
    - **YCbCr411_8** (Display string: 'YCbCr411_8'): YCrCb 411 8 bit.
    - **YCbCr422_8** (Display string: 'YCbCr422_8'): YCrCb 422 8 bit.
    - **YCbCr601_422_8** (Display string: 'YCbCr601_422_8'): YCrCb 601 422 8 bit.
    - **YCbCr709_422_8** (Display string: 'YCbCr709_422_8'): YCrCb 709 422 8 bit.
    - **YCbCr8** (Display string: 'YCbCr8'): YCbCr 8 bit.
    - **BayerBG8** (Display string: 'BayerBG8'): Bayer Blue Green 8 bit.
    - **BayerGB8** (Display string: 'BayerGB8'): Bayer Green Blue 8 bit.
    - **BayerGR8** (Display string: 'BayerGR8'): Bayer Green Red 8 bit.
    - **BayerRG8** (Display string: 'BayerRG8'): Bayer Red Green 8 bit.
    - **BayerBG10** (Display string: 'BayerBG10'): Bayer Blue Green 10 bit.
    - **BayerGB10** (Display string: 'BayerGB10'): Bayer Green Blue 10 bit.
    - **BayerGR10** (Display string: 'BayerGR10'): Bayer Green Red 10 bit.
    - **BayerRG10** (Display string: 'BayerRG10'): Bayer Red Green 10 bit.
    - **BayerBG12** (Display string: 'BayerBG12'): Bayer Blue Green 12 bit
    - **BayerGB12** (Display string: 'BayerGB12'): Bayer Green Blue 12 bit
    - **BayerGR12** (Display string: 'BayerGR12'): Bayer Green Red 12 bit.
    - **BayerRG12** (Display string: 'BayerRG12'): Bayer Red Green 12 bit.
    - **BayerBG16** (Display string: 'BayerBG16'): Bayer Blue Green 16 bit.
    - **BayerGB16** (Display string: 'BayerGB16'): Bayer Green Blue 16 bit.
    - **BayerGR16** (Display string: 'BayerGR16'): Bayer Green Red 16 bit.
    - **BayerRG16** (Display string: 'BayerRG16'): Bayer Red Green 16 bit.
    - **Coord3D_A8** (Display string: 'Coord3D_A8'): 3D coordinate, first component 8 bit.
    - **Coord3D_B8** (Display string: 'Coord3D_B8'): 3D coordinate, second component 8 bit.
    - **Coord3D_C8** (Display string: 'Coord3D_C8'): 3D coordinate, third component 8 bit.
    - **Coord3D_ABC8** (Display string: 'Coord3D_ABC8'): 3D coordinates, 3 components 8 bit.
    - **Coord3D_ABC8_Planar** (Display string: 'Coord3D_ABC8_Planar'): 3D coordinates, 3 components 8 bit planar.
    - **Coord3D_A16** (Display string: 'Coord3D_A16'): 3D coordinate, first component 16 bit.
    - **Coord3D_B16** (Display string: 'Coord3D_B16'): 3D coordinate, second component 16 bit.
    - **Coord3D_C16** (Display string: 'Coord3D_C16'): 3D coordinate, third component 16 bit.
    - **Coord3D_ABC16** (Display string: 'Coord3D_ABC16'): 3D coordinates, 3 components 16 bit.
    - **Coord3D_ABC16_Planar** (Display string: 'Coord3D_ABC16_Planar'): 3D coordinates, 3 components 16 bit planar.
    - **Coord3D_A32f** (Display string: 'Coord3D_A32f'): 3D coordinate, first component 32 bit float.
    - **Coord3D_B32f** (Display string: 'Coord3D_B32f'): 3D coordinate, second component 32 bit float.
    - **Coord3D_C32f** (Display string: 'Coord3D_C32f'): 3D coordinate, third component 32 bit float.
    - **Coord3D_ABC32f** (Display string: 'Coord3D_ABC32f'): 3D coordinates, 3 components 32 bit float.
    - **Coord3D_ABC32f_Planar** (Display string: 'Coord3D_ABC32f_Planar'): 3D coordinates, 3 components 32 bit float planar.
    - **Confidence1** (Display string: 'Confidence1'): Confidence data 1 bit.
    - **Confidence1p** (Display string: 'Confidence1p'): Confidence data 1 bit packed.
    - **Confidence8** (Display string: 'Confidence8'): Confidence data 8 bit.
    - **Confidence16** (Display string: 'Confidence16'): Confidence data 16 bit.
    - **Confidence32f** (Display string: 'Confidence32f'): Confidence data 32 bit float.
    - **Data8** (Display string: 'Data8'): Generic non-pixel data 8 bit.
    - **Data8s** (Display string: 'Data8s'): Generic non-pixel data 8 bit signed.
    - **Data16** (Display string: 'Data16'): Generic non-pixel data 16 bit.
    - **Data16s** (Display string: 'Data16s'): Generic non-pixel data 16 bit signed.
    - **Data32** (Display string: 'Data32'): Generic non-pixel data 32 bit.
    - **Data32s** (Display string: 'Data32s'): Generic non-pixel data 32 bit signed.
    - **Data32f** (Display string: 'Data32f'): Generic non-pixel data 32 bit floating point.
    - **Data64** (Display string: 'Data64'): Generic non-pixel data 64 bit.
    - **Data64s** (Display string: 'Data64s'): Generic non-pixel data 64 bit signed.
    - **Data64f** (Display string: 'Data64f'): Generic non-pixel data 64 bit floating point.
    - **Raw8** (Display string: 'Raw8'): Raw 8 bit.
    - **Raw16** (Display string: 'Raw16'): Raw 16 bit.
    - **Mono12Packed** (Display string: 'Mono12Packed'): Mono 12 bit packed (GigE Vision Specific).
    - **BayerGR10Packed** (Display string: 'BayerGR10Packed'): Bayer GR 10 bit packed (GigE Vision Specific).
    - **BayerRG10Packed** (Display string: 'BayerRG10Packed'): Bayer RG 10 bit packed (GigE Vision Specific).
    - **BayerGB10Packed** (Display string: 'BayerGB10Packed'): Bayer GB 10 bit packed (GigE Vision Specific).
    - **BayerBG10Packed** (Display string: 'BayerBG10Packed'): Bayer BG 10 bit packed (GigE Vision Specific).
    - **BayerGR12Packed** (Display string: 'BayerGR12Packed'): Bayer GR 12 bit packed (GigE Vision Specific).
    - **BayerRG12Packed** (Display string: 'BayerRG12Packed'): Bayer RG 12 bit packed (GigE Vision Specific).
    - **BayerGB12Packed** (Display string: 'BayerGB12Packed'): Bayer GB 12 bit packed (GigE Vision Specific).
    - **BayerBG12Packed** (Display string: 'BayerBG12Packed'): Bayer BG 12 bit packed (GigE Vision Specific).
    - **RGB10V1Packed** (Display string: 'RGB10V1Packed'): RGB 10 bit packed (GigE Vision Specific).
    - **RGB12V1Packed** (Display string: 'RGB12V1Packed'): RGB 12 bit packed (GigE Vision Specific).
    - **Mono8Signed** (Display string: 'Mono 8 Signed')
    - **Mono10Packed** (Display string: 'Mono 10 Packed')
    - **RGB8Packed** (Display string: 'RGB 8 Packed')
    - **BGR8Packed** (Display string: 'BGR 8 Packed')
    - **RGBA8Packed** (Display string: 'RGBA 8 Packed')
    - **BGRA8Packed** (Display string: 'BGRA 8 Packed')
    - **RGB10Packed** (Display string: 'RGB 10 Packed')
    - **BGR10Packed** (Display string: 'BGR 10 Packed')
    - **RGB12Packed** (Display string: 'RGB 12 Packed')
    - **BGR12Packed** (Display string: 'BGR 12 Packed')
    - **RGB16Packed** (Display string: 'RGB 16 Packed')
    - **RGB10V2Packed** (Display string: 'RGB 10 V 2 Packed')
    - **RGB565Packed** (Display string: 'RGB 565 Packed')
    - **BGR565Packed** (Display string: 'BGR 565 Packed')
    - **YUV411Packed** (Display string: 'YUV 411 Packed')
    - **YUV422Packed** (Display string: 'YUV 422 Packed')
    - **YUV444Packed** (Display string: 'YUV 444 Packed')
    - **YUYVPacked** (Display string: 'YUYV Packed')
    - **RGB8Planar** (Display string: 'RGB 8 Planar')
    - **RGB10Planar** (Display string: 'RGB 10 Planar')
    - **RGB12Planar** (Display string: 'RGB 12 Planar')
    - **RGB16Planar** (Display string: 'RGB 16 Planar')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    pixelFormatInfoSelector = property(lib_mvIMPACT_acquire.ImageFormatControl_pixelFormatInfoSelector_get, doc=r"""
    An enumerated integer property. Select the pixel format for which the information will be returned.
    Select the pixel format for which the information will be returned.

    The following string values might be valid for this feature:
    - **Mono1p** (Display string: 'Mono1p'): Mono 1 bit packed.
    - **Mono2p** (Display string: 'Mono2p'): Mono 2 bit packed.
    - **Mono4p** (Display string: 'Mono4p'): Mono 4 bit packed.
    - **Mono8** (Display string: 'Mono8'): Mono 8 bit packed.
    - **Mono10** (Display string: 'Mono10'): Mono 10 bit.
    - **Mono10p** (Display string: 'Mono10p'): Mono 10 bit packed.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    pixelFormatInfoID = property(lib_mvIMPACT_acquire.ImageFormatControl_pixelFormatInfoID_get, doc=r"""
    An integer property. Returns the value used by the streaming channels to identify the selected pixel format.
    Returns the value used by the streaming channels to identify the selected pixel format.
    """)
    pixelCoding = property(lib_mvIMPACT_acquire.ImageFormatControl_pixelCoding_get, doc=r"""
    An enumerated integer property. This feature is deprecated.
    Deprecated: 
    This feature is deprecated. It represents the coding of the pixels in the image. Raw gives the data in the native format of the sensor.

    The following string values might be valid for this feature:
    - **Mono** (Display string: 'Mono'): Mono.
    - **MonoSigned** (Display string: 'MonoSigned'): Mono signed.
    - **MonoPacked** (Display string: 'MonoPacked'): Mono packed.
    - **RGBPacked** (Display string: 'RGBPacked'): RGB packed.
    - **BGRPacked** (Display string: 'BGRPacked'): BGR packed.
    - **RGBAPacked** (Display string: 'RGBAPacked'): RGBA packed.
    - **BGRAPacked** (Display string: 'BGRAPacked'): BGRA packed.
    - **RGBPlanar** (Display string: 'RGBPlanar'): RGB planar.
    - **YUV411Packed** (Display string: 'YUV411Packed'): YUV 411 packed.
    - **YUV422Packed** (Display string: 'YUV422Packed'): YUV 422 packed.
    - **YUV444Packed** (Display string: 'YUV444Packed'): YUV 444 packed.
    - **YUYVPacked** (Display string: 'YUYVPacked'): YUYV packed.
    - **Raw** (Display string: 'Raw'): Raw.
    - **RawPacked** (Display string: 'RawPacked'): Raw packed.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    pixelSize = property(lib_mvIMPACT_acquire.ImageFormatControl_pixelSize_get, doc=r"""
    An enumerated integer property. Total size in bits of a pixel of the image.
    Total size in bits of a pixel of the image.

    The following string values might be valid for this feature:
    - **Bpp1** (Display string: 'Bpp1'): 1 bit per pixel.
    - **Bpp2** (Display string: 'Bpp2'): 2 bits per pixel.
    - **Bpp4** (Display string: 'Bpp4'): 4 bits per pixel.
    - **Bpp8** (Display string: 'Bpp8'): 8 bits per pixel.
    - **Bpp10** (Display string: 'Bpp10'): 10 bits per pixel.
    - **Bpp12** (Display string: 'Bpp12'): 12 bits per pixel.
    - **Bpp14** (Display string: 'Bpp14'): 14 bits per pixel.
    - **Bpp16** (Display string: 'Bpp16'): 16 bits per pixel.
    - **Bpp20** (Display string: 'Bpp20'): 20 bits per pixel.
    - **Bpp24** (Display string: 'Bpp24'): 24 bits per pixel.
    - **Bpp30** (Display string: 'Bpp30'): 30 bits per pixel.
    - **Bpp32** (Display string: 'Bpp32'): 32 bits per pixel.
    - **Bpp36** (Display string: 'Bpp36'): 36 bits per pixel.
    - **Bpp48** (Display string: 'Bpp48'): 48 bits per pixel.
    - **Bpp64** (Display string: 'Bpp64'): 64 bits per pixel.
    - **Bpp96** (Display string: 'Bpp96'): 96 bits per pixel.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    pixelColorFilter = property(lib_mvIMPACT_acquire.ImageFormatControl_pixelColorFilter_get, doc=r"""
    An enumerated integer property. Type of color filter that is applied to the image.
    Type of color filter that is applied to the image.

    The following string values might be valid for this feature:
    - **None** (Display string: 'None'): No color filter.
    - **BayerRG** (Display string: 'BayerRG'): Bayer Red Green filter.
    - **BayerGB** (Display string: 'BayerGB'): Bayer Green Blue filter.
    - **BayerGR** (Display string: 'BayerGR'): Bayer Green Red filter.
    - **BayerBG** (Display string: 'BayerBG'): Bayer Blue Green filter.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    pixelDynamicRangeMin = property(lib_mvIMPACT_acquire.ImageFormatControl_pixelDynamicRangeMin_get, doc=r"""
    An integer property. Minimum value that can be returned during the digitization process.
    Minimum value that can be returned during the digitization process. This corresponds to the darkest value of the camera. For color camera, this returns the smallest value that each color component can take.
    """)
    pixelDynamicRangeMax = property(lib_mvIMPACT_acquire.ImageFormatControl_pixelDynamicRangeMax_get, doc=r"""
    An integer property. Maximum value that will be returned during the digitization process.
    Maximum value that will be returned during the digitization process. This corresponds to the brightest value of the camera. For color camera, this returns the biggest value that each color component can take.
    """)
    testPatternGeneratorSelector = property(lib_mvIMPACT_acquire.ImageFormatControl_testPatternGeneratorSelector_get, doc=r"""
    An enumerated integer property. Selects which test pattern generator is controlled by the TestPattern feature.
    Selects which test pattern generator is controlled by the TestPattern feature.

    The following string values might be valid for this feature:
    - **Sensor** (Display string: 'Sensor'): TestPattern feature will control the sensor's test pattern generator.
    - **Region0** (Display string: 'Region 0'): TestPattern feature will control the region 0 test pattern generator.
    - **Region1** (Display string: 'Region 1'): TestPattern feature will control the region 1 test pattern generator.
    - **Region2** (Display string: 'Region 2'): TestPattern feature will control the region 2 test pattern generator.
    - **Region**#3# (Display string: 'Region #3#'): TestPattern feature will control the region #3# test pattern generator.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    testPattern = property(lib_mvIMPACT_acquire.ImageFormatControl_testPattern_get, doc=r"""
    An enumerated integer property. Selects the type of test pattern that is generated by the device as image source.
    Selects the type of test pattern that is generated by the device as image source.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off'): Image is coming from the sensor.
    - **Black** (Display string: 'Black'): Image is filled with the darkest possible image.
    - **White** (Display string: 'White'): Image is filled with the brightest possible image.
    - **GreyHorizontalRamp** (Display string: 'Grey Horizontal Ramp'): Image is filled horizontally with an image that goes from the darkest possible value to the brightest.
    - **GreyVerticalRamp** (Display string: 'Grey Vertical Ramp'): Image is filled vertically with an image that goes from the darkest possible value to the brightest.
    - **GreyHorizontalRampMoving** (Display string: 'Grey Horizontal Ramp Moving'): Image is filled horizontally with an image that goes from the darkest possible value to the brightest and that moves horizontally from left to right at each frame.
    - **GreyVerticalRampMoving** (Display string: 'Grey Vertical Ramp Moving'): Image is filled vertically with an image that goes from the darkest possible value to the brightest and that moves vertically from top to bottom at each frame.
    - **HorizontalLineMoving** (Display string: 'Horizontal Line Moving'): A moving horizontal line is superimposed on the live image.
    - **VerticalLineMoving** (Display string: 'Vertical Line Moving'): A moving vertical line is superimposed on the live image.
    - **ColorBar** (Display string: 'Color Bar'): Image is filled with stripes of color including White, Black, Red, Green, Blue, Cyan, Magenta and Yellow.
    - **FrameCounter** (Display string: 'Frame Counter'): A frame counter is superimposed on the live image.
    - **HorzontalLineMoving** (Display string: 'Horzontal Line Moving')
    - **mvBayerRaw** (Display string: 'mv Bayer Raw')
    - **mvGreyDiagonalRamp** (Display string: 'mv Grey Diagonal Ramp')
    - **mvFadeToGreyColorBar** (Display string: 'mv Fade To Grey Color Bar')
    - **mvFFCImage** (Display string: 'mv FFC Image')
    - **mvMovingGreyDiagonalRamp** (Display string: 'mv Moving Grey Diagonal Ramp')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    testImageSelector = property(lib_mvIMPACT_acquire.ImageFormatControl_testImageSelector_get, doc=r"""
    An enumerated integer property. This feature is deprecated (See TestPattern).
    Deprecated: 
    This feature is deprecated (See TestPattern). Selects the type of test image that is sent by the device.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off'): Image is coming from the sensor.
    - **Black** (Display string: 'Black'): Image is filled with the darkest possible image.
    - **White** (Display string: 'White'): Image is filled with the brightest possible image.
    - **GreyHorizontalRamp** (Display string: 'Grey Horizontal Ramp'): Image is filled horizontally with an image that goes from the darkest possible value to the brightest.
    - **GreyVerticalRamp** (Display string: 'Grey Vertical Ramp'): Image is filled vertically with an image that goes from the darkest possible value to the brightest.
    - **GreyHorizontalRampMoving** (Display string: 'Grey Horizontal Ramp Moving'): Image is filled horizontally with an image that goes from the darkest possible value to the brightest and that moves horizontally from left to right at each frame.
    - **GreyVerticalRampMoving** (Display string: 'Grey Vertical Ramp Moving'): Image is filled vertically with an image that goes from the darkest possible value to the brightest and that moves vertically from top to bottom at each frame.
    - **HorizontalLineMoving** (Display string: 'Horizontal Line Moving'): A moving horizontal line is superimposed on the live image.
    - **VerticalLineMoving** (Display string: 'Vertical Line Moving'): A moving vertical line is superimposed on the live image.
    - **ColorBar** (Display string: 'Color Bar'): Image is filled with stripes of color including White, Black, Red, Green, Blue, Cyan, Magenta and Yellow.
    - **FrameCounter** (Display string: 'Frame Counter'): A frame counter is superimposed on the live image.
    - **HorzontalLineMoving** (Display string: 'Horzontal Line Moving')
    - **mvBayerRaw** (Display string: 'mv Bayer Raw')
    - **mvGreyDiagonalRamp** (Display string: 'mv Grey Diagonal Ramp')
    - **mvFadeToGreyColorBar** (Display string: 'mv Fade To Grey Color Bar')
    - **mvFFCImage** (Display string: 'mv FFC Image')
    - **mvMovingGreyDiagonalRamp** (Display string: 'mv Moving Grey Diagonal Ramp')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    deinterlacing = property(lib_mvIMPACT_acquire.ImageFormatControl_deinterlacing_get, doc=r"""
    An enumerated integer property. Controls how the device performs de-interlacing.
    Controls how the device performs de-interlacing.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off'): The device doesn't perform de-interlacing.
    - **LineDuplication** (Display string: 'Line Duplication'): The device performs de-interlacing by outputting each line of each field twice.
    - **Weave** (Display string: 'Weave'): The device performs de-interlacing by interleaving the lines of all fields.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    imageCompressionMode = property(lib_mvIMPACT_acquire.ImageFormatControl_imageCompressionMode_get, doc=r"""
    An enumerated integer property. Enable a specific image compression mode as the base mode for image transfer.
    Enable a specific image compression mode as the base mode for image transfer. Optionally, chunk data can be appended to the compressed image (See the  REF _Ref397502619 chapter).

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off'): Default value. Image compression is disabled. Images are transmitted uncompressed.
    - **JPEG** (Display string: 'JPEG'): JPEG compression is selected.
    - **JPEG2000** (Display string: 'JPEG 2000'): JPEG 2000 compression is selected.
    - **H264** (Display string: 'H 264'): H.264 compression is selected.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    imageCompressionRateOption = property(lib_mvIMPACT_acquire.ImageFormatControl_imageCompressionRateOption_get, doc=r"""
    An enumerated integer property. Two rate controlling options are offered: fixed bit rate or fixed quality.
    Two rate controlling options are offered: fixed bit rate or fixed quality. The exact implementation to achieve one or the other is vendor-specific.

    The following string values might be valid for this feature:
    - **FixBitrate** (Display string: 'Fix Bitrate'): Output stream follows a constant bit rate. Allows easy bandwidth management on the link.
    - **FixQuality** (Display string: 'Fix Quality'): Output stream has a constant image quality. Can be used when image processing algorithms are sensitive to image degradation caused by excessive data compression.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    imageCompressionQuality = property(lib_mvIMPACT_acquire.ImageFormatControl_imageCompressionQuality_get, doc=r"""
    An integer property. Control the quality of the produced compressed stream.
    Control the quality of the produced compressed stream.
    """)
    imageCompressionBitrate = property(lib_mvIMPACT_acquire.ImageFormatControl_imageCompressionBitrate_get, doc=r"""
    A floating point property. Control the rate of the produced compressed stream.
    Control the rate of the produced compressed stream.
    """)
    imageCompressionJPEGFormatOption = property(lib_mvIMPACT_acquire.ImageFormatControl_imageCompressionJPEGFormatOption_get, doc=r"""
    An enumerated integer property. When JPEG is selected as the compression format, a device might optionally offer better control over JPEG-specific options through this feature.
    When JPEG is selected as the compression format, a device might optionally offer better control over JPEG-specific options through this feature.

    The following string values might be valid for this feature:
    - **Lossless** (Display string: 'Lossless'): Selects lossless JPEG compression based on a predictive coding model.
    - **BaselineStandard** (Display string: 'Baseline Standard'): Indicates this is a baseline sequential (single-scan) DCT-based JPEG.
    - **BaselineOptimized** (Display string: 'Baseline Optimized'): Provides optimized color and slightly better compression than baseline standard by using custom Huffman tables optimized after statistical analysis of the image content.
    - **Progressive** (Display string: 'Progressive'): Indicates this is a progressive (multi-scan) DCT-based JPEG.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvSensorDigitizationBitDepth = property(lib_mvIMPACT_acquire.ImageFormatControl_mvSensorDigitizationBitDepth_get, doc=r"""
    An enumerated integer property. This feature manually selects the resolution of the device's ADC.
    This feature manually selects the resolution of the device's ADC.

    The following string values might be valid for this feature:
    - **Auto** (Display string: 'Auto'): When the selected pixel format has 12 bits or more the ADC will work with 12 bits. Otherwise the ADC will work with 10 bits.
    - **Bpp8** (Display string: 'Bpp 8'): The ADC will always work with a resolution of  8 bits no matter which pixel format has been selected.
    - **Bpp10** (Display string: 'Bpp 10'): The ADC will always work with a resolution of 10 bits no matter which pixel format has been selected.
    - **Bpp12** (Display string: 'Bpp 12'): The ADC will always work with a resolution of 12 bits no matter which pixel format has been selected. This will allow to achieve higher precision and thus improved quality when internal processing is done (e.g. when applying digital gain to the image).
    - **Fixed** (Display string: 'Fixed')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_ImageFormatControl

# Register ImageFormatControl in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.ImageFormatControl_swigregister(ImageFormatControl)

class AcquisitionControl(object):
    r"""
    Category for the acquisition and trigger control features.
    A category for the acquisition and trigger control features.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::GenICam::AcquisitionControl** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.AcquisitionControl_swiginit(self, lib_mvIMPACT_acquire.new_AcquisitionControl(*args))
    acquisitionMode = property(lib_mvIMPACT_acquire.AcquisitionControl_acquisitionMode_get, doc=r"""
    An enumerated integer property. Sets the acquisition mode of the device.
    Sets the acquisition mode of the device. It defines mainly the number of frames to capture during an acquisition and the way the acquisition stops.

    The following string values might be valid for this feature:
    - **SingleFrame** (Display string: 'Single Frame'): One frame is captured.
    - **MultiFrame** (Display string: 'Multi Frame'): The number of frames specified by AcquisitionFrameCount is captured.
    - **Continuous** (Display string: 'Continuous'): Frames are captured continuously until stopped with the AcquisitionStop command.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    acquisitionStart = property(lib_mvIMPACT_acquire.AcquisitionControl_acquisitionStart_get, doc=r"""
    A method object. Starts the Acquisition of the device.
    Starts the Acquisition of the device. The number of frames captured is specified by AcquisitionMode.
    """)
    acquisitionStop = property(lib_mvIMPACT_acquire.AcquisitionControl_acquisitionStop_get, doc=r"""
    A method object. Stops the Acquisition of the device at the end of the current Frame.
    Stops the Acquisition of the device at the end of the current Frame. It is mainly used when AcquisitionMode is Continuous but can be used in any acquisition mode.
    """)
    acquisitionStopMode = property(lib_mvIMPACT_acquire.AcquisitionControl_acquisitionStopMode_get, doc=r"""
    An enumerated integer property. Controls how the AcquisitionStop command and the acquisition stopped using a trigger (e.g.
    Controls how the AcquisitionStop command and the acquisition stopped using a trigger (e.g. AcquisitionActive, FrameBurstActive, FrameActive or FrameEnd trigger), ends an ongoing frame. This feature is mainly used in Linescan devices where each line in a frame is acquired sequentially.

    The following string values might be valid for this feature:
    - **Complete** (Display string: 'Complete'): When stopped during a frame, the device will continue acquisition of lines until the specified Height is reached to deliver a complete default size frame. Note that if each line is triggered from an external source and this line trigger stops no frame is delivered, and an AcquisitionAbort is needed.
    - **Immediate** (Display string: 'Immediate'): Acquisition stops immediately even during a frame and only the lines acquired at the time  are delivered.
    - **ImmediateWithPadding** (Display string: 'Immediate With Padding'): Acquisition stops immediately even during a frame but the remaining of the frame will be padded with data to deliver a complete default Height frame.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    acquisitionAbort = property(lib_mvIMPACT_acquire.AcquisitionControl_acquisitionAbort_get, doc=r"""
    A method object. Aborts the Acquisition immediately.
    Aborts the Acquisition immediately. This will end the capture without completing the current Frame or waiting on a trigger. If no Acquisition is in progress, the command is ignored.
    """)
    acquisitionArm = property(lib_mvIMPACT_acquire.AcquisitionControl_acquisitionArm_get, doc=r"""
    A method object. Arms the device before an AcquisitionStart command.
    Arms the device before an AcquisitionStart command. This optional command validates all the current features for consistency and prepares the device for a fast start of the Acquisition.
    """)
    acquisitionFrameCount = property(lib_mvIMPACT_acquire.AcquisitionControl_acquisitionFrameCount_get, doc=r"""
    An integer property. Number of frames to acquire in MultiFrame Acquisition mode.
    Number of frames to acquire in MultiFrame Acquisition mode.
    """)
    acquisitionBurstFrameCount = property(lib_mvIMPACT_acquire.AcquisitionControl_acquisitionBurstFrameCount_get, doc=r"""
    An integer property. Number of frames to acquire for each FrameBurstStart trigger.
    Number of frames to acquire for each FrameBurstStart trigger.
    """)
    mvSensorRegister = property(lib_mvIMPACT_acquire.AcquisitionControl_mvSensorRegister_get, doc=r"""
    An integer property. Number of sensor register to access.
    Number of sensor register to access.
    """)
    mvSensorRegisterValue = property(lib_mvIMPACT_acquire.AcquisitionControl_mvSensorRegisterValue_get, doc=r"""
    An integer property. Value of sensor register.
    Value of sensor register.
    """)
    acquisitionFrameRate = property(lib_mvIMPACT_acquire.AcquisitionControl_acquisitionFrameRate_get, doc=r"""
    A floating point property. Controls the acquisition rate (in Hertz) at which the frames are captured.
    Controls the acquisition rate (in Hertz) at which the frames are captured.
    """)
    acquisitionFrameRateEnable = property(lib_mvIMPACT_acquire.AcquisitionControl_acquisitionFrameRateEnable_get, doc=r"""
    A boolean property. Controls if the AcquisitionFrameRate feature is writable and used to control the acquisition rate.
    Controls if the AcquisitionFrameRate feature is writable and used to control the acquisition rate. Otherwise, the acquisition rate is implicitly controlled by the combination of other features like ExposureTime, etc...
    """)
    acquisitionLineRate = property(lib_mvIMPACT_acquire.AcquisitionControl_acquisitionLineRate_get, doc=r"""
    A floating point property. Controls the rate (in Hertz) at which the Lines in a Frame are captured.
    Controls the rate (in Hertz) at which the Lines in a Frame are captured.
    """)
    acquisitionLineRateEnable = property(lib_mvIMPACT_acquire.AcquisitionControl_acquisitionLineRateEnable_get, doc=r"""
    A boolean property. Controls if the AcquisitionLineRate feature is writable and used to control the acquisition rate.
    Controls if the AcquisitionLineRate feature is writable and used to control the acquisition rate. Otherwise, the acquisition rate is implicitly controlled by the combination of other features like ExposureTime, etc...
    """)
    acquisitionStatusSelector = property(lib_mvIMPACT_acquire.AcquisitionControl_acquisitionStatusSelector_get, doc=r"""
    An enumerated integer property. Selects the internal acquisition signal to read using AcquisitionStatus.
    Selects the internal acquisition signal to read using AcquisitionStatus.

    The following string values might be valid for this feature:
    - **AcquisitionTriggerWait** (Display string: 'Acquisition Trigger Wait'): Device is currently waiting for a trigger for the capture of one or many frames.
    - **AcquisitionActive** (Display string: 'Acquisition Active'): Device is currently doing an acquisition of one or many frames.
    - **AcquisitionTransfer** (Display string: 'Acquisition Transfer'): Device is currently transferring an acquisition of one or many frames.
    - **FrameTriggerWait** (Display string: 'Frame Trigger Wait'): Device is currently waiting for a frame start trigger.
    - **FrameActive** (Display string: 'Frame Active'): Device is currently doing the capture of a frame.
    - **ExposureActive** (Display string: 'Exposure Active'): Device is doing the exposure of a frame.
    - **FrameTransfer** (Display string: 'Frame Transfer'): See TransferStatus.
    - **FrameTransfer** (Display string: 'Frame Transfer'): See TransferStatus.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    acquisitionStatus = property(lib_mvIMPACT_acquire.AcquisitionControl_acquisitionStatus_get, doc=r"""
    A boolean property. Reads the state of the internal acquisition signal selected using AcquisitionStatusSelector.
    Reads the state of the internal acquisition signal selected using AcquisitionStatusSelector.
    """)
    triggerSelector = property(lib_mvIMPACT_acquire.AcquisitionControl_triggerSelector_get, doc=r"""
    An enumerated integer property. Selects the type of trigger to configure.
    Selects the type of trigger to configure.

    The following string values might be valid for this feature:
    - **AcquisitionStart** (Display string: 'Acquisition Start'): Selects a trigger that starts the Acquisition of one or many frames according to AcquisitionMode.
    - **AcquisitionEnd** (Display string: 'Acquisition End'): Selects a trigger that ends the Acquisition of one or many frames according to AcquisitionMode.
    - **AcquisitionActive** (Display string: 'Acquisition Active'): Selects a trigger that controls the duration of the Acquisition of one or many frames. The Acquisition is activated when the trigger signal becomes active and terminated when it goes back to the inactive state.
    - **FrameStart** (Display string: 'Frame Start'): Selects a trigger starting the capture of one frame.
    - **FrameEnd** (Display string: 'Frame End'): Selects a trigger ending the capture of one frame (mainly used in linescan mode).
    - **FrameActive** (Display string: 'Frame Active'): Selects a trigger controlling the duration of one frame (mainly used in linescan mode).
    - **FrameBurstStart** (Display string: 'Frame Burst Start'): Selects a trigger starting the capture of the bursts of frames in an acquisition. AcquisitionBurstFrameCount controls the length of each burst unless a FrameBurstEnd trigger is active. The total number of frames captured is also conditioned by AcquisitionFrameCount if AcquisitionMode is MultiFrame.
    - **FrameBurstEnd** (Display string: 'Frame Burst End'): Selects a trigger ending the capture of the bursts of frames in an acquisition.
    - **FrameBurstActive** (Display string: 'Frame Burst Active'): Selects a trigger controlling the duration of the capture of the bursts of frames in an acquisition.
    - **LineStart** (Display string: 'Line Start'): Selects a trigger starting the capture of one Line of a Frame (mainly used in linescan mode).
    - **ExposureStart** (Display string: 'Exposure Start'): Selects a trigger controlling the start of the exposure of one Frame (or Line).
    - **ExposureEnd** (Display string: 'Exposure End'): Selects a trigger controlling the end of the exposure of one Frame (or Line).
    - **ExposureActive** (Display string: 'Exposure Active'): Selects a trigger controlling the duration of the exposure of one frame (or Line).
    - **MultiSlopeExposureLimit1** (Display string: 'Multi Slope Exposure Limit 1'): Selects a trigger controlling the first duration of a multi-slope exposure. Exposure is continued according to the pre-defined multi-slope settings.
    - **mvTimestampReset** (Display string: 'mv Timestamp Reset')
    - **mvLoopRecordEnd** (Display string: 'mv Loop Record End')
    - **mvFrameStartSensor2** (Display string: 'mv Frame Start Sensor 2')
    - **mvInvalidTriggerSelector** (Display string: 'mv Invalid Trigger Selector')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    triggerMode = property(lib_mvIMPACT_acquire.AcquisitionControl_triggerMode_get, doc=r"""
    An enumerated integer property. Controls if the selected trigger is active.
    Controls if the selected trigger is active.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off'): Disables the selected trigger.
    - **On** (Display string: 'On'): Enable the selected trigger.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    triggerSoftware = property(lib_mvIMPACT_acquire.AcquisitionControl_triggerSoftware_get, doc=r"""
    A method object. Generates an internal trigger.
    Generates an internal trigger. TriggerSource must be set to Software.
    """)
    triggerSource = property(lib_mvIMPACT_acquire.AcquisitionControl_triggerSource_get, doc=r"""
    An enumerated integer property. Specifies the internal signal or physical input Line to use as the trigger source.
    Specifies the internal signal or physical input Line to use as the trigger source. The selected trigger must have its TriggerMode set to On.

    The following string values might be valid for this feature:
    - **Software** (Display string: 'Software'): Specifies that the trigger source will be generated by software using the TriggerSoftware command.
    - **SoftwareSignal0** (Display string: 'Software Signal 0'): Specifies that the trigger source will be a signal generated by software using the SoftwareSignalPulse command.
    - **SoftwareSignal1** (Display string: 'Software Signal 1'): Specifies that the trigger source will be a signal generated by software using the SoftwareSignalPulse command.
    - **SoftwareSignal2** (Display string: 'Software Signal 2'): Specifies that the trigger source will be a signal generated by software using the SoftwareSignalPulse command.
    - **SoftwareSignal**#3# (Display string: 'Software Signal #3#'): Specifies that the trigger source will be a signal generated by software using the SoftwareSignalPulse command.
    - **Line0** (Display string: 'Line 0'): Specifies which physical line (or pin) and associated I/O control block to use as external source for the trigger signal.
    - **Line1** (Display string: 'Line 1'): Specifies which physical line (or pin) and associated I/O control block to use as external source for the trigger signal.
    - **Line2** (Display string: 'Line 2'): Specifies which physical line (or pin) and associated I/O control block to use as external source for the trigger signal.
    - **Line**#3# (Display string: 'Line #3#'): Specifies which physical line (or pin) and associated I/O control block to use as external source for the trigger signal.
    - **UserOutput0** (Display string: 'User Output 0'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **UserOutput1** (Display string: 'User Output 1'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **UserOutput2** (Display string: 'User Output 2'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **UserOutput**#3# (Display string: 'User Output #3#'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **Counter0Start** (Display string: 'Counter 0 Start'): Specifies which of the Counter signal to use as internal source for the trigger.
    - **Counter1Start** (Display string: 'Counter 1 Start'): Specifies which of the Counter signal to use as internal source for the trigger.
    - **Counter2Start** (Display string: 'Counter 2 Start'): Specifies which of the Counter signal to use as internal source for the trigger.
    - **Counter**#3#Start (Display string: 'Counter #3# Start'): Specifies which of the Counter signal to use as internal source for the trigger.
    - **Counter0End** (Display string: 'Counter 0 End'): Specifies which of the Counter signal to use as internal source for the trigger.
    - **Counter1End** (Display string: 'Counter 1 End'): Specifies which of the Counter signal to use as internal source for the trigger.
    - **Counter2End** (Display string: 'Counter 2 End'): Specifies which of the Counter signal to use as internal source for the trigger.
    - **Counter**#3#End (Display string: 'Counter #3# End'): Specifies which of the Counter signal to use as internal source for the trigger.
    - **Timer0Start** (Display string: 'Timer 0 Start'): Specifies which Timer signal to use as internal source for the trigger.
    - **Timer1Start** (Display string: 'Timer 1 Start'): Specifies which Timer signal to use as internal source for the trigger.
    - **Timer2Start** (Display string: 'Timer 2 Start'): Specifies which Timer signal to use as internal source for the trigger.
    - **Timer**#3#Start (Display string: 'Timer #3# Start'): Specifies which Timer signal to use as internal source for the trigger.
    - **Timer0End** (Display string: 'Timer 0 End'): Specifies which Timer signal to use as internal source for the trigger.
    - **Timer1End** (Display string: 'Timer 1 End'): Specifies which Timer signal to use as internal source for the trigger.
    - **Timer2End** (Display string: 'Timer 2 End'): Specifies which Timer signal to use as internal source for the trigger.
    - **Timer**#3#End (Display string: 'Timer #3# End'): Specifies which Timer signal to use as internal source for the trigger.
    - **Encoder0** (Display string: 'Encoder 0'): Specifies which Encoder signal to use as internal source for the trigger.
    - **Encoder1** (Display string: 'Encoder 1'): Specifies which Encoder signal to use as internal source for the trigger.
    - **Encoder2** (Display string: 'Encoder 2'): Specifies which Encoder signal to use as internal source for the trigger.
    - **Encoder**#3# (Display string: 'Encoder #3#'): Specifies which Encoder signal to use as internal source for the trigger.
    - **LogicBlock0** (Display string: 'Logic Block 0'): Specifies which Logic Block signal to use as internal source for the trigger.
    - **LogicBlock1** (Display string: 'Logic Block 1'): Specifies which Logic Block signal to use as internal source for the trigger.
    - **LogicBlock2** (Display string: 'Logic Block 2'): Specifies which Logic Block signal to use as internal source for the trigger.
    - **LogicBlock**#3# (Display string: 'Logic Block #3#'): Specifies which Logic Block signal to use as internal source for the trigger.
    - **Action0** (Display string: 'Action 0'): Specifies which Action command to use as internal source for the trigger.
    - **Action1** (Display string: 'Action 1'): Specifies which Action command to use as internal source for the trigger.
    - **Action2** (Display string: 'Action 2'): Specifies which Action command to use as internal source for the trigger.
    - **Action**#3# (Display string: 'Action #3#'): Specifies which Action command to use as internal source for the trigger.
    - **LinkTrigger0** (Display string: 'Link Trigger 0'): Specifies which Link Trigger to use as  source for the trigger (received from the transport layer).
    - **LinkTrigger1** (Display string: 'Link Trigger 1'): Specifies which Link Trigger to use as  source for the trigger (received from the transport layer).
    - **LinkTrigger2** (Display string: 'Link Trigger 2'): Specifies which Link Trigger to use as  source for the trigger (received from the transport layer).
    - **LinkTrigger**#3# (Display string: 'Link Trigger #3#'): Specifies which Link Trigger to use as  source for the trigger (received from the transport layer).
    - **CC1** (Display string: 'CC 1'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink products only.
    - **CC2** (Display string: 'CC 2'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink products only.
    - **CC3** (Display string: 'CC 3'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink products only.
    - **CC4** (Display string: 'CC 4'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink products only.
    - **CC**#5# (Display string: 'CC #5#'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink products only.
    - **Line3** (Display string: 'Line 3'): Specifies which physical line (or pin) and associated I/O control block to use as external source for the trigger signal.
    - **Line4** (Display string: 'Line 4'): Specifies which physical line (or pin) and associated I/O control block to use as external source for the trigger signal.
    - **Line5** (Display string: 'Line 5'): Specifies which physical line (or pin) and associated I/O control block to use as external source for the trigger signal.
    - **Line6** (Display string: 'Line 6'): Specifies which physical line (or pin) and associated I/O control block to use as external source for the trigger signal.
    - **Line7** (Display string: 'Line 7'): Specifies which physical line (or pin) and associated I/O control block to use as external source for the trigger signal.
    - **Line8** (Display string: 'Line 8'): Specifies which physical line (or pin) and associated I/O control block to use as external source for the trigger signal.
    - **Line9** (Display string: 'Line 9'): Specifies which physical line (or pin) and associated I/O control block to use as external source for the trigger signal.
    - **Line10** (Display string: 'Line 10'): Specifies which physical line (or pin) and associated I/O control block to use as external source for the trigger signal.
    - **Line11** (Display string: 'Line 11'): Specifies which physical line (or pin) and associated I/O control block to use as external source for the trigger signal.
    - **Line12** (Display string: 'Line 12'): Specifies which physical line (or pin) and associated I/O control block to use as external source for the trigger signal.
    - **Line13** (Display string: 'Line 13'): Specifies which physical line (or pin) and associated I/O control block to use as external source for the trigger signal.
    - **Line14** (Display string: 'Line 14'): Specifies which physical line (or pin) and associated I/O control block to use as external source for the trigger signal.
    - **Line15** (Display string: 'Line 15'): Specifies which physical line (or pin) and associated I/O control block to use as external source for the trigger signal.
    - **Timer3Start** (Display string: 'Timer 3 Start'): Specifies which Timer signal to use as internal source for the trigger.
    - **Timer4Start** (Display string: 'Timer 4 Start'): Specifies which Timer signal to use as internal source for the trigger.
    - **Timer5Start** (Display string: 'Timer 5 Start'): Specifies which Timer signal to use as internal source for the trigger.
    - **Timer6Start** (Display string: 'Timer 6 Start'): Specifies which Timer signal to use as internal source for the trigger.
    - **Timer7Start** (Display string: 'Timer 7 Start'): Specifies which Timer signal to use as internal source for the trigger.
    - **Timer8Start** (Display string: 'Timer 8 Start'): Specifies which Timer signal to use as internal source for the trigger.
    - **Timer9Start** (Display string: 'Timer 9 Start'): Specifies which Timer signal to use as internal source for the trigger.
    - **Timer10Start** (Display string: 'Timer 10 Start'): Specifies which Timer signal to use as internal source for the trigger.
    - **Timer11Start** (Display string: 'Timer 11 Start'): Specifies which Timer signal to use as internal source for the trigger.
    - **Timer12Start** (Display string: 'Timer 12 Start'): Specifies which Timer signal to use as internal source for the trigger.
    - **Timer13Start** (Display string: 'Timer 13 Start'): Specifies which Timer signal to use as internal source for the trigger.
    - **Timer14Start** (Display string: 'Timer 14 Start'): Specifies which Timer signal to use as internal source for the trigger.
    - **Timer15Start** (Display string: 'Timer 15 Start'): Specifies which Timer signal to use as internal source for the trigger.
    - **Timer16Start** (Display string: 'Timer 16 Start')
    - **Timer3End** (Display string: 'Timer 3 End'): Specifies which Timer signal to use as internal source for the trigger.
    - **Timer4End** (Display string: 'Timer 4 End'): Specifies which Timer signal to use as internal source for the trigger.
    - **Timer5End** (Display string: 'Timer 5 End'): Specifies which Timer signal to use as internal source for the trigger.
    - **Timer6End** (Display string: 'Timer 6 End'): Specifies which Timer signal to use as internal source for the trigger.
    - **Timer7End** (Display string: 'Timer 7 End'): Specifies which Timer signal to use as internal source for the trigger.
    - **Timer8End** (Display string: 'Timer 8 End'): Specifies which Timer signal to use as internal source for the trigger.
    - **Timer9End** (Display string: 'Timer 9 End'): Specifies which Timer signal to use as internal source for the trigger.
    - **Timer10End** (Display string: 'Timer 10 End'): Specifies which Timer signal to use as internal source for the trigger.
    - **Timer11End** (Display string: 'Timer 11 End'): Specifies which Timer signal to use as internal source for the trigger.
    - **Timer12End** (Display string: 'Timer 12 End'): Specifies which Timer signal to use as internal source for the trigger.
    - **Timer13End** (Display string: 'Timer 13 End'): Specifies which Timer signal to use as internal source for the trigger.
    - **Timer14End** (Display string: 'Timer 14 End'): Specifies which Timer signal to use as internal source for the trigger.
    - **Timer15End** (Display string: 'Timer 15 End'): Specifies which Timer signal to use as internal source for the trigger.
    - **Timer16End** (Display string: 'Timer 16 End')
    - **Counter3Start** (Display string: 'Counter 3 Start'): Specifies which of the Counter signal to use as internal source for the trigger.
    - **Counter4Start** (Display string: 'Counter 4 Start'): Specifies which of the Counter signal to use as internal source for the trigger.
    - **Counter5Start** (Display string: 'Counter 5 Start'): Specifies which of the Counter signal to use as internal source for the trigger.
    - **Counter6Start** (Display string: 'Counter 6 Start'): Specifies which of the Counter signal to use as internal source for the trigger.
    - **Counter7Start** (Display string: 'Counter 7 Start'): Specifies which of the Counter signal to use as internal source for the trigger.
    - **Counter8Start** (Display string: 'Counter 8 Start'): Specifies which of the Counter signal to use as internal source for the trigger.
    - **Counter9Start** (Display string: 'Counter 9 Start'): Specifies which of the Counter signal to use as internal source for the trigger.
    - **Counter10Start** (Display string: 'Counter 10 Start'): Specifies which of the Counter signal to use as internal source for the trigger.
    - **Counter11Start** (Display string: 'Counter 11 Start'): Specifies which of the Counter signal to use as internal source for the trigger.
    - **Counter12Start** (Display string: 'Counter 12 Start'): Specifies which of the Counter signal to use as internal source for the trigger.
    - **Counter13Start** (Display string: 'Counter 13 Start'): Specifies which of the Counter signal to use as internal source for the trigger.
    - **Counter14Start** (Display string: 'Counter 14 Start'): Specifies which of the Counter signal to use as internal source for the trigger.
    - **Counter15Start** (Display string: 'Counter 15 Start'): Specifies which of the Counter signal to use as internal source for the trigger.
    - **Counter16Start** (Display string: 'Counter 16 Start')
    - **Counter3End** (Display string: 'Counter 3 End'): Specifies which of the Counter signal to use as internal source for the trigger.
    - **Counter4End** (Display string: 'Counter 4 End'): Specifies which of the Counter signal to use as internal source for the trigger.
    - **Counter5End** (Display string: 'Counter 5 End'): Specifies which of the Counter signal to use as internal source for the trigger.
    - **Counter6End** (Display string: 'Counter 6 End'): Specifies which of the Counter signal to use as internal source for the trigger.
    - **Counter7End** (Display string: 'Counter 7 End'): Specifies which of the Counter signal to use as internal source for the trigger.
    - **Counter8End** (Display string: 'Counter 8 End'): Specifies which of the Counter signal to use as internal source for the trigger.
    - **Counter9End** (Display string: 'Counter 9 End'): Specifies which of the Counter signal to use as internal source for the trigger.
    - **Counter10End** (Display string: 'Counter 10 End'): Specifies which of the Counter signal to use as internal source for the trigger.
    - **Counter11End** (Display string: 'Counter 11 End'): Specifies which of the Counter signal to use as internal source for the trigger.
    - **Counter12End** (Display string: 'Counter 12 End'): Specifies which of the Counter signal to use as internal source for the trigger.
    - **Counter13End** (Display string: 'Counter 13 End'): Specifies which of the Counter signal to use as internal source for the trigger.
    - **Counter14End** (Display string: 'Counter 14 End'): Specifies which of the Counter signal to use as internal source for the trigger.
    - **Counter15End** (Display string: 'Counter 15 End'): Specifies which of the Counter signal to use as internal source for the trigger.
    - **Counter16End** (Display string: 'Counter 16 End')
    - **mvLogicGateOR1Output** (Display string: 'mv Logic Gate OR 1 Output')
    - **mvLogicGateOR2Output** (Display string: 'mv Logic Gate OR 2 Output')
    - **mvLogicGateOR3Output** (Display string: 'mv Logic Gate OR 3 Output')
    - **mvLogicGateOR4Output** (Display string: 'mv Logic Gate OR 4 Output')
    - **UserOutput3** (Display string: 'User Output 3'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **UserOutput4** (Display string: 'User Output 4'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **UserOutput5** (Display string: 'User Output 5'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **UserOutput6** (Display string: 'User Output 6'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **UserOutput7** (Display string: 'User Output 7'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **UserOutput8** (Display string: 'User Output 8'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **UserOutput9** (Display string: 'User Output 9'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **UserOutput10** (Display string: 'User Output 10'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **UserOutput11** (Display string: 'User Output 11'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **UserOutput12** (Display string: 'User Output 12'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **UserOutput13** (Display string: 'User Output 13'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **UserOutput14** (Display string: 'User Output 14'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **UserOutput15** (Display string: 'User Output 15'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **Action3** (Display string: 'Action 3'): Specifies which Action command to use as internal source for the trigger.
    - **Action4** (Display string: 'Action 4'): Specifies which Action command to use as internal source for the trigger.
    - **Action5** (Display string: 'Action 5'): Specifies which Action command to use as internal source for the trigger.
    - **Action6** (Display string: 'Action 6'): Specifies which Action command to use as internal source for the trigger.
    - **Action7** (Display string: 'Action 7'): Specifies which Action command to use as internal source for the trigger.
    - **Action8** (Display string: 'Action 8'): Specifies which Action command to use as internal source for the trigger.
    - **Action9** (Display string: 'Action 9'): Specifies which Action command to use as internal source for the trigger.
    - **Action10** (Display string: 'Action 10'): Specifies which Action command to use as internal source for the trigger.
    - **Action11** (Display string: 'Action 11'): Specifies which Action command to use as internal source for the trigger.
    - **Action12** (Display string: 'Action 12'): Specifies which Action command to use as internal source for the trigger.
    - **Action13** (Display string: 'Action 13'): Specifies which Action command to use as internal source for the trigger.
    - **Action14** (Display string: 'Action 14'): Specifies which Action command to use as internal source for the trigger.
    - **Action15** (Display string: 'Action 15'): Specifies which Action command to use as internal source for the trigger.
    - **Action16** (Display string: 'Action 16')
    - **CC5** (Display string: 'CC 5'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink products only.
    - **CC6** (Display string: 'CC 6'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink products only.
    - **CC7** (Display string: 'CC 7'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink products only.
    - **CC8** (Display string: 'CC 8'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink products only.
    - **CC9** (Display string: 'CC 9'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink products only.
    - **CC10** (Display string: 'CC 10'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink products only.
    - **CC11** (Display string: 'CC 11'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink products only.
    - **CC12** (Display string: 'CC 12'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink products only.
    - **CC13** (Display string: 'CC 13'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink products only.
    - **CC14** (Display string: 'CC 14'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink products only.
    - **CC15** (Display string: 'CC 15'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink products only.
    - **CC16** (Display string: 'CC 16')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    triggerActivation = property(lib_mvIMPACT_acquire.AcquisitionControl_triggerActivation_get, doc=r"""
    An enumerated integer property. Specifies the activation mode of the trigger.
    Specifies the activation mode of the trigger.

    The following string values might be valid for this feature:
    - **RisingEdge** (Display string: 'Rising Edge'): Specifies that the trigger is considered valid on the rising edge of the source signal.
    - **FallingEdge** (Display string: 'Falling Edge'): Specifies that the trigger is considered valid on the falling edge of the source signal.
    - **AnyEdge** (Display string: 'Any Edge'): Specifies that the trigger is considered valid on the falling or rising edge of the source signal.
    - **LevelHigh** (Display string: 'Level High'): Specifies that the trigger is considered valid as long as the level of the source signal is high.
    - **LevelLow** (Display string: 'Level Low'): Specifies that the trigger is considered valid as long as the level of the source signal is low.
    - **mvNone** (Display string: 'mv None')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    triggerOverlap = property(lib_mvIMPACT_acquire.AcquisitionControl_triggerOverlap_get, doc=r"""
    An enumerated integer property. Specifies the type trigger overlap permitted with the previous frame or line.
    Specifies the type trigger overlap permitted with the previous frame or line. This defines when a valid trigger will be accepted (or latched) for a new frame or a new line.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off'): No trigger overlap is permitted.
    - **ReadOut** (Display string: 'Read Out'): Trigger is accepted immediately after the exposure period.
    - **PreviousFrame** (Display string: 'Previous Frame'): Trigger is accepted (latched) at any time during the capture of the previous frame.
    - **PreviousLine** (Display string: 'Previous Line'): Trigger is accepted (latched) at any time during the capture of the previous line.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    triggerDelay = property(lib_mvIMPACT_acquire.AcquisitionControl_triggerDelay_get, doc=r"""
    A floating point property. Specifies the delay in microseconds (us) to apply after the trigger reception before activating it.
    Specifies the delay in microseconds (us) to apply after the trigger reception before activating it.
    """)
    triggerDivider = property(lib_mvIMPACT_acquire.AcquisitionControl_triggerDivider_get, doc=r"""
    An integer property. Specifies a division factor for the incoming trigger pulses.
    Specifies a division factor for the incoming trigger pulses.
    """)
    triggerMultiplier = property(lib_mvIMPACT_acquire.AcquisitionControl_triggerMultiplier_get, doc=r"""
    An integer property. Specifies a multiplication factor for the incoming trigger pulses.
    Specifies a multiplication factor for the incoming trigger pulses. It is generally used in conjunction with TriggerDivider to control the ratio of triggers that are accepted.
    """)
    exposureMode = property(lib_mvIMPACT_acquire.AcquisitionControl_exposureMode_get, doc=r"""
    An enumerated integer property. Sets the operation mode of the Exposure.
    Sets the operation mode of the Exposure.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off'): Disables the Exposure and let the shutter open.
    - **Timed** (Display string: 'Timed'): Timed exposure. The exposure duration time is set using the ExposureTime or ExposureAuto features and the exposure starts with the FrameStart or LineStart.
    - **TriggerWidth** (Display string: 'Trigger Width'): Uses the width of the current Frame or Line trigger signal(s) pulse to control the exposure duration. Note that if the Frame or Line TriggerActivation is RisingEdge or LevelHigh, the exposure duration will be the time the trigger stays High. If TriggerActivation is FallingEdge or LevelLow, the exposure time will last as long as the trigger stays Low.
    - **TriggerControlled** (Display string: 'Trigger Controlled'): Uses one or more trigger signal(s) to control the exposure duration independently from the current Frame or Line triggers. See ExposureStart, ExposureEnd and ExposureActive of the TriggerSelector feature.
    - **mvMultiZone** (Display string: 'mv Multi Zone'): The exposure duration time can be configured individually for different zones within the image by setting the 'ExposureTimeSelector' to one of the 'mvHorizontalZone' values. This mode will only have effect on the image when operating the device in a 'mvMultiAreaMode' different from 'mvOff'.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    exposureTimeMode = property(lib_mvIMPACT_acquire.AcquisitionControl_exposureTimeMode_get, doc=r"""
    An enumerated integer property. Sets the configuration mode of the ExposureTime feature.
    Sets the configuration mode of the ExposureTime feature.

    The following string values might be valid for this feature:
    - **Common** (Display string: 'Common'): The exposure time is common to all the color components. The common ExposureTime value to use can be set selecting it with ExposureTimeSelector[Common].
    - **Individual** (Display string: 'Individual'): The exposure time is individual for each color component. Each individual ExposureTime values to use can be set by selecting them with ExposureTimeSelector.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    exposureTimeSelector = property(lib_mvIMPACT_acquire.AcquisitionControl_exposureTimeSelector_get, doc=r"""
    An enumerated integer property. Selects which exposure time is controlled by the ExposureTime feature.
    Selects which exposure time is controlled by the ExposureTime feature. This allows for independent control over the exposure components.

    The following string values might be valid for this feature:
    - **Common** (Display string: 'Common'): Selects the common ExposureTime.
    - **Red** (Display string: 'Red'): Selects the red common ExposureTime.
    - **Green** (Display string: 'Green'): Selects the green ExposureTime.
    - **Blue** (Display string: 'Blue'): Selects the blue ExposureTime.
    - **Cyan** (Display string: 'Cyan'): Selects the cyan common ExposureTime.
    - **Magenta** (Display string: 'Magenta'): Selects the magenta ExposureTime.
    - **Yellow** (Display string: 'Yellow'): Selects the yellow ExposureTime.
    - **Infrared** (Display string: 'Infrared'): Selects the infrared ExposureTime.
    - **Ultraviolet** (Display string: 'Ultraviolet'): Selects the ultraviolet ExposureTime.
    - **Stage1** (Display string: 'Stage 1'): Selects the first stage ExposureTime.
    - **Stage2** (Display string: 'Stage 2'): Selects the second stage ExposureTime.
    - **Stage**#3# (Display string: 'Stage #3#'): Selects the second stage ExposureTime.
    - **mvHorizontalZone0** (Display string: 'mv Horizontal Zone 0'): Selects the first horizontal exposure zone used when 'ExposureMode' is set to 'mvMultiZone' and when operating the device in a 'mvMultiAreaMode' different from 'mvOff'.
    - **mvHorizontalZone1** (Display string: 'mv Horizontal Zone 1'): Selects the second horizontal exposure zone used when 'ExposureMode' is set to 'mvMultiZone' and when operating the device in a 'mvMultiAreaMode' different from 'mvOff'.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    exposureTime = property(lib_mvIMPACT_acquire.AcquisitionControl_exposureTime_get, doc=r"""
    A floating point property. Sets the Exposure time when ExposureMode is Timed and ExposureAuto is Off.
    Sets the Exposure time when ExposureMode is Timed and ExposureAuto is Off. This controls the duration where the photosensitive cells are exposed to light.
    """)
    mvExposureHorizontalZoneDivider = property(lib_mvIMPACT_acquire.AcquisitionControl_mvExposureHorizontalZoneDivider_get, doc=r"""
    A floating point property. Defines the position(in percent of the total number of lines) within the image to switch from one exposure time to the next.
    Defines the position(in percent of the total number of lines) within the image to switch from one exposure time to the next. 100% means that only one zone exists. 25% means that the upper 25% of the image are defined by the exposure time of 'mvHorizontalZone0' and the lower 75% are defined by the exposure time of 'mvHorizontalZone1'.
    """)
    exposureAuto = property(lib_mvIMPACT_acquire.AcquisitionControl_exposureAuto_get, doc=r"""
    An enumerated integer property. Sets the automatic exposure mode when ExposureMode is Timed.
    Sets the automatic exposure mode when ExposureMode is Timed. The exact algorithm used to implement this control is device-specific.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off'): Exposure duration is user controlled using ExposureTime.
    - **Once** (Display string: 'Once'): Exposure duration is adapted once by the device. Once it has converged, it returns to the Off state.
    - **Continuous** (Display string: 'Continuous'): Exposure duration is constantly adapted by the device to maximize the dynamic range.
    - **mvSequenced** (Display string: 'mv Sequenced')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    multiSlopeMode = property(lib_mvIMPACT_acquire.AcquisitionControl_multiSlopeMode_get, doc=r"""
    An enumerated integer property. Controls multi-slope exposure state.
    Controls multi-slope exposure state.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off'): Off
    - **Manual** (Display string: 'Manual'): Manual
    - **PresetSoft** (Display string: 'Preset Soft'): Preset Soft
    - **PresetMedium** (Display string: 'Preset Medium'): Preset Medium
    - **PresetAggressive** (Display string: 'Preset Aggressive'): Preset Aggressive

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    multiSlopeKneePointCount = property(lib_mvIMPACT_acquire.AcquisitionControl_multiSlopeKneePointCount_get, doc=r"""
    An integer property. The number of knee-points as well as the number of additional exposure slopes used for multi-slope exposure.
    The number of knee-points as well as the number of additional exposure slopes used for multi-slope exposure.
    """)
    multiSlopeKneePointSelector = property(lib_mvIMPACT_acquire.AcquisitionControl_multiSlopeKneePointSelector_get, doc=r"""
    An integer property. Selects the parameters for controlling an additional slope in multi-slope exposure.
    Selects the parameters for controlling an additional slope in multi-slope exposure.
    """)
    multiSlopeExposureLimit = property(lib_mvIMPACT_acquire.AcquisitionControl_multiSlopeExposureLimit_get, doc=r"""
    A floating point property. Percent of the ExposureTime at a certain knee-point of multi-slope exposure.
    Percent of the ExposureTime at a certain knee-point of multi-slope exposure.
    """)
    multiSlopeSaturationThreshold = property(lib_mvIMPACT_acquire.AcquisitionControl_multiSlopeSaturationThreshold_get, doc=r"""
    A floating point property. The percentage of the full saturation that is applied at a certain knee-point of a multi-slope exposure.
    The percentage of the full saturation that is applied at a certain knee-point of a multi-slope exposure.
    """)
    multiSlopeIntensityLimit = property(lib_mvIMPACT_acquire.AcquisitionControl_multiSlopeIntensityLimit_get, doc=r"""
    A floating point property. The relative intensity which divides intensities influenced by different exposure slopes.
    The relative intensity which divides intensities influenced by different exposure slopes.
    """)
    multiSlopeExposureGradient = property(lib_mvIMPACT_acquire.AcquisitionControl_multiSlopeExposureGradient_get, doc=r"""
    A floating point property. The gradient of the additional slope that is defined by this knee-point.
    The gradient of the additional slope that is defined by this knee-point.
    """)
    mvAcquisitionFrameRateLimitMode = property(lib_mvIMPACT_acquire.AcquisitionControl_mvAcquisitionFrameRateLimitMode_get, doc=r"""
    An enumerated integer property. Controls the calculation of the maximum frame rate.
    Controls the calculation of the maximum frame rate.

    The following string values might be valid for this feature:
    - **mvDeviceLinkThroughput** (Display string: 'mv Device Link Throughput'): Uses the highest possible frame rate depending on bandwidth and sensor settings.
    - **mvDeviceMaxSensorThroughput** (Display string: 'mv Device Max Sensor Throughput'): Maximum frame rate the sensor can provide depending on AOI and pixel clock. Note: Images might be buffered in the cameras memory. This can result in delayed images.
    - **mvLegacy** (Display string: 'mv Legacy'): Compatibility mode, not recommended.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvAcquisitionFrameRateEnable = property(lib_mvIMPACT_acquire.AcquisitionControl_mvAcquisitionFrameRateEnable_get, doc=r"""
    An enumerated integer property. Enables the use of the 'AcquisitionFrameRate' feature.
    Enables the use of the 'AcquisitionFrameRate' feature.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off'): The acquisition frame rate is set automatically to the limit, calculated according to 'mvAcquisitionFrameRateLimitMode' feature.
    - **On** (Display string: 'On'): The acquisition frame rate is set by the 'AcquisitionFrameRate' feature.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvResultingFrameRate = property(lib_mvIMPACT_acquire.AcquisitionControl_mvResultingFrameRate_get, doc=r"""
    A floating point property. Shows the resulting frame rate.
    Shows the resulting frame rate.
    """)
    mvShutterMode = property(lib_mvIMPACT_acquire.AcquisitionControl_mvShutterMode_get, doc=r"""
    An enumerated integer property. Selects the shutter mode of the sensor.
    Selects the shutter mode of the sensor.

    The following string values might be valid for this feature:
    - **mvRollingShutter** (Display string: 'mv Rolling Shutter')
    - **mvGlobalReset** (Display string: 'mv Global Reset')
    - **mvGlobalShutter** (Display string: 'mv Global Shutter')
    - **mvGlobalShutterWithoutReset** (Display string: 'mv Global Shutter Without Reset')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvCompressionKneepoint = property(lib_mvIMPACT_acquire.AcquisitionControl_mvCompressionKneepoint_get, doc=r"""
    An integer property. Knee point of 10 to 8 bit compression.
    Knee point of 10 to 8 bit compression.
    """)
    mvExposureAutoLowerLimit = property(lib_mvIMPACT_acquire.AcquisitionControl_mvExposureAutoLowerLimit_get, doc=r"""
    A floating point property. The lower limit of the exposure time in auto exposure mode.
    The lower limit of the exposure time in auto exposure mode.
    """)
    mvExposureAutoUpperLimit = property(lib_mvIMPACT_acquire.AcquisitionControl_mvExposureAutoUpperLimit_get, doc=r"""
    A floating point property. The upper limit of the exposure time in auto exposure mode.
    The upper limit of the exposure time in auto exposure mode.
    """)
    mvExposureAutoSpeed = property(lib_mvIMPACT_acquire.AcquisitionControl_mvExposureAutoSpeed_get, doc=r"""
    An enumerated integer property. Determines the increment or decrement size of exposure value from frame to frame.
    Determines the increment or decrement size of exposure value from frame to frame.

    The following string values might be valid for this feature:
    - **Slow** (Display string: 'Slow')
    - **Medium** (Display string: 'Medium')
    - **Fast** (Display string: 'Fast')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvExposureAutoDelayImages = property(lib_mvIMPACT_acquire.AcquisitionControl_mvExposureAutoDelayImages_get, doc=r"""
    An integer property. The number of frames that the AEC must skip before updating the exposure register.
    The number of frames that the AEC must skip before updating the exposure register.
    """)
    mvExposureAutoAverageGrey = property(lib_mvIMPACT_acquire.AcquisitionControl_mvExposureAutoAverageGrey_get, doc=r"""
    An integer property. Common desired average grey value (in percent) used for Auto Gain Control(AGC) and Auto Exposure Control(AEC).
    Common desired average grey value (in percent) used for auto gain control(AGC) and auto exposure control (AEC).
    """)
    mvExposureAutoHighlightAOI = property(lib_mvIMPACT_acquire.AcquisitionControl_mvExposureAutoHighlightAOI_get, doc=r"""
    An enumerated integer property. Highlight auto control AOI to check AOI settings. Switch off for normal operation.
    Highlight auto control AOI to check AOI settings. Switch off for normal operation.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off')
    - **On** (Display string: 'On')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvExposureAutoAOIMode = property(lib_mvIMPACT_acquire.AcquisitionControl_mvExposureAutoAOIMode_get, doc=r"""
    An enumerated integer property. Common AutoControl AOI used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).
    Common AutoControl AOI used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).

    The following string values might be valid for this feature:
    - **mvFull** (Display string: 'mv Full')
    - **mvCenter** (Display string: 'mv Center')
    - **mvUser** (Display string: 'mv User')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvExposureAutoOffsetX = property(lib_mvIMPACT_acquire.AcquisitionControl_mvExposureAutoOffsetX_get, doc=r"""
    An integer property. Common AOI XOffset used for auto gain control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).
    Common AOI XOffset used for auto gain control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).
    """)
    mvExposureAutoOffsetY = property(lib_mvIMPACT_acquire.AcquisitionControl_mvExposureAutoOffsetY_get, doc=r"""
    An integer property. Common AOI YOffset used for auto gain control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).
    Common AOI YOffset used for auto gain control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).
    """)
    mvExposureAutoWidth = property(lib_mvIMPACT_acquire.AcquisitionControl_mvExposureAutoWidth_get, doc=r"""
    An integer property. Common AOI Width used for auto gain control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).
    Common AOI Width used for auto gain control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).
    """)
    mvExposureAutoHeight = property(lib_mvIMPACT_acquire.AcquisitionControl_mvExposureAutoHeight_get, doc=r"""
    An integer property. Common AOI Height used for auto gain control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).
    Common AOI Height used for auto gain control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).
    """)
    mvExposureAutoMode = property(lib_mvIMPACT_acquire.AcquisitionControl_mvExposureAutoMode_get, doc=r"""
    An enumerated integer property. Selects the common auto mode for gain and exposure.
    Selects the common auto mode for gain and exposure.

    The following string values might be valid for this feature:
    - **mvSensor** (Display string: 'mv Sensor'): The sensor itself will do the auto control.
    - **mvDevice** (Display string: 'mv Device'): The device(firmware) will do the auto control.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvSmearReduction = property(lib_mvIMPACT_acquire.AcquisitionControl_mvSmearReduction_get, doc=r"""
    An enumerated integer property. Smear reduction in triggered and non-overlapped mode.
    Smear reduction in triggered and non-overlapped mode.

    The following string values might be valid for this feature:
    - **mvStandard** (Display string: 'mv Standard'): Standard smear reduction.
    - **mvMedium** (Display string: 'mv Medium'): Medium smear reduction.
    - **mvHighest** (Display string: 'mv Highest'): Highest smear but more power consumption.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvAcquisitionMemoryMode = property(lib_mvIMPACT_acquire.AcquisitionControl_mvAcquisitionMemoryMode_get, doc=r"""
    An enumerated integer property. mvRecord is used to store frames in memory. mvPlayback transfers stored frames. mvPretrigger stores frames in memory to be transferred after trigger.
    mvRecord is used to store frames in memory. mvPlayback transfers stored frames. mvPretrigger stores frames in memory to be transferred after trigger.

    The following string values might be valid for this feature:
    - **Default** (Display string: 'Default'): Default memory mode.
    - **mvRecord** (Display string: 'mv Record'): Stores frames in memory.
    - **mvPlayback** (Display string: 'mv Playback'): Transfers stored frames.
    - **mvPretrigger** (Display string: 'mv Pretrigger'): Stores frames in memory to be transferred after trigger.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvPretriggerFrameCount = property(lib_mvIMPACT_acquire.AcquisitionControl_mvPretriggerFrameCount_get, doc=r"""
    An integer property. Number of frames to acquire before the occurrence of an AcquisitionStart or AcquisitionActive trigger.
    Number of frames to acquire before the occurrence of an AcquisitionStart or AcquisitionActive trigger.
    """)
    mvAcquisitionMemoryMaxFrameCount = property(lib_mvIMPACT_acquire.AcquisitionControl_mvAcquisitionMemoryMaxFrameCount_get, doc=r"""
    An integer property. Maximum number of frames that can be recorded in the current configuration(deprecated, use the maximum value of 'mvAcquisitionMemoryFrameCount' instead).
    Deprecated: 
    Maximum number of frames that can be recorded in the current configuration(deprecated, use the maximum value of 'mvAcquisitionMemoryFrameCount' instead).
    """)
    mvAcquisitionMemoryFrameCount = property(lib_mvIMPACT_acquire.AcquisitionControl_mvAcquisitionMemoryFrameCount_get, doc=r"""
    An integer property. The number of frames currently stored in the frame buffer.
    The number of frames currently stored in the frame buffer. If this value keeps increasing this can indicate a bandwidth/transmission problem.
    """)
    mvAcquisitionMemoryAOIParameterChanged = property(lib_mvIMPACT_acquire.AcquisitionControl_mvAcquisitionMemoryAOIParameterChanged_get, doc=r"""
    An integer property. AOI and/or binning parameter changed after last Acquisition.
    AOI and/or binning parameter changed after last Acquisition.
    """)
    mvFeatureMode = property(lib_mvIMPACT_acquire.AcquisitionControl_mvFeatureMode_get, doc=r"""
    An enumerated integer property. Enables feature mode.
    Enables feature mode.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off'): No smart feature mode is selected
    - **mvJPEGWithRaw** (Display string: 'mv JPEG With Raw'): When active a binned raw image is sent together with a full resolution JPEG.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvSmartFrameRecallEnable = property(lib_mvIMPACT_acquire.AcquisitionControl_mvSmartFrameRecallEnable_get, doc=r"""
    A boolean property. When active in addition to the processed image data also the unprocessed image is stored inside the devices RAM.
    When active in addition to the processed image data (e.g. after binning, decimation, de-Bayering, LUT etc. applied inside the device) also the unprocessed image is stored inside the devices RAM allowing to request the transmission of these images by an application as well. This will effectively reduce the number of images that can be stored inside the frame buffer.
    """)
    mvSmartFrameRecallTimestampLookupAccuracy = property(lib_mvIMPACT_acquire.AcquisitionControl_mvSmartFrameRecallTimestampLookupAccuracy_get, doc=r"""
    An integer property. This value defines the strictness of the timestamp-check for the recalled image (given in us).
    This value defines the strictness of the timestamp-check for the recalled image (given in us).
    """)
    mvSmartFrameRecallFrameSkipRatio = property(lib_mvIMPACT_acquire.AcquisitionControl_mvSmartFrameRecallFrameSkipRatio_get, doc=r"""
    An integer property. When set to a value != 0, the smaller frames get thinned out. AOI requests can still be done for all frames.
    The number of processed images to drop, i.e. skip. This can be used to reduce the frame rate even further. AOIs for unsent images can still be requested - the timestamps for these dropped images must be interpolated.
    """)
    mvLensCalibrationEnable = property(lib_mvIMPACT_acquire.AcquisitionControl_mvLensCalibrationEnable_get, doc=r"""
    A boolean property. Enables or disables lens calibration.
    When active lens calibration will be applied to the image. The calibration data must have been correctly calculated for the scene and loaded into device memory using, for example, the file interface with filename 'mvLensCalibrationBlocks' and 'mvLensCalibrationPixels'. This will effectively reduce the number of images that can be stored inside the frame buffer.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_AcquisitionControl

# Register AcquisitionControl in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.AcquisitionControl_swigregister(AcquisitionControl)

class AnalogControl(object):
    r"""
    Category that contains the Analog control features.
    A category that contains the Analog control features.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::GenICam::AnalogControl** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.AnalogControl_swiginit(self, lib_mvIMPACT_acquire.new_AnalogControl(*args))
    mvTapBalancingMode = property(lib_mvIMPACT_acquire.AnalogControl_mvTapBalancingMode_get, doc=r"""
    An enumerated integer property. Where do the tap balancing calibration data come from?
    Where do the tap balancing calibration data come from?

    The following string values might be valid for this feature:
    - **mvFactory** (Display string: 'mv Factory')
    - **mvUser** (Display string: 'mv User')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvGainMode = property(lib_mvIMPACT_acquire.AnalogControl_mvGainMode_get, doc=r"""
    An enumerated integer property. Sets the operation mode of Gain.
    Sets the operation mode of Gain

    The following string values might be valid for this feature:
    - **Default** (Display string: 'Default'): Default operation mode. The whole image is configured as a single zone.
    - **mvMultiZone** (Display string: 'mv Multi Zone'): In this mode different gains can be applied to different zones of the image by writing them into the 'mvHorizontalZone' registers selectable via the 'GainSelector'. This mode will only have effect on the image when operating the device in a 'mvMultiAreaMode' different from 'mvOff'.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    gainSelector = property(lib_mvIMPACT_acquire.AnalogControl_gainSelector_get, doc=r"""
    An enumerated integer property. Selects which Gain is controlled by the various Gain features.
    Selects which Gain is controlled by the various Gain features.

    The following string values might be valid for this feature:
    - **All** (Display string: 'All'): Gain will be applied to all channels or taps.
    - **Red** (Display string: 'Red'): Gain will be applied to the red channel.
    - **Green** (Display string: 'Green'): Gain will be applied to the green channel.
    - **Blue** (Display string: 'Blue'): Gain will be applied to the blue channel.
    - **Y** (Display string: 'Y'): Gain will be applied to Y channel.
    - **U** (Display string: 'U'): Gain will be applied to U channel.
    - **V** (Display string: 'V'): Gain will be applied to V channel.
    - **Tap1** (Display string: 'Tap 1'): Gain will be applied to Tap 1.
    - **Tap2** (Display string: 'Tap 2'): Gain will be applied to Tap 2.
    - **Tap**#3# (Display string: 'Tap #3#'): Gain will be applied to Tap #3#.
    - **AnalogAll** (Display string: 'Analog All'): Gain will be applied to all analog channels or taps.
    - **AnalogRed** (Display string: 'Analog Red'): Gain will be applied to the red analog channel.
    - **AnalogGreen** (Display string: 'Analog Green'): Gain will be applied to the green analog channel.
    - **AnalogBlue** (Display string: 'Analog Blue'): Gain will be applied to the blue analog channel.
    - **AnalogY** (Display string: 'Analog Y'): Gain will be applied to Y analog channel.
    - **AnalogU** (Display string: 'Analog U'): Gain will be applied to U analog channel.
    - **AnalogV** (Display string: 'Analog V'): Gain will be applied to V analog channel.
    - **AnalogTap1** (Display string: 'Analog Tap 1'): Analog gain will be applied to Tap 1.
    - **AnalogTap2** (Display string: 'Analog Tap 2'): Analog gain will be applied to Tap 2.
    - **AnalogTap**#3# (Display string: 'Analog Tap #3#'): Analog gain will be applied to Tap #3#.
    - **DigitalAll** (Display string: 'Digital All'): Gain will be applied to all digital channels or taps.
    - **DigitalRed** (Display string: 'Digital Red'): Gain will be applied to the red digital channel.
    - **DigitalGreen** (Display string: 'Digital Green'): Gain will be applied to the green digital channel.
    - **DigitalBlue** (Display string: 'Digital Blue'): Gain will be applied to the blue digital channel.
    - **DigitalY** (Display string: 'Digital Y'): Gain will be applied to Y digital channel.
    - **DigitalU** (Display string: 'Digital U'): Gain will be applied to U digital channel.
    - **DigitalV** (Display string: 'Digital V'): Gain will be applied to V digital channel.
    - **DigitalTap1** (Display string: 'Digital Tap 1'): Digital gain will be applied to Tap 1.
    - **DigitalTap2** (Display string: 'Digital Tap 2'): Digital gain will be applied to Tap 2.
    - **DigitalTap**#3# (Display string: 'Digital Tap #3#'): Digital gain will be applied to Tap #3#.
    - **Tap3** (Display string: 'Tap 3'): Gain will be applied to Tap 3.
    - **Tap4** (Display string: 'Tap 4'): Gain will be applied to Tap 4.
    - **Tap5** (Display string: 'Tap 5'): Gain will be applied to Tap 5.
    - **Tap6** (Display string: 'Tap 6'): Gain will be applied to Tap 6.
    - **Tap7** (Display string: 'Tap 7'): Gain will be applied to Tap 7.
    - **Tap8** (Display string: 'Tap 8'): Gain will be applied to Tap 8.
    - **Tap9** (Display string: 'Tap 9'): Gain will be applied to Tap 9.
    - **Tap10** (Display string: 'Tap 10'): Gain will be applied to Tap 10.
    - **Tap11** (Display string: 'Tap 11'): Gain will be applied to Tap 11.
    - **Tap12** (Display string: 'Tap 12'): Gain will be applied to Tap 12.
    - **Tap13** (Display string: 'Tap 13'): Gain will be applied to Tap 13.
    - **Tap14** (Display string: 'Tap 14'): Gain will be applied to Tap 14.
    - **Tap15** (Display string: 'Tap 15'): Gain will be applied to Tap 15.
    - **Tap16** (Display string: 'Tap 16')
    - **AnalogTap3** (Display string: 'Analog Tap 3'): Analog gain will be applied to Tap 3.
    - **AnalogTap4** (Display string: 'Analog Tap 4'): Analog gain will be applied to Tap 4.
    - **AnalogTap5** (Display string: 'Analog Tap 5'): Analog gain will be applied to Tap 5.
    - **AnalogTap6** (Display string: 'Analog Tap 6'): Analog gain will be applied to Tap 6.
    - **AnalogTap7** (Display string: 'Analog Tap 7'): Analog gain will be applied to Tap 7.
    - **AnalogTap8** (Display string: 'Analog Tap 8'): Analog gain will be applied to Tap 8.
    - **AnalogTap9** (Display string: 'Analog Tap 9'): Analog gain will be applied to Tap 9.
    - **AnalogTap10** (Display string: 'Analog Tap 10'): Analog gain will be applied to Tap 10.
    - **AnalogTap11** (Display string: 'Analog Tap 11'): Analog gain will be applied to Tap 11.
    - **AnalogTap12** (Display string: 'Analog Tap 12'): Analog gain will be applied to Tap 12.
    - **AnalogTap13** (Display string: 'Analog Tap 13'): Analog gain will be applied to Tap 13.
    - **AnalogTap14** (Display string: 'Analog Tap 14'): Analog gain will be applied to Tap 14.
    - **AnalogTap15** (Display string: 'Analog Tap 15'): Analog gain will be applied to Tap 15.
    - **AnalogTap16** (Display string: 'Analog Tap 16')
    - **DigitalTap3** (Display string: 'Digital Tap 3'): Digital gain will be applied to Tap 3.
    - **DigitalTap4** (Display string: 'Digital Tap 4'): Digital gain will be applied to Tap 4.
    - **DigitalTap5** (Display string: 'Digital Tap 5'): Digital gain will be applied to Tap 5.
    - **DigitalTap6** (Display string: 'Digital Tap 6'): Digital gain will be applied to Tap 6.
    - **DigitalTap7** (Display string: 'Digital Tap 7'): Digital gain will be applied to Tap 7.
    - **DigitalTap8** (Display string: 'Digital Tap 8'): Digital gain will be applied to Tap 8.
    - **DigitalTap9** (Display string: 'Digital Tap 9'): Digital gain will be applied to Tap 9.
    - **DigitalTap10** (Display string: 'Digital Tap 10'): Digital gain will be applied to Tap 10.
    - **DigitalTap11** (Display string: 'Digital Tap 11'): Digital gain will be applied to Tap 11.
    - **DigitalTap12** (Display string: 'Digital Tap 12'): Digital gain will be applied to Tap 12.
    - **DigitalTap13** (Display string: 'Digital Tap 13'): Digital gain will be applied to Tap 13.
    - **DigitalTap14** (Display string: 'Digital Tap 14'): Digital gain will be applied to Tap 14.
    - **DigitalTap15** (Display string: 'Digital Tap 15'): Digital gain will be applied to Tap 15.
    - **DigitalTap16** (Display string: 'Digital Tap 16')
    - **mvAnalogSensorA** (Display string: 'mv Analog Sensor A')
    - **mvAnalogSensorB** (Display string: 'mv Analog Sensor B')
    - **mvHorizontalZone0** (Display string: 'mv Horizontal Zone 0'): Selects the first horizontal gain zone used when 'mvGainMode' is set to 'mvMultiZone' and when operating the device in a 'mvMultiAreaMode' different from 'mvOff'.
    - **mvHorizontalZone1** (Display string: 'mv Horizontal Zone 1'): Selects the second horizontal gain zone used when 'mvGainMode' is set to 'mvMultiZone' and when operating the device in a 'mvMultiAreaMode' different from 'mvOff'.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    gain = property(lib_mvIMPACT_acquire.AnalogControl_gain_get, doc=r"""
    A floating point property. Controls the selected gain as an absolute physical value.
    Controls the selected gain as an absolute physical value. This is an amplification factor applied to the video signal.
    """)
    mvGainHorizontalZoneDivider = property(lib_mvIMPACT_acquire.AnalogControl_mvGainHorizontalZoneDivider_get, doc=r"""
    A floating point property. Defines the position(in percent of the total number of lines) within the image to switch from one gain value to the next.
    Defines the position(in percent of the total number of lines) within the image to switch from one gain value to the next. 100% means that only one zone exists. 25% means that the upper 25% of the image are defined by the gain value of 'mvHorizontalZone0' and the lower 75% are defined by the gain value of 'mvHorizontalZone1'. Some sensors may only allow to change the gain at certain positions e.g. the last line of a defined ROI. In this case the first possible switching point above the actual line will be used.
    """)
    gainAuto = property(lib_mvIMPACT_acquire.AnalogControl_gainAuto_get, doc=r"""
    An enumerated integer property. Sets the automatic gain control (AGC) mode.
    Sets the automatic gain control (AGC) mode. The exact algorithm used to implement AGC is device-specific.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off'): Gain is User controlled using Gain.
    - **Once** (Display string: 'Once'): Gain is automatically adjusted once by the device. Once it has converged, it automatically returns to the Off state.
    - **Continuous** (Display string: 'Continuous'): Gain is constantly adjusted by the device.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    gainAutoBalance = property(lib_mvIMPACT_acquire.AnalogControl_gainAutoBalance_get, doc=r"""
    An enumerated integer property. Sets the mode for automatic gain balancing between the sensor color channels or taps.
    Sets the mode for automatic gain balancing between the sensor color channels or taps. The gain coefficients of each channel or tap are adjusted so they are matched.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off'): Gain tap balancing is user controlled using Gain .
    - **Once** (Display string: 'Once'): Gain tap balancing is automatically adjusted once by the device. Once it has converged, it automatically returns to the Off state.
    - **Continuous** (Display string: 'Continuous'): Gain tap balancing is constantly adjusted by the device.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    blackLevelSelector = property(lib_mvIMPACT_acquire.AnalogControl_blackLevelSelector_get, doc=r"""
    An enumerated integer property. Selects which Black Level is controlled by the various Black Level features.
    Selects which Black Level is controlled by the various Black Level features.

    The following string values might be valid for this feature:
    - **All** (Display string: 'All'): Black Level will be applied to all channels or taps.
    - **Red** (Display string: 'Red'): Black Level will be applied to the red channel.
    - **Green** (Display string: 'Green'): Black Level will be applied to the green channel.
    - **Blue** (Display string: 'Blue'): Black Level will be applied to the blue channel.
    - **Y** (Display string: 'Y'): Black Level will be applied to Y channel.
    - **U** (Display string: 'U'): Black Level will be applied to U channel.
    - **V** (Display string: 'V'): Black Level will be applied to V channel.
    - **Tap1** (Display string: 'Tap 1'): Black Level will be applied to Tap 1.
    - **Tap2** (Display string: 'Tap 2'): Black Level will be applied to Tap 2.
    - **Tap**#3# (Display string: 'Tap #3#'): Black Level will be applied to Tap #3#.
    - **Tap3** (Display string: 'Tap 3'): Black Level will be applied to Tap 3.
    - **Tap4** (Display string: 'Tap 4'): Black Level will be applied to Tap 4.
    - **Tap5** (Display string: 'Tap 5'): Black Level will be applied to Tap 5.
    - **Tap6** (Display string: 'Tap 6'): Black Level will be applied to Tap 6.
    - **Tap7** (Display string: 'Tap 7'): Black Level will be applied to Tap 7.
    - **Tap8** (Display string: 'Tap 8'): Black Level will be applied to Tap 8.
    - **Tap9** (Display string: 'Tap 9'): Black Level will be applied to Tap 9.
    - **Tap10** (Display string: 'Tap 10'): Black Level will be applied to Tap 10.
    - **Tap11** (Display string: 'Tap 11'): Black Level will be applied to Tap 11.
    - **Tap12** (Display string: 'Tap 12'): Black Level will be applied to Tap 12.
    - **Tap13** (Display string: 'Tap 13'): Black Level will be applied to Tap 13.
    - **Tap14** (Display string: 'Tap 14'): Black Level will be applied to Tap 14.
    - **Tap15** (Display string: 'Tap 15'): Black Level will be applied to Tap 15.
    - **Tap16** (Display string: 'Tap 16')
    - **mvAnalogSensorA** (Display string: 'mv Analog Sensor A')
    - **mvAnalogSensorB** (Display string: 'mv Analog Sensor B')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    blackLevel = property(lib_mvIMPACT_acquire.AnalogControl_blackLevel_get, doc=r"""
    A floating point property. Controls the analog black level as an absolute physical value.
    Controls the analog black level as an absolute physical value. This represents a DC offset applied to the video signal.
    """)
    blackLevelAuto = property(lib_mvIMPACT_acquire.AnalogControl_blackLevelAuto_get, doc=r"""
    An enumerated integer property. Controls the mode for automatic black level adjustment.
    Controls the mode for automatic black level adjustment. The exact algorithm used to implement this adjustment is device-specific.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off'): Analog black level is user controlled using BlackLevel.
    - **Once** (Display string: 'Once'): Analog black level is automatically adjusted once by the device. Once it has converged, it automatically returns to the Off state.
    - **Continuous** (Display string: 'Continuous'): Analog black level is constantly adjusted by the device.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    blackLevelAutoBalance = property(lib_mvIMPACT_acquire.AnalogControl_blackLevelAutoBalance_get, doc=r"""
    An enumerated integer property. Controls the mode for automatic black level balancing between the sensor color channels or taps.
    Controls the mode for automatic black level balancing between the sensor color channels or taps. The black level coefficients of each channel are adjusted so they are matched.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off'): Black level tap balancing is user controlled using BlackLevel.
    - **Once** (Display string: 'Once'): Black level tap balancing is automatically adjusted once by the device. Once it has converged, it automatically returns to the Off state.
    - **Continuous** (Display string: 'Continuous'): Black level tap balancing is constantly adjusted by the device.
    - **mvRaw** (Display string: 'mv Raw')
    - **mvFixed** (Display string: 'mv Fixed')
    - **mvLowerLine** (Display string: 'mv Lower Line')
    - **mvSlow** (Display string: 'mv Slow')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    whiteClipSelector = property(lib_mvIMPACT_acquire.AnalogControl_whiteClipSelector_get, doc=r"""
    An enumerated integer property. Selects which White Clip to control.
    Selects which White Clip to control.

    The following string values might be valid for this feature:
    - **All** (Display string: 'All'): White Clip will be applied to all channels or taps.
    - **Red** (Display string: 'Red'): White Clip will be applied to the red channel.
    - **Green** (Display string: 'Green'): White Clip will be applied to the green channel.
    - **Blue** (Display string: 'Blue'): White Clip will be applied to the blue channel.
    - **Y** (Display string: 'Y'): White Clip will be applied to Y channel.
    - **U** (Display string: 'U'): White Clip will be applied to U channel.
    - **V** (Display string: 'V'): White Clip will be applied to V channel.
    - **Tap1** (Display string: 'Tap 1'): White Clip will be applied to Tap 1.
    - **Tap2** (Display string: 'Tap 2'): White Clip will be applied to Tap 2.
    - **Tap**#3# (Display string: 'Tap #3#'): White Clip will be applied to Tap #3#.
    - **Tap3** (Display string: 'Tap 3'): White Clip will be applied to Tap 3.
    - **Tap4** (Display string: 'Tap 4'): White Clip will be applied to Tap 4.
    - **Tap5** (Display string: 'Tap 5'): White Clip will be applied to Tap 5.
    - **Tap6** (Display string: 'Tap 6'): White Clip will be applied to Tap 6.
    - **Tap7** (Display string: 'Tap 7'): White Clip will be applied to Tap 7.
    - **Tap8** (Display string: 'Tap 8'): White Clip will be applied to Tap 8.
    - **Tap9** (Display string: 'Tap 9'): White Clip will be applied to Tap 9.
    - **Tap10** (Display string: 'Tap 10'): White Clip will be applied to Tap 10.
    - **Tap11** (Display string: 'Tap 11'): White Clip will be applied to Tap 11.
    - **Tap12** (Display string: 'Tap 12'): White Clip will be applied to Tap 12.
    - **Tap13** (Display string: 'Tap 13'): White Clip will be applied to Tap 13.
    - **Tap14** (Display string: 'Tap 14'): White Clip will be applied to Tap 14.
    - **Tap15** (Display string: 'Tap 15'): White Clip will be applied to Tap 15.
    - **Tap16** (Display string: 'Tap 16')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    whiteClip = property(lib_mvIMPACT_acquire.AnalogControl_whiteClip_get, doc=r"""
    A floating point property. Controls the maximal intensity taken by the video signal before being clipped as an absolute physical value.
    Controls the maximal intensity taken by the video signal before being clipped as an absolute physical value. The video signal will never exceed the white clipping point: it will saturate at that level.
    """)
    balanceRatioSelector = property(lib_mvIMPACT_acquire.AnalogControl_balanceRatioSelector_get, doc=r"""
    An enumerated integer property. Selects which Balance ratio to control.
    Selects which Balance ratio to control.

    The following string values might be valid for this feature:
    - **All** (Display string: 'All'): Balance Ratio will be applied to all channels or taps.
    - **Red** (Display string: 'Red'): Balance Ratio will be applied to the red channel.
    - **Green** (Display string: 'Green'): Balance Ratio will be applied to the green channel.
    - **Blue** (Display string: 'Blue'): Balance Ratio will be applied to the blue channel.
    - **Y** (Display string: 'Y'): Balance Ratio will be applied to Y channel.
    - **U** (Display string: 'U'): Balance Ratio will be applied to U channel.
    - **V** (Display string: 'V'): Balance Ratio will be applied to V channel.
    - **Tap1** (Display string: 'Tap 1'): Balance Ratio will be applied to Tap 1.
    - **Tap2** (Display string: 'Tap 2'): Balance Ratio will be applied to Tap 2.
    - **Tap**#3# (Display string: 'Tap #3#'): Balance Ratio will be applied to Tap #3#.
    - **Green0** (Display string: 'Green 0')
    - **Green1** (Display string: 'Green 1')
    - **Tap3** (Display string: 'Tap 3'): Balance Ratio will be applied to Tap 3.
    - **Tap4** (Display string: 'Tap 4'): Balance Ratio will be applied to Tap 4.
    - **Tap5** (Display string: 'Tap 5'): Balance Ratio will be applied to Tap 5.
    - **Tap6** (Display string: 'Tap 6'): Balance Ratio will be applied to Tap 6.
    - **Tap7** (Display string: 'Tap 7'): Balance Ratio will be applied to Tap 7.
    - **Tap8** (Display string: 'Tap 8'): Balance Ratio will be applied to Tap 8.
    - **Tap9** (Display string: 'Tap 9'): Balance Ratio will be applied to Tap 9.
    - **Tap10** (Display string: 'Tap 10'): Balance Ratio will be applied to Tap 10.
    - **Tap11** (Display string: 'Tap 11'): Balance Ratio will be applied to Tap 11.
    - **Tap12** (Display string: 'Tap 12'): Balance Ratio will be applied to Tap 12.
    - **Tap13** (Display string: 'Tap 13'): Balance Ratio will be applied to Tap 13.
    - **Tap14** (Display string: 'Tap 14'): Balance Ratio will be applied to Tap 14.
    - **Tap15** (Display string: 'Tap 15'): Balance Ratio will be applied to Tap 15.
    - **Tap16** (Display string: 'Tap 16')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    balanceRatio = property(lib_mvIMPACT_acquire.AnalogControl_balanceRatio_get, doc=r"""
    A floating point property. Controls ratio of the selected color component to a reference color component.
    Controls ratio of the selected color component to a reference color component. It is used for white balancing.
    """)
    balanceWhiteAuto = property(lib_mvIMPACT_acquire.AnalogControl_balanceWhiteAuto_get, doc=r"""
    An enumerated integer property. Controls the mode for automatic white balancing between the color channels.
    Controls the mode for automatic white balancing between the color channels. The white balancing ratios are automatically adjusted.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off'): White balancing is user controlled using BalanceRatioSelector and BalanceRatio.
    - **Once** (Display string: 'Once'): White balancing is automatically adjusted once by the device. Once it has converged, it automatically returns to the Off state.
    - **Continuous** (Display string: 'Continuous'): White balancing is constantly adjusted by the device.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvGainAutoDelayImages = property(lib_mvIMPACT_acquire.AnalogControl_mvGainAutoDelayImages_get, doc=r"""
    An integer property. The number of frames that the AEC must skip before updating the exposure register
    The number of frames that the AEC must skip before updating the exposure register
    """)
    mvGainAutoUpperLimit = property(lib_mvIMPACT_acquire.AnalogControl_mvGainAutoUpperLimit_get, doc=r"""
    A floating point property. The upper limit of the gain in auto gain mode
    The upper limit of the gain in auto gain mode
    """)
    mvGainAutoLowerLimit = property(lib_mvIMPACT_acquire.AnalogControl_mvGainAutoLowerLimit_get, doc=r"""
    A floating point property. The lower limit of the gain in auto gain mode
    The lower limit of the gain in auto gain mode
    """)
    mvGainAutoSpeed = property(lib_mvIMPACT_acquire.AnalogControl_mvGainAutoSpeed_get, doc=r"""
    An enumerated integer property. Determines the increment or decrement size of gain value from frame to frame.
    Determines the increment or decrement size of gain value from frame to frame.

    The following string values might be valid for this feature:
    - **Slow** (Display string: 'Slow')
    - **Medium** (Display string: 'Medium')
    - **Fast** (Display string: 'Fast')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvGainAutoAverageGrey = property(lib_mvIMPACT_acquire.AnalogControl_mvGainAutoAverageGrey_get, doc=r"""
    An integer property. Common desired average grey value (in percent) used for Auto Gain Control(AGC) and Auto Exposure Control(AEC).
    Common desired average grey value (in percent) used for Auto Gain Control(AGC) and Auto Exposure Control(AEC).
    """)
    mvGainAutoHighlightAOI = property(lib_mvIMPACT_acquire.AnalogControl_mvGainAutoHighlightAOI_get, doc=r"""
    An enumerated integer property. Highlight auto control AOI to check AOI settings. Switch off for normal operation.
    Highlight auto control AOI to check AOI settings. Switch off for normal operation.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off')
    - **On** (Display string: 'On')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvGainAutoAOIMode = property(lib_mvIMPACT_acquire.AnalogControl_mvGainAutoAOIMode_get, doc=r"""
    An enumerated integer property. Common AutoControl AOI used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balancing.
    Common AutoControl AOI used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balancing.

    The following string values might be valid for this feature:
    - **mvFull** (Display string: 'mv Full')
    - **mvCenter** (Display string: 'mv Center')
    - **mvUser** (Display string: 'mv User')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvGainAutoOffsetX = property(lib_mvIMPACT_acquire.AnalogControl_mvGainAutoOffsetX_get, doc=r"""
    An integer property. Common AOI X-Offset used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).
    Common AOI X-Offset used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).
    """)
    mvGainAutoOffsetY = property(lib_mvIMPACT_acquire.AnalogControl_mvGainAutoOffsetY_get, doc=r"""
    An integer property. Common AOI Y-Offset used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).
    Common AOI Y-Offset used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).
    """)
    mvGainAutoWidth = property(lib_mvIMPACT_acquire.AnalogControl_mvGainAutoWidth_get, doc=r"""
    An integer property. Common AOI Width used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).
    Common AOI Width used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).
    """)
    mvGainAutoHeight = property(lib_mvIMPACT_acquire.AnalogControl_mvGainAutoHeight_get, doc=r"""
    An integer property. Common AOI Height used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).
    Common AOI Height used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).
    """)
    mvGainAutoMode = property(lib_mvIMPACT_acquire.AnalogControl_mvGainAutoMode_get, doc=r"""
    An enumerated integer property. Selects the common auto mode for gain and exposure.
    Selects the common auto mode for gain and exposure.

    The following string values might be valid for this feature:
    - **mvSensor** (Display string: 'mv Sensor'): The sensor itself will do the auto control.
    - **mvDevice** (Display string: 'mv Device'): The device(firmware) will do the auto control.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvBalanceWhiteAutoAOIMode = property(lib_mvIMPACT_acquire.AnalogControl_mvBalanceWhiteAutoAOIMode_get, doc=r"""
    An enumerated integer property. Common AutoControl AOI used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).
    Common AutoControl AOI used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).

    The following string values might be valid for this feature:
    - **mvFull** (Display string: 'mv Full')
    - **mvCenter** (Display string: 'mv Center')
    - **mvUser** (Display string: 'mv User')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvBalanceWhiteAutoOffsetX = property(lib_mvIMPACT_acquire.AnalogControl_mvBalanceWhiteAutoOffsetX_get, doc=r"""
    An integer property. Common AOI X-Offset used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).
    Common AOI XOffset used for auto gain control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).
    """)
    mvBalanceWhiteAutoOffsetY = property(lib_mvIMPACT_acquire.AnalogControl_mvBalanceWhiteAutoOffsetY_get, doc=r"""
    An integer property. Common AOI Y-Offset used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).
    Common AOI Y-Offset used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).
    """)
    mvBalanceWhiteAutoWidth = property(lib_mvIMPACT_acquire.AnalogControl_mvBalanceWhiteAutoWidth_get, doc=r"""
    An integer property. Common AOI Width used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).
    Common AOI Width used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).
    """)
    mvBalanceWhiteAutoHeight = property(lib_mvIMPACT_acquire.AnalogControl_mvBalanceWhiteAutoHeight_get, doc=r"""
    An integer property. Common AOI Height used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).
    Common AOI Height used for Auto Gain Control(AGC), Auto Exposure Control(AEC) and Auto White Balance(AWB).
    """)
    mvLowLight = property(lib_mvIMPACT_acquire.AnalogControl_mvLowLight_get, doc=r"""
    An enumerated integer property. Makes the image brighter.
    Makes the image brighter.

    The following string values might be valid for this feature:
    - **On** (Display string: 'On')
    - **Off** (Display string: 'Off')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvADCGain = property(lib_mvIMPACT_acquire.AnalogControl_mvADCGain_get, doc=r"""
    An integer property. Adapt gain. Gain value of the sensor may differ from sensor to sensor.
    Adapt gain. Gain value of the sensor may differ from sensor to sensor.
    """)
    mvVRamp = property(lib_mvIMPACT_acquire.AnalogControl_mvVRamp_get, doc=r"""
    An integer property. Adjusting this value will result in better column CDS (correlated double sampling) which will remove the column FPN from the image.
    Adjusting this value will result in better column CDS (correlated double sampling) which will remove the column FPN from the image.
    """)
    mvLinearLogarithmicMode = property(lib_mvIMPACT_acquire.AnalogControl_mvLinearLogarithmicMode_get, doc=r"""
    An integer property. Controls the knee point between linear response and logarithmic response.
    Controls the knee point between linear response and logarithmic response.
    """)
    mvDigitalGainOffset = property(lib_mvIMPACT_acquire.AnalogControl_mvDigitalGainOffset_get, doc=r"""
    An integer property. Used for fine tuning of the brightness of the sensor.
    Used for fine tuning of the brightness of the sensor.
    """)
    mvSaveCalibrationData = property(lib_mvIMPACT_acquire.AnalogControl_mvSaveCalibrationData_get, doc=r"""
    A method object. Saves the calibration data to non-volatile memory.
    Saves the calibration data to non-volatile memory.
    """)
    mvGammaEnable = property(lib_mvIMPACT_acquire.AnalogControl_mvGammaEnable_get, doc=r"""
    A boolean property. Enables Gamma correction. All other LUT will be disabled.
    Enables gamma correction. All other LUT will be disabled.
    """)
    mvGammaSelector = property(lib_mvIMPACT_acquire.AnalogControl_mvGammaSelector_get, doc=r"""
    An enumerated integer property. Sets the type of Gamma to be used.
    Sets the type of Gamma to be used.

    The following string values might be valid for this feature:
    - **mvSRGB** (Display string: 'mv SRGB'): Gamma curve is fixed to a sRGB curve.
    - **mvUser** (Display string: 'mv User'): Gamma curve can be configured by user.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    gamma = property(lib_mvIMPACT_acquire.AnalogControl_gamma_get, doc=r"""
    A floating point property. Controls the gamma correction of pixel intensity.
    Controls the gamma correction of pixel intensity.
    Since the human eye perceives light similar to a logarithm of real light intensity it's characteristic curve is
    non-linear. It follows the rule of (intensity ^ gamma) with a gamma value between 0.3-0.5.
    To provide as much useful information as possible, the image is converted from 12-bit acquired by the sensor to 8-bit utilizing
    this characteristic curve. The result is a linearized image optimized for the human eye's non-linear behavior which allows
    to perceive as much intensity differences as possible.
    Image: Gamma_correction_camera.png
        Conversion from 12- to 8-bit utilizing the gamma function
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_AnalogControl

# Register AnalogControl in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.AnalogControl_swigregister(AnalogControl)

class LUTControl(object):
    r"""
    Category that includes the LUT control features.
    A category that includes the LUT control features.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::GenICam::LUTControl** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.LUTControl_swiginit(self, lib_mvIMPACT_acquire.new_LUTControl(*args))
    LUTSelector = property(lib_mvIMPACT_acquire.LUTControl_LUTSelector_get, doc=r"""
    An enumerated integer property. Selects which LUT to control.
    Selects which LUT to control.

    The following string values might be valid for this feature:
    - **Luminance** (Display string: 'Luminance'): Selects the Luminance LUT.
    - **Red** (Display string: 'Red'): Selects the Red LUT.
    - **Green** (Display string: 'Green'): Selects the Green LUT.
    - **Blue** (Display string: 'Blue'): Selects the Blue LUT.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    LUTEnable = property(lib_mvIMPACT_acquire.LUTControl_LUTEnable_get, doc=r"""
    A boolean property. Activates the selected LUT.
    Activates the selected LUT.
    """)
    LUTIndex = property(lib_mvIMPACT_acquire.LUTControl_LUTIndex_get, doc=r"""
    An integer property. Control the index (offset) of the coefficient to access in the selected LUT.
    Control the index (offset) of the coefficient to access in the selected LUT.
    """)
    LUTValue = property(lib_mvIMPACT_acquire.LUTControl_LUTValue_get, doc=r"""
    An integer property. Returns the Value at entry LUTIndex of the LUT selected by LUTSelector.
    Returns the Value at entry LUTIndex of the LUT selected by LUTSelector.
    """)
    LUTValueAll = property(lib_mvIMPACT_acquire.LUTControl_LUTValueAll_get, doc=r"""
    A string property. Accesses all the LUT coefficients in a single access without using individual LUTIndex.
    Accesses all the LUT coefficients in a single access without using individual LUTIndex.
    """)
    mvLUTType = property(lib_mvIMPACT_acquire.LUTControl_mvLUTType_get, doc=r"""
    An enumerated integer property. Describes the type of LUT used.
    Describes the type of LUT used.

    The following string values might be valid for this feature:
    - **Direct** (Display string: 'Direct'): The user can define an output value for each input value of the LUT.
    - **Interpolated** (Display string: 'Interpolated'): The user can define the output values for equidistant nodes in the LUT. Linear interpolation is used to determine the output values for input values that lie in between the given nodes.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvLUTInputData = property(lib_mvIMPACT_acquire.LUTControl_mvLUTInputData_get, doc=r"""
    An enumerated integer property. Describes the data the LUT is operating on
    Describes the data the LUT is operating on

    The following string values might be valid for this feature:
    - **Bayer** (Display string: 'Bayer'): The LUT is operating on raw Bayer data (i.e. before debayering)
    - **Gray** (Display string: 'Gray'): The LUT is operating on gray data
    - **RGB** (Display string: 'RGB'): The LUT is operating on RGB data (i.e. after debayering)
    - **DeviceSpecific** (Display string: 'Device Specific'): The LUT is operating on device specific data

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvLUTMapping = property(lib_mvIMPACT_acquire.LUTControl_mvLUTMapping_get, doc=r"""
    An enumerated integer property. Describes mapping of the LUT
    Describes the mapping of the LUT

    The following string values might be valid for this feature:
    - **map_8To12** (Display string: 'map 8 To 12'): The LUT maps 8 bit input data to 12 bit output data.
    - **map_10To12** (Display string: 'map 10 To 12'): The LUT maps 10 bit input data to 12 bit output data.
    - **map_10To10** (Display string: 'map 10 To 10'): The LUT maps 10 bit input data to 10 bit output data.
    - **map_8To10** (Display string: 'map 8 To 10'): The LUT maps 8 bit input data to 12 bit output data.
    - **map_12To10** (Display string: 'map 12 To 10'): The LUT maps 12 bit input data to 10 bit output data.
    - **map_10To9** (Display string: 'map 10 To 9'): The LUT maps 10 bit input data to 9 bit output data.
    - **map_12To9** (Display string: 'map 12 To 9'): The LUT maps 12 bit input data to 9 bit output data.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_LUTControl

# Register LUTControl in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.LUTControl_swigregister(LUTControl)

class ColorTransformationControl(object):
    r"""
    Category that contains the Color Transformation control features.
    A category that contains the Color Transformation control features.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::GenICam::ColorTransformationControl** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.ColorTransformationControl_swiginit(self, lib_mvIMPACT_acquire.new_ColorTransformationControl(*args))
    colorTransformationSelector = property(lib_mvIMPACT_acquire.ColorTransformationControl_colorTransformationSelector_get, doc=r"""
    An enumerated integer property. Selects which Color Transformation module is controlled by the various Color Transformation features.
    Selects which Color Transformation module is controlled by the various Color Transformation features.

    The following string values might be valid for this feature:
    - **RGBtoRGB** (Display string: 'RGB to RGB'): RGB to RGB color transformation.
    - **RGBtoYUV** (Display string: 'RGB to YUV'): RGB to YUV color transformation.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    colorTransformationEnable = property(lib_mvIMPACT_acquire.ColorTransformationControl_colorTransformationEnable_get, doc=r"""
    A boolean property. Activates the selected Color Transformation module.
    Activates the selected Color Transformation module.
    """)
    colorTransformationValueSelector = property(lib_mvIMPACT_acquire.ColorTransformationControl_colorTransformationValueSelector_get, doc=r"""
    An enumerated integer property. Selects the Gain factor or Offset of the Transformation matrix to access in the selected Color Transformation module.
    Selects the Gain factor or Offset of the Transformation matrix to access in the selected Color Transformation module.

    The following string values might be valid for this feature:
    - **Gain00** (Display string: 'Gain 00'): Gain 0,0 of the transformation matrix.
    - **Gain01** (Display string: 'Gain 01'): Gain 0,1 of the transformation matrix.
    - **Gain02** (Display string: 'Gain 02'): Gain 0,2 of the transformation matrix.
    - **Gain10** (Display string: 'Gain 10'): Gain 1,0 of the transformation matrix.
    - **Gain11** (Display string: 'Gain 11'): Gain 1,1 of the transformation matrix.
    - **Gain12** (Display string: 'Gain 12'): Gain 1,2 of the transformation matrix.
    - **Gain20** (Display string: 'Gain 20'): Gain 2,0 of the transformation matrix.
    - **Gain21** (Display string: 'Gain 21'): Gain 2,1 of the transformation matrix.
    - **Gain22** (Display string: 'Gain 22'): Gain 2,2 of the transformation matrix.
    - **Offset0** (Display string: 'Offset 0'): Offset 0 of the transformation matrix.
    - **Offset1** (Display string: 'Offset 1'): Offset 1 of the transformation matrix.
    - **Offset2** (Display string: 'Offset 2'): Offset 2 of the transformation matrix.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    colorTransformationValue = property(lib_mvIMPACT_acquire.ColorTransformationControl_colorTransformationValue_get, doc=r"""
    A floating point property. Represents the value of the selected Gain factor or Offset inside the Transformation matrix.
    Represents the value of the selected Gain factor or Offset inside the Transformation matrix.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_ColorTransformationControl

# Register ColorTransformationControl in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.ColorTransformationControl_swigregister(ColorTransformationControl)

class DigitalIOControl(object):
    r"""
    Category that contains the digital input and output control features.
    A category that contains the digital input and output control features.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::GenICam::DigitalIOControl** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.DigitalIOControl_swiginit(self, lib_mvIMPACT_acquire.new_DigitalIOControl(*args))
    lineSelector = property(lib_mvIMPACT_acquire.DigitalIOControl_lineSelector_get, doc=r"""
    An enumerated integer property. Selects the physical line (or pin) of the external device connector or the virtual line of the Transport Layer to configure.
    Selects the physical line (or pin) of the external device connector or the virtual line of the Transport Layer to configure.

    The following string values might be valid for this feature:
    - **Line0** (Display string: 'Line 0'): Index of the physical line and associated I/O control block to use.
    - **Line1** (Display string: 'Line 1'): Index of the physical line and associated I/O control block to use.
    - **Line2** (Display string: 'Line 2'): Index of the physical line and associated I/O control block to use.
    - **Line**#3# (Display string: 'Line #3#'): Index of the physical line and associated I/O control block to use.
    - **LinkTrigger0** (Display string: 'Link Trigger 0'): Index of the virtual line going on the Transport layer to use.
    - **LinkTrigger1** (Display string: 'Link Trigger 1'): Index of the virtual line going on the Transport layer to use.
    - **LinkTrigger2** (Display string: 'Link Trigger 2'): Index of the virtual line going on the Transport layer to use.
    - **LinkTrigger**#3# (Display string: 'Link Trigger #3#'): Index of the virtual line going on the Transport layer to use.
    - **CC1** (Display string: 'CC 1'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink Product only.
    - **CC2** (Display string: 'CC 2'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink Product only.
    - **CC3** (Display string: 'CC 3'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink Product only.
    - **CC4** (Display string: 'CC 4'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink Product only.
    - **CC**#5# (Display string: 'CC #5#'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink Product only.
    - **Line3** (Display string: 'Line 3'): Index of the physical line and associated I/O control block to use.
    - **Line4** (Display string: 'Line 4'): Index of the physical line and associated I/O control block to use.
    - **Line5** (Display string: 'Line 5'): Index of the physical line and associated I/O control block to use.
    - **Line6** (Display string: 'Line 6'): Index of the physical line and associated I/O control block to use.
    - **Line7** (Display string: 'Line 7'): Index of the physical line and associated I/O control block to use.
    - **Line8** (Display string: 'Line 8'): Index of the physical line and associated I/O control block to use.
    - **Line9** (Display string: 'Line 9'): Index of the physical line and associated I/O control block to use.
    - **Line10** (Display string: 'Line 10'): Index of the physical line and associated I/O control block to use.
    - **Line11** (Display string: 'Line 11'): Index of the physical line and associated I/O control block to use.
    - **Line12** (Display string: 'Line 12'): Index of the physical line and associated I/O control block to use.
    - **Line13** (Display string: 'Line 13'): Index of the physical line and associated I/O control block to use.
    - **Line14** (Display string: 'Line 14'): Index of the physical line and associated I/O control block to use.
    - **Line15** (Display string: 'Line 15'): Index of the physical line and associated I/O control block to use.
    - **CC5** (Display string: 'CC 5'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink Product only.
    - **CC6** (Display string: 'CC 6'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink Product only.
    - **CC7** (Display string: 'CC 7'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink Product only.
    - **CC8** (Display string: 'CC 8'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink Product only.
    - **CC9** (Display string: 'CC 9'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink Product only.
    - **CC10** (Display string: 'CC 10'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink Product only.
    - **CC11** (Display string: 'CC 11'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink Product only.
    - **CC12** (Display string: 'CC 12'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink Product only.
    - **CC13** (Display string: 'CC 13'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink Product only.
    - **CC14** (Display string: 'CC 14'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink Product only.
    - **CC15** (Display string: 'CC 15'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink Product only.
    - **CC16** (Display string: 'CC 16')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.

    See **lineStatusAll** to find out which line corresponds to which input or output of your device
    """)
    lineMode = property(lib_mvIMPACT_acquire.DigitalIOControl_lineMode_get, doc=r"""
    An enumerated integer property. Controls if the physical Line is used to Input or Output a signal.
    Controls if the physical Line is used to Input or Output a signal.

    The following string values might be valid for this feature:
    - **Input** (Display string: 'Input'): The selected physical line is used to Input an electrical signal.
    - **Output** (Display string: 'Output'): The selected physical line is used to Output an electrical signal.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    lineInverter = property(lib_mvIMPACT_acquire.DigitalIOControl_lineInverter_get, doc=r"""
    A boolean property. Controls the inversion of the signal of the selected input or output Line.
    Controls the inversion of the signal of the selected input or output Line.
    """)
    lineStatus = property(lib_mvIMPACT_acquire.DigitalIOControl_lineStatus_get, doc=r"""
    A boolean property. Returns the current status of the selected input or output Line.
    Returns the current status of the selected input or output Line.
    """)
    lineStatusAll = property(lib_mvIMPACT_acquire.DigitalIOControl_lineStatusAll_get, doc=r"""
    An integer property. Returns the current status of all available Line signals at time of polling in a single bitfield.
    Returns the current status of all available Line signals at time of polling in a single bitfield.

    The following table documents which bit in this property represents the state of which digital I/O for **mvBlueCOUGAR-X** and **mvBlueFOX3** devices:


    |bit|IO|LineSelectorValue|
    |0|out 0|Line0|
    |1|out 1|Line1|
    |2|out 2|Line2|
    |3|out 3|Line3|
    |4|in 0|Line4|
    |5|in 1|Line5|


    The following table documents which bit in this property represents the state of which digital I/O for **mvBlueCOUGAR-X-POE** devices:


    |bit|IO|LineSelectorValue|
    |0|out 0|Line0|
    |1|out 1|Line1|
    |2|-|-|
    |3|-|-|
    |4|in 0|Line4|
    |5|in 1|Line5|


    The following table documents which bit in this property represents the state of which digital I/O for **mvBlueCOUGAR-X-POEI** **mvBlueCOUGAR-XD** devices:


    |bit|IO|LineSelectorValue|
    |0|out 0|Line0|
    |1|out 1|Line1|
    |2|out 2|Line2|
    |3|out 3|Line3|
    |4|in 0|Line4|
    |5|in 1|Line5|
    |6|in 2|Line6|
    |7|in 3|Line7|
    """)
    lineSource = property(lib_mvIMPACT_acquire.DigitalIOControl_lineSource_get, doc=r"""
    An enumerated integer property. Selects which internal acquisition or I/O source signal to output on the selected Line.
    Selects which internal acquisition or I/O source signal to output on the selected Line. LineMode must be Output.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off'): Line output is disabled (Tri-State).
    - **UserOutput0** (Display string: 'User Output 0'): The chosen User Output Bit state as defined by its current UserOutputValue.
    - **UserOutput1** (Display string: 'User Output 1'): The chosen User Output Bit state as defined by its current UserOutputValue.
    - **UserOutput2** (Display string: 'User Output 2'): The chosen User Output Bit state as defined by its current UserOutputValue.
    - **UserOutput**#3# (Display string: 'User Output #3#'): The chosen User Output Bit state as defined by its current UserOutputValue.
    - **AcquisitionTriggerWait** (Display string: 'Acquisition Trigger Wait'): Device is currently waiting for a trigger for the capture of one or many Frames.
    - **AcquisitionTrigger** (Display string: 'Acquisition Trigger'): Device is currently waiting for a trigger for the capture of one or many Frames.
    - **AcquisitionTriggerMissed** (Display string: 'Acquisition Trigger Missed'): Device has missed an Acquisition start trigger.
    - **AcquisitionActive** (Display string: 'Acquisition Active'): Device is currently doing an acquisition of one or many Frames.
    - **FrameTriggerWait** (Display string: 'Frame Trigger Wait'): Device is currently waiting for a Frame start trigger.
    - **FrameTrigger** (Display string: 'Frame Trigger'): Device is currently waiting for a Frame start trigger.
    - **FrameTriggerMissed** (Display string: 'Frame Trigger Missed'): Device has missed a Frame start trigger.
    - **FrameActive** (Display string: 'Frame Active'): Device is currently doing the capture of a Frame.
    - **ExposureActive** (Display string: 'Exposure Active'): Device is doing the exposure of a Frame (or Line).
    - **LineTriggerWait** (Display string: 'Line Trigger Wait'): Device is currently waiting for a Line start trigger.
    - **LineTrigger** (Display string: 'Line Trigger'): Device is currently waiting for a Line start trigger.
    - **LineTriggerMissed** (Display string: 'Line Trigger Missed'): Device has missed a Line start trigger.
    - **LineActive** (Display string: 'Line Active'): Device is currently doing the capture of a Line.
    - **Counter0Active** (Display string: 'Counter 0 Active'): The chosen counter is in active state (counting).
    - **Counter1Active** (Display string: 'Counter 1 Active'): The chosen counter is in active state (counting).
    - **Counter2Active** (Display string: 'Counter 2 Active'): The chosen counter is in active state (counting).
    - **Counter**#3#Active (Display string: 'Counter #3# Active'): The chosen counter is in active state (counting).
    - **Timer0Active** (Display string: 'Timer 0 Active'): The chosen Timer is in active state.
    - **Timer1Active** (Display string: 'Timer 1 Active'): The chosen Timer is in active state.
    - **Timer2Active** (Display string: 'Timer 2 Active'): The chosen Timer is in active state.
    - **Timer**#3#Active (Display string: 'Timer #3# Active'): The chosen Timer is in active state.
    - **Encoder0** (Display string: 'Encoder 0'): The chosen Encoder Output state.
    - **Encoder1** (Display string: 'Encoder 1'): The chosen Encoder Output state.
    - **Encoder2** (Display string: 'Encoder 2'): The chosen Encoder Output state.
    - **Encoder**#3# (Display string: 'Encoder #3#'): The chosen Encoder Output state.
    - **LogicBlock0** (Display string: 'Logic Block 0'): The choosen Logic Block output state.
    - **LogicBlock1** (Display string: 'Logic Block 1'): The choosen Logic Block output state.
    - **LogicBlock2** (Display string: 'Logic Block 2'): The choosen Logic Block output state.
    - **LogicBlock**#3# (Display string: 'Logic Block #3#'): The choosen Logic Block output state.
    - **SoftwareSignal0** (Display string: 'Software Signal 0'): The choosen Software Signal output state.
    - **SoftwareSignal1** (Display string: 'Software Signal 1'): The choosen Software Signal output state.
    - **SoftwareSignal2** (Display string: 'Software Signal 2'): The choosen Software Signal output state.
    - **SoftwareSignal**#3# (Display string: 'Software Signal #3#'): The choosen Software Signal output state.
    - **Stream0TransferActive** (Display string: 'Stream 0 Transfer Active'): Transfer on the stream is active.
    - **Stream1TransferActive** (Display string: 'Stream 1 Transfer Active'): Transfer on the stream is active.
    - **Stream**#2#TransferActive (Display string: 'Stream #2# Transfer Active'): Transfer on the stream is active.
    - **Stream0TransferPaused** (Display string: 'Stream 0 Transfer Paused'): Transfer on the stream is paused.
    - **Stream1TransferPaused** (Display string: 'Stream 1 Transfer Paused'): Transfer on the stream is paused.
    - **Stream**#2#TransferPaused (Display string: 'Stream #2# Transfer Paused'): Transfer on the stream is paused.
    - **Stream0TransferStopping** (Display string: 'Stream 0 Transfer Stopping'): Transfer on the stream is stopping.
    - **Stream1TransferStopping** (Display string: 'Stream 1 Transfer Stopping'): Transfer on the stream is stopping.
    - **Stream**#2#TransferStopping (Display string: 'Stream #2# Transfer Stopping'): Transfer on the stream is stopping.
    - **Stream0TransferStopped** (Display string: 'Stream 0 Transfer Stopped'): Transfer on the stream is stopped.
    - **Stream1TransferStopped** (Display string: 'Stream 1 Transfer Stopped'): Transfer on the stream is stopped.
    - **Stream**#2#TransferStopped (Display string: 'Stream #2# Transfer Stopped'): Transfer on the stream is stopped.
    - **Stream0TransferOverflow** (Display string: 'Stream 0 Transfer Overflow'): Transfer on the stream is in overflow.
    - **Stream1TransferOverflow** (Display string: 'Stream 1 Transfer Overflow'): Transfer on the stream is in overflow.
    - **Stream**#2#TransferOverflow (Display string: 'Stream #2# Transfer Overflow'): Transfer on the stream is in overflow.
    - **mvExposureSensor2Active** (Display string: 'mv Exposure Sensor 2 Active')
    - **UserOutput3** (Display string: 'User Output 3'): The chosen User Output Bit state as defined by its current UserOutputValue.
    - **UserOutput4** (Display string: 'User Output 4'): The chosen User Output Bit state as defined by its current UserOutputValue.
    - **UserOutput5** (Display string: 'User Output 5'): The chosen User Output Bit state as defined by its current UserOutputValue.
    - **UserOutput6** (Display string: 'User Output 6'): The chosen User Output Bit state as defined by its current UserOutputValue.
    - **UserOutput7** (Display string: 'User Output 7'): The chosen User Output Bit state as defined by its current UserOutputValue.
    - **Counter3Active** (Display string: 'Counter 3 Active'): The chosen counter is in active state (counting).
    - **Counter4Active** (Display string: 'Counter 4 Active'): The chosen counter is in active state (counting).
    - **Counter5Active** (Display string: 'Counter 5 Active'): The chosen counter is in active state (counting).
    - **Counter6Active** (Display string: 'Counter 6 Active'): The chosen counter is in active state (counting).
    - **Counter7Active** (Display string: 'Counter 7 Active'): The chosen counter is in active state (counting).
    - **Counter8Active** (Display string: 'Counter 8 Active'): The chosen counter is in active state (counting).
    - **mvReadOutActive** (Display string: 'mv Read Out Active')
    - **mvExposureAndAcquisitionActive** (Display string: 'mv Exposure And Acquisition Active')
    - **mvTemperatureOutOfRange** (Display string: 'mv Temperature Out Of Range')
    - **mvLogicGateOR1Output** (Display string: 'mv Logic Gate OR 1 Output')
    - **mvLogicGateOR2Output** (Display string: 'mv Logic Gate OR 2 Output')
    - **mvLogicGateOR3Output** (Display string: 'mv Logic Gate OR 3 Output')
    - **mvLogicGateOR4Output** (Display string: 'mv Logic Gate OR 4 Output')
    - **mvExposureActive** (Display string: 'mv Exposure Active')
    - **mvRTMOutput0** (Display string: 'mv RTM Output 0')
    - **mvRTMOutput1** (Display string: 'mv RTM Output 1')
    - **mvRTMOutput2** (Display string: 'mv RTM Output 2')
    - **mvRTMOutput3** (Display string: 'mv RTM Output 3')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    lineFormat = property(lib_mvIMPACT_acquire.DigitalIOControl_lineFormat_get, doc=r"""
    An enumerated integer property. Controls the current electrical format of the selected physical input or output Line.
    Controls the current electrical format of the selected physical input or output Line.

    The following string values might be valid for this feature:
    - **NoConnect** (Display string: 'No Connect'): The Line is not connected.
    - **TriState** (Display string: 'Tri State'): The Line is currently in Tri-State mode (Not driven).
    - **TTL** (Display string: 'TTL'): The Line is currently accepting or sending TTL level signals.
    - **LVDS** (Display string: 'LVDS'): The Line is currently accepting or sending LVDS level signals.
    - **RS422** (Display string: 'RS 422'): The Line is currently accepting or sending RS422 level signals.
    - **OptoCoupled** (Display string: 'Opto Coupled'): The Line is opto-coupled.
    - **OpenDrain** (Display string: 'Open Drain'): The Line is Open Drain (or Open Collector).

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    userOutputSelector = property(lib_mvIMPACT_acquire.DigitalIOControl_userOutputSelector_get, doc=r"""
    An enumerated integer property. Selects which bit of the User Output register will be set by UserOutputValue.
    Selects which bit of the User Output register will be set by UserOutputValue.

    The following string values might be valid for this feature:
    - **UserOutput0** (Display string: 'User Output 0'): Selects the bit 0 of the User Output register.
    - **UserOutput1** (Display string: 'User Output 1'): Selects the bit 1 of the User Output register.
    - **UserOutput2** (Display string: 'User Output 2'): Selects the bit 2 of the User Output register.
    - **UserOutput**#3# (Display string: 'User Output #3#'): Selects the bit #3# of the User Output register.
    - **UserOutput3** (Display string: 'User Output 3'): Selects the bit 3 of the User Output register.
    - **UserOutput4** (Display string: 'User Output 4'): Selects the bit 4 of the User Output register.
    - **UserOutput5** (Display string: 'User Output 5'): Selects the bit 5 of the User Output register.
    - **UserOutput6** (Display string: 'User Output 6'): Selects the bit 6 of the User Output register.
    - **UserOutput7** (Display string: 'User Output 7'): Selects the bit 7 of the User Output register.
    - **UserOutput8** (Display string: 'User Output 8'): Selects the bit 8 of the User Output register.
    - **UserOutput9** (Display string: 'User Output 9'): Selects the bit 9 of the User Output register.
    - **UserOutput10** (Display string: 'User Output 10'): Selects the bit 10 of the User Output register.
    - **UserOutput11** (Display string: 'User Output 11'): Selects the bit 11 of the User Output register.
    - **UserOutput12** (Display string: 'User Output 12'): Selects the bit 12 of the User Output register.
    - **UserOutput13** (Display string: 'User Output 13'): Selects the bit 13 of the User Output register.
    - **UserOutput14** (Display string: 'User Output 14'): Selects the bit 14 of the User Output register.
    - **UserOutput15** (Display string: 'User Output 15'): Selects the bit 15 of the User Output register.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    userOutputValue = property(lib_mvIMPACT_acquire.DigitalIOControl_userOutputValue_get, doc=r"""
    A boolean property. Sets the value of the bit selected by UserOutputSelector.
    Sets the value of the bit selected by UserOutputSelector.
    """)
    userOutputValueAll = property(lib_mvIMPACT_acquire.DigitalIOControl_userOutputValueAll_get, doc=r"""
    An integer property. Sets the value of all the bits of the User Output register.
    Sets the value of all the bits of the User Output register. It is subject to the UserOutputValueAllMask.
    """)
    userOutputValueAllMask = property(lib_mvIMPACT_acquire.DigitalIOControl_userOutputValueAllMask_get, doc=r"""
    An integer property. Sets the write mask to apply to the value specified by UserOutputValueAll before writing it in the User Output register.
    Sets the write mask to apply to the value specified by UserOutputValueAll before writing it in the User Output register. If the UserOutputValueAllMask feature is present, setting the user Output register using UserOutputValueAll will only change the bits that have a corresponding bit in the mask set to one.
    """)
    mvLineDebounceTimeRisingEdge = property(lib_mvIMPACT_acquire.DigitalIOControl_mvLineDebounceTimeRisingEdge_get, doc=r"""
    An integer property. Sets the debounce time in micro seconds for low to high transitions.
    Sets the debounce time in micro seconds for low to high transitions.
    """)
    mvLineDebounceTimeFallingEdge = property(lib_mvIMPACT_acquire.DigitalIOControl_mvLineDebounceTimeFallingEdge_get, doc=r"""
    An integer property. Sets the debounce time in micro seconds for high to low transitions.
    Sets the debounce time in micro seconds for high to low transitions.
    """)
    mvRTMInputSelector = property(lib_mvIMPACT_acquire.DigitalIOControl_mvRTMInputSelector_get, doc=r"""
    An enumerated integer property. Selects which RTM input to configure.
    Selects which RTM input to configure.

    The following string values might be valid for this feature:
    - **mvRTMInput0** (Display string: 'mv RTM Input 0')
    - **mvRTMInput1** (Display string: 'mv RTM Input 1')
    - **mvRTMInput2** (Display string: 'mv RTM Input 2')
    - **mvRTMInput3** (Display string: 'mv RTM Input 3')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvRTMSource = property(lib_mvIMPACT_acquire.DigitalIOControl_mvRTMSource_get, doc=r"""
    An enumerated integer property. Selects which signal to connect to the selected RTM input.
    Selects which signal to connect to the selected RTM input.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off')
    - **Line4** (Display string: 'Line 4')
    - **Line5** (Display string: 'Line 5')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvLineLED = property(lib_mvIMPACT_acquire.DigitalIOControl_mvLineLED_get, doc=r"""
    An enumerated integer property. Selects the digital I/O line to be stated by the LED
    Selects the digital I/O line to be stated by the LED

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off')
    - **Line0** (Display string: 'Line 0')
    - **Line1** (Display string: 'Line 1')
    - **Line2** (Display string: 'Line 2')
    - **Line3** (Display string: 'Line 3')
    - **Line4** (Display string: 'Line 4')
    - **Line5** (Display string: 'Line 5')
    - **Line6** (Display string: 'Line 6')
    - **Line7** (Display string: 'Line 7')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_DigitalIOControl

# Register DigitalIOControl in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.DigitalIOControl_swigregister(DigitalIOControl)

class CounterAndTimerControl(object):
    r"""
    Category that contains the Counter and Timer control features.
    A category that contains the Counter and Timer control features.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::GenICam::CounterAndTimerControl** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.CounterAndTimerControl_swiginit(self, lib_mvIMPACT_acquire.new_CounterAndTimerControl(*args))
    counterSelector = property(lib_mvIMPACT_acquire.CounterAndTimerControl_counterSelector_get, doc=r"""
    An enumerated integer property. Selects which Counter to configure.
    Selects which Counter to configure.

    The following string values might be valid for this feature:
    - **Counter0** (Display string: 'Counter 0'): Selects the counter 0.
    - **Counter1** (Display string: 'Counter 1'): Selects the counter 1.
    - **Counter2** (Display string: 'Counter 2'): Selects the counter 2.
    - **Counter**#3# (Display string: 'Counter #3#'): Selects the counter #3#.
    - **Counter3** (Display string: 'Counter 3'): Selects the counter 3.
    - **Counter4** (Display string: 'Counter 4'): Selects the counter 4.
    - **Counter5** (Display string: 'Counter 5'): Selects the counter 5.
    - **Counter6** (Display string: 'Counter 6'): Selects the counter 6.
    - **Counter7** (Display string: 'Counter 7'): Selects the counter 7.
    - **Counter8** (Display string: 'Counter 8'): Selects the counter 8.
    - **Counter9** (Display string: 'Counter 9'): Selects the counter 9.
    - **Counter10** (Display string: 'Counter 10'): Selects the counter 10.
    - **Counter11** (Display string: 'Counter 11'): Selects the counter 11.
    - **Counter12** (Display string: 'Counter 12'): Selects the counter 12.
    - **Counter13** (Display string: 'Counter 13'): Selects the counter 13.
    - **Counter14** (Display string: 'Counter 14'): Selects the counter 14.
    - **Counter15** (Display string: 'Counter 15'): Selects the counter 15.
    - **Counter16** (Display string: 'Counter 16')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    counterEventSource = property(lib_mvIMPACT_acquire.CounterAndTimerControl_counterEventSource_get, doc=r"""
    An enumerated integer property. Select the events that will be the source to increment the Counter.
    Select the events that will be the source to increment the Counter.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off'): Counter is stopped.
    - **AcquisitionTrigger** (Display string: 'Acquisition Trigger'): Counts the number of Acquisition Trigger.
    - **AcquisitionTriggerMissed** (Display string: 'Acquisition Trigger Missed'): Counts the number of missed Acquisition Start Trigger.
    - **AcquisitionStart** (Display string: 'Acquisition Start'): Counts the number of Acquisition Start.
    - **AcquisitionEnd** (Display string: 'Acquisition End'): Counts the number of Acquisition End.
    - **FrameTrigger** (Display string: 'Frame Trigger'): Counts the number of Frame Start Trigger.
    - **FrameTriggerMissed** (Display string: 'Frame Trigger Missed'): Counts the number of missed Frame Start Trigger.
    - **FrameStart** (Display string: 'Frame Start'): Counts the number of Frame Start.
    - **FrameEnd** (Display string: 'Frame End'): Counts the number of Frame End.
    - **FrameBurstStart** (Display string: 'Frame Burst Start'): Counts the number of Frame Burst Start.
    - **FrameBurstEnd** (Display string: 'Frame Burst End'): Counts the number of Frame Burst End.
    - **LineTrigger** (Display string: 'Line Trigger'): Counts the number of Line Start Trigger.
    - **LineTriggerMissed** (Display string: 'Line Trigger Missed'): Counts the number of missed Line Start Trigger.
    - **LineStart** (Display string: 'Line Start'): Counts the number of Line Start.
    - **LineEnd** (Display string: 'Line End'): Counts the number of Line End.
    - **ExposureStart** (Display string: 'Exposure Start'): Counts the number of Exposure Start.
    - **ExposureEnd** (Display string: 'Exposure End'): Counts the number of Exposure End.
    - **Line0** (Display string: 'Line 0'): Counts the number of transitions on the chosen I/O Line.
    - **Line1** (Display string: 'Line 1'): Counts the number of transitions on the chosen I/O Line.
    - **Line2** (Display string: 'Line 2'): Counts the number of transitions on the chosen I/O Line.
    - **Line**#3# (Display string: 'Line #3#'): Counts the number of transitions on the chosen I/O Line.
    - **Counter0Start** (Display string: 'Counter 0 Start'): Counts the number of Counter Start.
    - **Counter1Start** (Display string: 'Counter 1 Start'): Counts the number of Counter Start.
    - **Counter2Start** (Display string: 'Counter 2 Start'): Counts the number of Counter Start.
    - **Counter**#3#Start (Display string: 'Counter #3# Start'): Counts the number of Counter Start.
    - **Counter0End** (Display string: 'Counter 0 End'): Counts the number of Counter End.
    - **Counter1End** (Display string: 'Counter 1 End'): Counts the number of Counter End.
    - **Counter2End** (Display string: 'Counter 2 End'): Counts the number of Counter End.
    - **Counter**#3#End (Display string: 'Counter #3# End'): Counts the number of Counter End.
    - **Timer0Start** (Display string: 'Timer 0 Start'): Counts the number of Timer Start pulses generated.
    - **Timer1Start** (Display string: 'Timer 1 Start'): Counts the number of Timer Start pulses generated.
    - **Timer2Start** (Display string: 'Timer 2 Start'): Counts the number of Timer Start pulses generated.
    - **Timer**#3#Start (Display string: 'Timer #3# Start'): Counts the number of Timer Start pulses generated.
    - **Timer0End** (Display string: 'Timer 0 End'): Counts the number of Timer End pulses generated.
    - **Timer1End** (Display string: 'Timer 1 End'): Counts the number of Timer End pulses generated.
    - **Timer2End** (Display string: 'Timer 2 End'): Counts the number of Timer End pulses generated.
    - **Timer**#3#End (Display string: 'Timer #3# End'): Counts the number of Timer End pulses generated.
    - **Encoder0** (Display string: 'Encoder 0'): Counts the number of Encoder output pulses.
    - **Encoder1** (Display string: 'Encoder 1'): Counts the number of Encoder output pulses.
    - **Encoder2** (Display string: 'Encoder 2'): Counts the number of Encoder output pulses.
    - **Encoder**#3# (Display string: 'Encoder #3#'): Counts the number of Encoder output pulses.
    - **LogicBlock0** (Display string: 'Logic Block 0'): Counts the number of Logic Block output pulses.
    - **LogicBlock1** (Display string: 'Logic Block 1'): Counts the number of Logic Block output pulses.
    - **LogicBlock2** (Display string: 'Logic Block 2'): Counts the number of Logic Block output pulses.
    - **LogicBlock**#3# (Display string: 'Logic Block #3#'): Counts the number of Logic Block output pulses.
    - **SoftwareSignal0** (Display string: 'Software Signal 0'): Counts the number of Software Signal.
    - **SoftwareSignal1** (Display string: 'Software Signal 1'): Counts the number of Software Signal.
    - **SoftwareSignal2** (Display string: 'Software Signal 2'): Counts the number of Software Signal.
    - **SoftwareSignal**#3# (Display string: 'Software Signal #3#'): Counts the number of Software Signal.
    - **Action0** (Display string: 'Action 0'): Counts the number of assertions of the chosen action signal.
    - **Action1** (Display string: 'Action 1'): Counts the number of assertions of the chosen action signal.
    - **Action2** (Display string: 'Action 2'): Counts the number of assertions of the chosen action signal.
    - **Action**#3# (Display string: 'Action #3#'): Counts the number of assertions of the chosen action signal.
    - **LinkTrigger0** (Display string: 'Link Trigger 0'): Counts the number of  Link Triggers.
    - **LinkTrigger1** (Display string: 'Link Trigger 1'): Counts the number of  Link Triggers.
    - **LinkTrigger2** (Display string: 'Link Trigger 2'): Counts the number of  Link Triggers.
    - **LinkTrigger**#3# (Display string: 'Link Trigger #3#'): Counts the number of  Link Triggers.
    - **LinkTriggerMissed0** (Display string: 'Link Trigger Missed 0'): Counts the number of Link Triggers missed.
    - **LinkTriggerMissed1** (Display string: 'Link Trigger Missed 1'): Counts the number of Link Triggers missed.
    - **LinkTriggerMissed2** (Display string: 'Link Trigger Missed 2'): Counts the number of Link Triggers missed.
    - **LinkTriggerMissed**#3# (Display string: 'Link Trigger Missed #3#'): Counts the number of Link Triggers missed.
    - **TimestampTick** (Display string: 'Timestamp Tick'): Counts the number of clock ticks of the Timestamp clock. Can be used to create a programmable timer.
    - **Line3** (Display string: 'Line 3'): Counts the number of transitions on the chosen I/O Line.
    - **Line4** (Display string: 'Line 4'): Counts the number of transitions on the chosen I/O Line.
    - **Line5** (Display string: 'Line 5'): Counts the number of transitions on the chosen I/O Line.
    - **Line6** (Display string: 'Line 6'): Counts the number of transitions on the chosen I/O Line.
    - **Line7** (Display string: 'Line 7'): Counts the number of transitions on the chosen I/O Line.
    - **Line8** (Display string: 'Line 8'): Counts the number of transitions on the chosen I/O Line.
    - **Line9** (Display string: 'Line 9'): Counts the number of transitions on the chosen I/O Line.
    - **Line10** (Display string: 'Line 10'): Counts the number of transitions on the chosen I/O Line.
    - **Line11** (Display string: 'Line 11'): Counts the number of transitions on the chosen I/O Line.
    - **Line12** (Display string: 'Line 12'): Counts the number of transitions on the chosen I/O Line.
    - **Line13** (Display string: 'Line 13'): Counts the number of transitions on the chosen I/O Line.
    - **Line14** (Display string: 'Line 14'): Counts the number of transitions on the chosen I/O Line.
    - **Line15** (Display string: 'Line 15'): Counts the number of transitions on the chosen I/O Line.
    - **Counter3End** (Display string: 'Counter 3 End'): Counts the number of Counter End.
    - **Counter4End** (Display string: 'Counter 4 End'): Counts the number of Counter End.
    - **Counter5End** (Display string: 'Counter 5 End'): Counts the number of Counter End.
    - **Counter6End** (Display string: 'Counter 6 End'): Counts the number of Counter End.
    - **Counter7End** (Display string: 'Counter 7 End'): Counts the number of Counter End.
    - **Counter8End** (Display string: 'Counter 8 End'): Counts the number of Counter End.
    - **Counter9End** (Display string: 'Counter 9 End'): Counts the number of Counter End.
    - **Counter10End** (Display string: 'Counter 10 End'): Counts the number of Counter End.
    - **Counter11End** (Display string: 'Counter 11 End'): Counts the number of Counter End.
    - **Counter12End** (Display string: 'Counter 12 End'): Counts the number of Counter End.
    - **Counter13End** (Display string: 'Counter 13 End'): Counts the number of Counter End.
    - **Counter14End** (Display string: 'Counter 14 End'): Counts the number of Counter End.
    - **Counter15End** (Display string: 'Counter 15 End'): Counts the number of Counter End.
    - **Counter16End** (Display string: 'Counter 16 End')
    - **Timer3End** (Display string: 'Timer 3 End'): Counts the number of Timer End pulses generated.
    - **Timer4End** (Display string: 'Timer 4 End'): Counts the number of Timer End pulses generated.
    - **Timer5End** (Display string: 'Timer 5 End'): Counts the number of Timer End pulses generated.
    - **Timer6End** (Display string: 'Timer 6 End'): Counts the number of Timer End pulses generated.
    - **Timer7End** (Display string: 'Timer 7 End'): Counts the number of Timer End pulses generated.
    - **Timer8End** (Display string: 'Timer 8 End'): Counts the number of Timer End pulses generated.
    - **Timer9End** (Display string: 'Timer 9 End'): Counts the number of Timer End pulses generated.
    - **Timer10End** (Display string: 'Timer 10 End'): Counts the number of Timer End pulses generated.
    - **Timer11End** (Display string: 'Timer 11 End'): Counts the number of Timer End pulses generated.
    - **Timer12End** (Display string: 'Timer 12 End'): Counts the number of Timer End pulses generated.
    - **Timer13End** (Display string: 'Timer 13 End'): Counts the number of Timer End pulses generated.
    - **Timer14End** (Display string: 'Timer 14 End'): Counts the number of Timer End pulses generated.
    - **Timer15End** (Display string: 'Timer 15 End'): Counts the number of Timer End pulses generated.
    - **Timer16End** (Display string: 'Timer 16 End')
    - **Action3** (Display string: 'Action 3'): Counts the number of assertions of the chosen action signal.
    - **Action4** (Display string: 'Action 4'): Counts the number of assertions of the chosen action signal.
    - **Action5** (Display string: 'Action 5'): Counts the number of assertions of the chosen action signal.
    - **Action6** (Display string: 'Action 6'): Counts the number of assertions of the chosen action signal.
    - **Action7** (Display string: 'Action 7'): Counts the number of assertions of the chosen action signal.
    - **Action8** (Display string: 'Action 8'): Counts the number of assertions of the chosen action signal.
    - **Action9** (Display string: 'Action 9'): Counts the number of assertions of the chosen action signal.
    - **Action10** (Display string: 'Action 10'): Counts the number of assertions of the chosen action signal.
    - **Action11** (Display string: 'Action 11'): Counts the number of assertions of the chosen action signal.
    - **Action12** (Display string: 'Action 12'): Counts the number of assertions of the chosen action signal.
    - **Action13** (Display string: 'Action 13'): Counts the number of assertions of the chosen action signal.
    - **Action14** (Display string: 'Action 14'): Counts the number of assertions of the chosen action signal.
    - **Action15** (Display string: 'Action 15'): Counts the number of assertions of the chosen action signal.
    - **Action16** (Display string: 'Action 16')
    - **Line0RisingEdge** (Display string: 'Line 0 Rising Edge')
    - **Line1RisingEdge** (Display string: 'Line 1 Rising Edge')
    - **Line2RisingEdge** (Display string: 'Line 2 Rising Edge')
    - **Line3RisingEdge** (Display string: 'Line 3 Rising Edge')
    - **Line4RisingEdge** (Display string: 'Line 4 Rising Edge')
    - **Line5RisingEdge** (Display string: 'Line 5 Rising Edge')
    - **Line6RisingEdge** (Display string: 'Line 6 Rising Edge')
    - **Line7RisingEdge** (Display string: 'Line 7 Rising Edge')
    - **Line8RisingEdge** (Display string: 'Line 8 Rising Edge')
    - **Line9RisingEdge** (Display string: 'Line 9 Rising Edge')
    - **Line10RisingEdge** (Display string: 'Line 10 Rising Edge')
    - **Line11RisingEdge** (Display string: 'Line 11 Rising Edge')
    - **Line12RisingEdge** (Display string: 'Line 12 Rising Edge')
    - **Line13RisingEdge** (Display string: 'Line 13 Rising Edge')
    - **Line14RisingEdge** (Display string: 'Line 14 Rising Edge')
    - **Line15RisingEdge** (Display string: 'Line 15 Rising Edge')
    - **mvTemperatureOutOfRange** (Display string: 'mv Temperature Out Of Range')
    - **mvLogicGateOR1Output** (Display string: 'mv Logic Gate OR 1 Output')
    - **mvLogicGateOR2Output** (Display string: 'mv Logic Gate OR 2 Output')
    - **mvLogicGateOR3Output** (Display string: 'mv Logic Gate OR 3 Output')
    - **mvLogicGateOR4Output** (Display string: 'mv Logic Gate OR 4 Output')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    counterEventActivation = property(lib_mvIMPACT_acquire.CounterAndTimerControl_counterEventActivation_get, doc=r"""
    An enumerated integer property. Selects the Activation mode Event Source signal.
    Selects the Activation mode Event Source signal.

    The following string values might be valid for this feature:
    - **RisingEdge** (Display string: 'Rising Edge'): Counts on the Rising Edge of the signal.
    - **FallingEdge** (Display string: 'Falling Edge'): Counts on the Falling Edge of the signal.
    - **AnyEdge** (Display string: 'Any Edge'): Counts on the Falling or rising Edge of the selected signal.
    - **LevelHigh** (Display string: 'Level High')
    - **LevelLow** (Display string: 'Level Low')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    counterResetSource = property(lib_mvIMPACT_acquire.CounterAndTimerControl_counterResetSource_get, doc=r"""
    An enumerated integer property. Selects the signals that will be the source to reset the Counter.
    Selects the signals that will be the source to reset the Counter.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off'): Disable the Counter Reset trigger.
    - **CounterTrigger** (Display string: 'Counter Trigger'): Resets with the reception of a trigger on the CounterTriggerSource.
    - **AcquisitionTrigger** (Display string: 'Acquisition Trigger'): Resets with the reception of the Acquisition Trigger.
    - **AcquisitionTriggerMissed** (Display string: 'Acquisition Trigger Missed'): Resets with the reception of the missed Acquisition start trigger.
    - **AcquisitionStart** (Display string: 'Acquisition Start'): Resets with the reception of the Acquisition Start.
    - **AcquisitionEnd** (Display string: 'Acquisition End'): Resets with the reception of the Acquisition End.
    - **FrameTrigger** (Display string: 'Frame Trigger'): Resets with the reception of the Frame Start Trigger.
    - **FrameTriggerMissed** (Display string: 'Frame Trigger Missed'): Resets with the reception of the missed Frame start trigger.
    - **FrameStart** (Display string: 'Frame Start'): Resets with the reception of the Frame Start.
    - **FrameEnd** (Display string: 'Frame End'): Resets with the reception of the Frame End.
    - **LineTrigger** (Display string: 'Line Trigger'): Resets with the reception of the Line Start Trigger.
    - **LineTriggerMissed** (Display string: 'Line Trigger Missed'): Resets with the reception of the missed Line start trigger.
    - **LineStart** (Display string: 'Line Start'): Resets with the reception of the Line Start.
    - **LineEnd** (Display string: 'Line End'): Resets with the reception of the Line End.
    - **ExposureStart** (Display string: 'Exposure Start'): Resets with the reception of the Exposure Start.
    - **ExposureEnd** (Display string: 'Exposure End'): Resets with the reception of the Exposure End.
    - **Line0** (Display string: 'Line 0'): Resets by the chosen I/O Line.
    - **Line1** (Display string: 'Line 1'): Resets by the chosen I/O Line.
    - **Line2** (Display string: 'Line 2'): Resets by the chosen I/O Line.
    - **Line**#3# (Display string: 'Line #3#'): Resets by the chosen I/O Line.
    - **UserOutput0** (Display string: 'User Output 0'): Resets by the chosen User Output bit.
    - **UserOutput1** (Display string: 'User Output 1'): Resets by the chosen User Output bit.
    - **UserOutput2** (Display string: 'User Output 2'): Resets by the chosen User Output bit.
    - **UserOutput**#3# (Display string: 'User Output #3#'): Resets by the chosen User Output bit.
    - **Counter0Start** (Display string: 'Counter 0 Start'): Resets with the reception of the Counter Start.
    - **Counter1Start** (Display string: 'Counter 1 Start'): Resets with the reception of the Counter Start.
    - **Counter2Start** (Display string: 'Counter 2 Start'): Resets with the reception of the Counter Start.
    - **Counter**#3#Start (Display string: 'Counter #3# Start'): Resets with the reception of the Counter Start.
    - **Counter0End** (Display string: 'Counter 0 End'): Resets with the reception of the Counter End.
    - **Counter1End** (Display string: 'Counter 1 End'): Resets with the reception of the Counter End.
    - **Counter2End** (Display string: 'Counter 2 End'): Resets with the reception of the Counter End.
    - **Counter**#3#End (Display string: 'Counter #3# End'): Resets with the reception of the Counter End.
    - **Timer0Start** (Display string: 'Timer 0 Start'): Resets with the reception of the Timer Start.
    - **Timer1Start** (Display string: 'Timer 1 Start'): Resets with the reception of the Timer Start.
    - **Timer2Start** (Display string: 'Timer 2 Start'): Resets with the reception of the Timer Start.
    - **Timer**#3#Start (Display string: 'Timer #3# Start'): Resets with the reception of the Timer Start.
    - **Timer0End** (Display string: 'Timer 0 End'): Resets with the reception of the Timer End.
    - **Timer1End** (Display string: 'Timer 1 End'): Resets with the reception of the Timer End.
    - **Timer2End** (Display string: 'Timer 2 End'): Resets with the reception of the Timer End.
    - **Timer**#3#End (Display string: 'Timer #3# End'): Resets with the reception of the Timer End.
    - **Encoder0** (Display string: 'Encoder 0'): Resets with the reception of the Encoder output signal.
    - **Encoder1** (Display string: 'Encoder 1'): Resets with the reception of the Encoder output signal.
    - **Encoder2** (Display string: 'Encoder 2'): Resets with the reception of the Encoder output signal.
    - **Encoder**#3# (Display string: 'Encoder #3#'): Resets with the reception of the Encoder output signal.
    - **LogicBlock0** (Display string: 'Logic Block 0'): Resets with the reception of the LogicBlock output signal.
    - **LogicBlock1** (Display string: 'Logic Block 1'): Resets with the reception of the LogicBlock output signal.
    - **LogicBlock2** (Display string: 'Logic Block 2'): Resets with the reception of the LogicBlock output signal.
    - **LogicBlock**#3# (Display string: 'Logic Block #3#'): Resets with the reception of the LogicBlock output signal.
    - **SoftwareSignal0** (Display string: 'Software Signal 0'): Resets on the reception of the Software Signal.
    - **SoftwareSignal1** (Display string: 'Software Signal 1'): Resets on the reception of the Software Signal.
    - **SoftwareSignal2** (Display string: 'Software Signal 2'): Resets on the reception of the Software Signal.
    - **SoftwareSignal**#3# (Display string: 'Software Signal #3#'): Resets on the reception of the Software Signal.
    - **Action0** (Display string: 'Action 0'): Resets on assertions of the chosen action signal (Broadcasted signal on the transport layer).
    - **Action1** (Display string: 'Action 1'): Resets on assertions of the chosen action signal (Broadcasted signal on the transport layer).
    - **Action2** (Display string: 'Action 2'): Resets on assertions of the chosen action signal (Broadcasted signal on the transport layer).
    - **Action**#3# (Display string: 'Action #3#'): Resets on assertions of the chosen action signal (Broadcasted signal on the transport layer).
    - **LinkTrigger0** (Display string: 'Link Trigger 0'): Resets on the reception of the chosen Link Trigger (received from the transport layer).
    - **LinkTrigger1** (Display string: 'Link Trigger 1'): Resets on the reception of the chosen Link Trigger (received from the transport layer).
    - **LinkTrigger2** (Display string: 'Link Trigger 2'): Resets on the reception of the chosen Link Trigger (received from the transport layer).
    - **LinkTrigger**#3# (Display string: 'Link Trigger #3#'): Resets on the reception of the chosen Link Trigger (received from the transport layer).
    - **Line3** (Display string: 'Line 3'): Resets by the chosen I/O Line.
    - **Line4** (Display string: 'Line 4'): Resets by the chosen I/O Line.
    - **Line5** (Display string: 'Line 5'): Resets by the chosen I/O Line.
    - **Line6** (Display string: 'Line 6'): Resets by the chosen I/O Line.
    - **Line7** (Display string: 'Line 7'): Resets by the chosen I/O Line.
    - **Line8** (Display string: 'Line 8'): Resets by the chosen I/O Line.
    - **Line9** (Display string: 'Line 9'): Resets by the chosen I/O Line.
    - **Line10** (Display string: 'Line 10'): Resets by the chosen I/O Line.
    - **Line11** (Display string: 'Line 11'): Resets by the chosen I/O Line.
    - **Line12** (Display string: 'Line 12'): Resets by the chosen I/O Line.
    - **Line13** (Display string: 'Line 13'): Resets by the chosen I/O Line.
    - **Line14** (Display string: 'Line 14'): Resets by the chosen I/O Line.
    - **Line15** (Display string: 'Line 15'): Resets by the chosen I/O Line.
    - **Counter3End** (Display string: 'Counter 3 End'): Resets with the reception of the Counter End.
    - **Counter4End** (Display string: 'Counter 4 End'): Resets with the reception of the Counter End.
    - **Counter5End** (Display string: 'Counter 5 End'): Resets with the reception of the Counter End.
    - **Counter6End** (Display string: 'Counter 6 End'): Resets with the reception of the Counter End.
    - **Counter7End** (Display string: 'Counter 7 End'): Resets with the reception of the Counter End.
    - **Counter8End** (Display string: 'Counter 8 End'): Resets with the reception of the Counter End.
    - **Counter9End** (Display string: 'Counter 9 End'): Resets with the reception of the Counter End.
    - **Counter10End** (Display string: 'Counter 10 End'): Resets with the reception of the Counter End.
    - **Counter11End** (Display string: 'Counter 11 End'): Resets with the reception of the Counter End.
    - **Counter12End** (Display string: 'Counter 12 End'): Resets with the reception of the Counter End.
    - **Counter13End** (Display string: 'Counter 13 End'): Resets with the reception of the Counter End.
    - **Counter14End** (Display string: 'Counter 14 End'): Resets with the reception of the Counter End.
    - **Counter15End** (Display string: 'Counter 15 End'): Resets with the reception of the Counter End.
    - **Counter16End** (Display string: 'Counter 16 End')
    - **Timer3End** (Display string: 'Timer 3 End'): Resets with the reception of the Timer End.
    - **Timer4End** (Display string: 'Timer 4 End'): Resets with the reception of the Timer End.
    - **Timer5End** (Display string: 'Timer 5 End'): Resets with the reception of the Timer End.
    - **Timer6End** (Display string: 'Timer 6 End'): Resets with the reception of the Timer End.
    - **Timer7End** (Display string: 'Timer 7 End'): Resets with the reception of the Timer End.
    - **Timer8End** (Display string: 'Timer 8 End'): Resets with the reception of the Timer End.
    - **Timer9End** (Display string: 'Timer 9 End'): Resets with the reception of the Timer End.
    - **Timer10End** (Display string: 'Timer 10 End'): Resets with the reception of the Timer End.
    - **Timer11End** (Display string: 'Timer 11 End'): Resets with the reception of the Timer End.
    - **Timer12End** (Display string: 'Timer 12 End'): Resets with the reception of the Timer End.
    - **Timer13End** (Display string: 'Timer 13 End'): Resets with the reception of the Timer End.
    - **Timer14End** (Display string: 'Timer 14 End'): Resets with the reception of the Timer End.
    - **Timer15End** (Display string: 'Timer 15 End'): Resets with the reception of the Timer End.
    - **Timer16End** (Display string: 'Timer 16 End')
    - **UserOutput3** (Display string: 'User Output 3'): Resets by the chosen User Output bit.
    - **UserOutput4** (Display string: 'User Output 4'): Resets by the chosen User Output bit.
    - **UserOutput5** (Display string: 'User Output 5'): Resets by the chosen User Output bit.
    - **UserOutput6** (Display string: 'User Output 6'): Resets by the chosen User Output bit.
    - **UserOutput7** (Display string: 'User Output 7'): Resets by the chosen User Output bit.
    - **UserOutput8** (Display string: 'User Output 8'): Resets by the chosen User Output bit.
    - **UserOutput9** (Display string: 'User Output 9'): Resets by the chosen User Output bit.
    - **UserOutput10** (Display string: 'User Output 10'): Resets by the chosen User Output bit.
    - **UserOutput11** (Display string: 'User Output 11'): Resets by the chosen User Output bit.
    - **UserOutput12** (Display string: 'User Output 12'): Resets by the chosen User Output bit.
    - **UserOutput13** (Display string: 'User Output 13'): Resets by the chosen User Output bit.
    - **UserOutput14** (Display string: 'User Output 14'): Resets by the chosen User Output bit.
    - **UserOutput15** (Display string: 'User Output 15'): Resets by the chosen User Output bit.
    - **Action3** (Display string: 'Action 3'): Resets on assertions of the chosen action signal (Broadcasted signal on the transport layer).
    - **Action4** (Display string: 'Action 4'): Resets on assertions of the chosen action signal (Broadcasted signal on the transport layer).
    - **Action5** (Display string: 'Action 5'): Resets on assertions of the chosen action signal (Broadcasted signal on the transport layer).
    - **Action6** (Display string: 'Action 6'): Resets on assertions of the chosen action signal (Broadcasted signal on the transport layer).
    - **Action7** (Display string: 'Action 7'): Resets on assertions of the chosen action signal (Broadcasted signal on the transport layer).
    - **Action8** (Display string: 'Action 8'): Resets on assertions of the chosen action signal (Broadcasted signal on the transport layer).
    - **Action9** (Display string: 'Action 9'): Resets on assertions of the chosen action signal (Broadcasted signal on the transport layer).
    - **Action10** (Display string: 'Action 10'): Resets on assertions of the chosen action signal (Broadcasted signal on the transport layer).
    - **Action11** (Display string: 'Action 11'): Resets on assertions of the chosen action signal (Broadcasted signal on the transport layer).
    - **Action12** (Display string: 'Action 12'): Resets on assertions of the chosen action signal (Broadcasted signal on the transport layer).
    - **Action13** (Display string: 'Action 13'): Resets on assertions of the chosen action signal (Broadcasted signal on the transport layer).
    - **Action14** (Display string: 'Action 14'): Resets on assertions of the chosen action signal (Broadcasted signal on the transport layer).
    - **Action15** (Display string: 'Action 15'): Resets on assertions of the chosen action signal (Broadcasted signal on the transport layer).
    - **Action16** (Display string: 'Action 16')
    - **mvTemperatureOutOfRange** (Display string: 'mv Temperature Out Of Range')
    - **mvLogicGateOR1Output** (Display string: 'mv Logic Gate OR 1 Output')
    - **mvLogicGateOR2Output** (Display string: 'mv Logic Gate OR 2 Output')
    - **mvLogicGateOR3Output** (Display string: 'mv Logic Gate OR 3 Output')
    - **mvLogicGateOR4Output** (Display string: 'mv Logic Gate OR 4 Output')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    counterResetActivation = property(lib_mvIMPACT_acquire.CounterAndTimerControl_counterResetActivation_get, doc=r"""
    An enumerated integer property. Selects the Activation mode of the Counter Reset Source signal.
    Selects the Activation mode of the Counter Reset Source signal.

    The following string values might be valid for this feature:
    - **RisingEdge** (Display string: 'Rising Edge'): Resets the counter on the Rising Edge of the signal.
    - **FallingEdge** (Display string: 'Falling Edge'): Resets the counter on the Falling Edge of the signal.
    - **AnyEdge** (Display string: 'Any Edge'): Resets the counter on the Falling or rising Edge of the selected signal.
    - **LevelHigh** (Display string: 'Level High'): Resets the counter as long as the selected signal level is High.
    - **LevelLow** (Display string: 'Level Low'): Resets the counter as long as the selected signal level is Low.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    counterReset = property(lib_mvIMPACT_acquire.CounterAndTimerControl_counterReset_get, doc=r"""
    A method object. Does a software reset of the selected Counter and starts it.
    Does a software reset of the selected Counter and starts it. The counter starts counting events immediately after the reset unless a Counter trigger is active. CounterReset can be used to reset the Counter independently from the CounterResetSource. To disable the counter temporarily, set CounterEventSource to Off.
    """)
    counterValue = property(lib_mvIMPACT_acquire.CounterAndTimerControl_counterValue_get, doc=r"""
    An integer property. Reads or writes the current value of the selected Counter.
    Reads or writes the current value of the selected Counter.
    """)
    counterValueAtReset = property(lib_mvIMPACT_acquire.CounterAndTimerControl_counterValueAtReset_get, doc=r"""
    An integer property. Reads the value of the selected Counter when it was reset by a trigger or by an explicit CounterReset command.
    Reads the value of the selected Counter when it was reset by a trigger or by an explicit CounterReset command.
    """)
    counterDuration = property(lib_mvIMPACT_acquire.CounterAndTimerControl_counterDuration_get, doc=r"""
    An integer property. Sets the duration (or number of events) before the CounterEnd event is generated.
    Sets the duration (or number of events) before the CounterEnd event is generated.
    """)
    counterStatus = property(lib_mvIMPACT_acquire.CounterAndTimerControl_counterStatus_get, doc=r"""
    An enumerated integer property. Returns the current status of the Counter.
    Returns the current status of the Counter.

    The following string values might be valid for this feature:
    - **CounterIdle** (Display string: 'Counter Idle'): The counter is idle.
    - **CounterTriggerWait** (Display string: 'Counter Trigger Wait'): The counter is waiting for a start trigger.
    - **CounterActive** (Display string: 'Counter Active'): The counter is counting for the specified duration.
    - **CounterCompleted** (Display string: 'Counter Completed'): The counter reached the CounterDuration count.
    - **CounterOverflow** (Display string: 'Counter Overflow'): The counter reached its maximum possible count.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    counterTriggerSource = property(lib_mvIMPACT_acquire.CounterAndTimerControl_counterTriggerSource_get, doc=r"""
    An enumerated integer property. Selects the source to start the Counter.
    Selects the source to start the Counter.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off'): Disables the Counter trigger.
    - **AcquisitionTrigger** (Display string: 'Acquisition Trigger'): Starts with the reception of the Acquisition Trigger.
    - **AcquisitionTriggerMissed** (Display string: 'Acquisition Trigger Missed'): Device has missed an Acquisition start trigger.
    - **AcquisitionStart** (Display string: 'Acquisition Start'): Starts with the reception of the Acquisition Start.
    - **AcquisitionEnd** (Display string: 'Acquisition End'): Starts with the reception of the Acquisition End.
    - **FrameTrigger** (Display string: 'Frame Trigger'): Starts with the reception of the Frame Start Trigger.
    - **FrameTriggerMissed** (Display string: 'Frame Trigger Missed'): Device has missed a Frame start trigger.
    - **FrameStart** (Display string: 'Frame Start'): Starts with the reception of the Frame Start.
    - **FrameEnd** (Display string: 'Frame End'): Starts with the reception of the Frame End.
    - **FrameBurstStart** (Display string: 'Frame Burst Start'): Starts with the reception of the Frame Burst Start.
    - **FrameBurstEnd** (Display string: 'Frame Burst End'): Starts with the reception of the Frame Burst End.
    - **LineTrigger** (Display string: 'Line Trigger'): Starts with the reception of the Line Start Trigger.
    - **LineTriggerMissed** (Display string: 'Line Trigger Missed'): Device has missed a Line start trigger.
    - **LineStart** (Display string: 'Line Start'): Starts with the reception of the Line Start.
    - **LineEnd** (Display string: 'Line End'): Starts with the reception of the Line End.
    - **ExposureStart** (Display string: 'Exposure Start'): Starts with the reception of the Exposure Start.
    - **ExposureEnd** (Display string: 'Exposure End'): Starts with the reception of the Exposure End.
    - **Line0** (Display string: 'Line 0'): Starts when the specified CounterTriggerActivation condition is met on the chosen I/O Line.
    - **Line1** (Display string: 'Line 1'): Starts when the specified CounterTriggerActivation condition is met on the chosen I/O Line.
    - **Line2** (Display string: 'Line 2'): Starts when the specified CounterTriggerActivation condition is met on the chosen I/O Line.
    - **Line**#3# (Display string: 'Line #3#'): Starts when the specified CounterTriggerActivation condition is met on the chosen I/O Line.
    - **UserOutput0** (Display string: 'User Output 0'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **UserOutput1** (Display string: 'User Output 1'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **UserOutput2** (Display string: 'User Output 2'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **UserOutput**#3# (Display string: 'User Output #3#'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **Counter0Start** (Display string: 'Counter 0 Start'): Starts with the reception of the Counter Start.
    - **Counter1Start** (Display string: 'Counter 1 Start'): Starts with the reception of the Counter Start.
    - **Counter2Start** (Display string: 'Counter 2 Start'): Starts with the reception of the Counter Start.
    - **Counter**#3#Start (Display string: 'Counter #3# Start'): Starts with the reception of the Counter Start.
    - **Counter0End** (Display string: 'Counter 0 End'): Starts with the reception of the Counter End.
    - **Counter1End** (Display string: 'Counter 1 End'): Starts with the reception of the Counter End.
    - **Counter2End** (Display string: 'Counter 2 End'): Starts with the reception of the Counter End.
    - **Counter**#3#End (Display string: 'Counter #3# End'): Starts with the reception of the Counter End.
    - **Timer0Start** (Display string: 'Timer 0 Start'): Starts with the reception of the Timer Start.
    - **Timer1Start** (Display string: 'Timer 1 Start'): Starts with the reception of the Timer Start.
    - **Timer2Start** (Display string: 'Timer 2 Start'): Starts with the reception of the Timer Start.
    - **Timer**#3#Start (Display string: 'Timer #3# Start'): Starts with the reception of the Timer Start.
    - **Timer0End** (Display string: 'Timer 0 End'): Starts with the reception of the Timer End.
    - **Timer1End** (Display string: 'Timer 1 End'): Starts with the reception of the Timer End.
    - **Timer2End** (Display string: 'Timer 2 End'): Starts with the reception of the Timer End.
    - **Timer**#3#End (Display string: 'Timer #3# End'): Starts with the reception of the Timer End.
    - **Encoder0** (Display string: 'Encoder 0'): Starts with the reception of the Encoder output signal.
    - **Encoder1** (Display string: 'Encoder 1'): Starts with the reception of the Encoder output signal.
    - **Encoder2** (Display string: 'Encoder 2'): Starts with the reception of the Encoder output signal.
    - **Encoder**#3# (Display string: 'Encoder #3#'): Starts with the reception of the Encoder output signal.
    - **LogicBlock0** (Display string: 'Logic Block 0'): Starts with the reception of the Logic Block output signal.
    - **LogicBlock1** (Display string: 'Logic Block 1'): Starts with the reception of the Logic Block output signal.
    - **LogicBlock2** (Display string: 'Logic Block 2'): Starts with the reception of the Logic Block output signal.
    - **LogicBlock**#3# (Display string: 'Logic Block #3#'): Starts with the reception of the Logic Block output signal.
    - **SoftwareSignal0** (Display string: 'Software Signal 0'): Starts on the reception of the Software Signal.
    - **SoftwareSignal1** (Display string: 'Software Signal 1'): Starts on the reception of the Software Signal.
    - **SoftwareSignal2** (Display string: 'Software Signal 2'): Starts on the reception of the Software Signal.
    - **SoftwareSignal**#3# (Display string: 'Software Signal #3#'): Starts on the reception of the Software Signal.
    - **Action0** (Display string: 'Action 0'): Starts with the assertion of the chosen action signal.
    - **Action1** (Display string: 'Action 1'): Starts with the assertion of the chosen action signal.
    - **Action2** (Display string: 'Action 2'): Starts with the assertion of the chosen action signal.
    - **Action**#3# (Display string: 'Action #3#'): Starts with the assertion of the chosen action signal.
    - **LinkTrigger0** (Display string: 'Link Trigger 0'): Starts with the reception of the chosen Link Trigger signal.
    - **LinkTrigger1** (Display string: 'Link Trigger 1'): Starts with the reception of the chosen Link Trigger signal.
    - **LinkTrigger2** (Display string: 'Link Trigger 2'): Starts with the reception of the chosen Link Trigger signal.
    - **LinkTrigger**#3# (Display string: 'Link Trigger #3#'): Starts with the reception of the chosen Link Trigger signal.
    - **Line3** (Display string: 'Line 3'): Starts when the specified CounterTriggerActivation condition is met on the chosen I/O Line.
    - **Line4** (Display string: 'Line 4'): Starts when the specified CounterTriggerActivation condition is met on the chosen I/O Line.
    - **Line5** (Display string: 'Line 5'): Starts when the specified CounterTriggerActivation condition is met on the chosen I/O Line.
    - **Line6** (Display string: 'Line 6'): Starts when the specified CounterTriggerActivation condition is met on the chosen I/O Line.
    - **Line7** (Display string: 'Line 7'): Starts when the specified CounterTriggerActivation condition is met on the chosen I/O Line.
    - **Line8** (Display string: 'Line 8'): Starts when the specified CounterTriggerActivation condition is met on the chosen I/O Line.
    - **Line9** (Display string: 'Line 9'): Starts when the specified CounterTriggerActivation condition is met on the chosen I/O Line.
    - **Line10** (Display string: 'Line 10'): Starts when the specified CounterTriggerActivation condition is met on the chosen I/O Line.
    - **Line11** (Display string: 'Line 11'): Starts when the specified CounterTriggerActivation condition is met on the chosen I/O Line.
    - **Line12** (Display string: 'Line 12'): Starts when the specified CounterTriggerActivation condition is met on the chosen I/O Line.
    - **Line13** (Display string: 'Line 13'): Starts when the specified CounterTriggerActivation condition is met on the chosen I/O Line.
    - **Line14** (Display string: 'Line 14'): Starts when the specified CounterTriggerActivation condition is met on the chosen I/O Line.
    - **Line15** (Display string: 'Line 15'): Starts when the specified CounterTriggerActivation condition is met on the chosen I/O Line.
    - **UserOutput3** (Display string: 'User Output 3'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **UserOutput4** (Display string: 'User Output 4'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **UserOutput5** (Display string: 'User Output 5'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **UserOutput6** (Display string: 'User Output 6'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **UserOutput7** (Display string: 'User Output 7'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **UserOutput8** (Display string: 'User Output 8'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **UserOutput9** (Display string: 'User Output 9'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **UserOutput10** (Display string: 'User Output 10'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **UserOutput11** (Display string: 'User Output 11'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **UserOutput12** (Display string: 'User Output 12'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **UserOutput13** (Display string: 'User Output 13'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **UserOutput14** (Display string: 'User Output 14'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **UserOutput15** (Display string: 'User Output 15'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **Counter3End** (Display string: 'Counter 3 End'): Starts with the reception of the Counter End.
    - **Counter4End** (Display string: 'Counter 4 End'): Starts with the reception of the Counter End.
    - **Counter5End** (Display string: 'Counter 5 End'): Starts with the reception of the Counter End.
    - **Counter6End** (Display string: 'Counter 6 End'): Starts with the reception of the Counter End.
    - **Counter7End** (Display string: 'Counter 7 End'): Starts with the reception of the Counter End.
    - **Counter8End** (Display string: 'Counter 8 End'): Starts with the reception of the Counter End.
    - **Counter9End** (Display string: 'Counter 9 End'): Starts with the reception of the Counter End.
    - **Counter10End** (Display string: 'Counter 10 End'): Starts with the reception of the Counter End.
    - **Counter11End** (Display string: 'Counter 11 End'): Starts with the reception of the Counter End.
    - **Counter12End** (Display string: 'Counter 12 End'): Starts with the reception of the Counter End.
    - **Counter13End** (Display string: 'Counter 13 End'): Starts with the reception of the Counter End.
    - **Counter14End** (Display string: 'Counter 14 End'): Starts with the reception of the Counter End.
    - **Counter15End** (Display string: 'Counter 15 End'): Starts with the reception of the Counter End.
    - **Counter16End** (Display string: 'Counter 16 End')
    - **Timer3End** (Display string: 'Timer 3 End'): Starts with the reception of the Timer End.
    - **Timer4End** (Display string: 'Timer 4 End'): Starts with the reception of the Timer End.
    - **Timer5End** (Display string: 'Timer 5 End'): Starts with the reception of the Timer End.
    - **Timer6End** (Display string: 'Timer 6 End'): Starts with the reception of the Timer End.
    - **Timer7End** (Display string: 'Timer 7 End'): Starts with the reception of the Timer End.
    - **Timer8End** (Display string: 'Timer 8 End'): Starts with the reception of the Timer End.
    - **Timer9End** (Display string: 'Timer 9 End'): Starts with the reception of the Timer End.
    - **Timer10End** (Display string: 'Timer 10 End'): Starts with the reception of the Timer End.
    - **Timer11End** (Display string: 'Timer 11 End'): Starts with the reception of the Timer End.
    - **Timer12End** (Display string: 'Timer 12 End'): Starts with the reception of the Timer End.
    - **Timer13End** (Display string: 'Timer 13 End'): Starts with the reception of the Timer End.
    - **Timer14End** (Display string: 'Timer 14 End'): Starts with the reception of the Timer End.
    - **Timer15End** (Display string: 'Timer 15 End'): Starts with the reception of the Timer End.
    - **Timer16End** (Display string: 'Timer 16 End')
    - **Action3** (Display string: 'Action 3'): Starts with the assertion of the chosen action signal.
    - **Action4** (Display string: 'Action 4'): Starts with the assertion of the chosen action signal.
    - **Action5** (Display string: 'Action 5'): Starts with the assertion of the chosen action signal.
    - **Action6** (Display string: 'Action 6'): Starts with the assertion of the chosen action signal.
    - **Action7** (Display string: 'Action 7'): Starts with the assertion of the chosen action signal.
    - **Action8** (Display string: 'Action 8'): Starts with the assertion of the chosen action signal.
    - **Action9** (Display string: 'Action 9'): Starts with the assertion of the chosen action signal.
    - **Action10** (Display string: 'Action 10'): Starts with the assertion of the chosen action signal.
    - **Action11** (Display string: 'Action 11'): Starts with the assertion of the chosen action signal.
    - **Action12** (Display string: 'Action 12'): Starts with the assertion of the chosen action signal.
    - **Action13** (Display string: 'Action 13'): Starts with the assertion of the chosen action signal.
    - **Action14** (Display string: 'Action 14'): Starts with the assertion of the chosen action signal.
    - **Action15** (Display string: 'Action 15'): Starts with the assertion of the chosen action signal.
    - **Action16** (Display string: 'Action 16')
    - **mvLogicGateOR1Output** (Display string: 'mv Logic Gate OR 1 Output')
    - **mvLogicGateOR2Output** (Display string: 'mv Logic Gate OR 2 Output')
    - **mvLogicGateOR3Output** (Display string: 'mv Logic Gate OR 3 Output')
    - **mvLogicGateOR4Output** (Display string: 'mv Logic Gate OR 4 Output')
    - **mvReadOutActive** (Display string: 'mv Read Out Active')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    counterTriggerActivation = property(lib_mvIMPACT_acquire.CounterAndTimerControl_counterTriggerActivation_get, doc=r"""
    An enumerated integer property. Selects the activation mode of the trigger to start the Counter.
    Selects the activation mode of the trigger to start the Counter.

    The following string values might be valid for this feature:
    - **RisingEdge** (Display string: 'Rising Edge'): Starts counting on the Rising Edge of the selected trigger signal.
    - **FallingEdge** (Display string: 'Falling Edge'): Starts counting on the Falling Edge of the selected trigger signal.
    - **AnyEdge** (Display string: 'Any Edge'): Starts counting on the Falling or rising Edge of the selected trigger signal.
    - **LevelHigh** (Display string: 'Level High'): Counts as long as the selected trigger signal level is High.
    - **LevelLow** (Display string: 'Level Low'): Counts as long as the selected trigger signal level is Low.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    timerSelector = property(lib_mvIMPACT_acquire.CounterAndTimerControl_timerSelector_get, doc=r"""
    An enumerated integer property. Selects which Timer to configure.
    Selects which Timer to configure.

    The following string values might be valid for this feature:
    - **Timer0** (Display string: 'Timer 0'): Selects the Timer 0.
    - **Timer1** (Display string: 'Timer 1'): Selects the Timer 1.
    - **Timer2** (Display string: 'Timer 2'): Selects the Timer 2.
    - **Timer**#3# (Display string: 'Timer #3#'): Selects the Timer #3#.
    - **Timer3** (Display string: 'Timer 3'): Selects the Timer 3.
    - **Timer4** (Display string: 'Timer 4'): Selects the Timer 4.
    - **Timer5** (Display string: 'Timer 5'): Selects the Timer 5.
    - **Timer6** (Display string: 'Timer 6'): Selects the Timer 6.
    - **Timer7** (Display string: 'Timer 7'): Selects the Timer 7.
    - **Timer8** (Display string: 'Timer 8'): Selects the Timer 8.
    - **Timer9** (Display string: 'Timer 9'): Selects the Timer 9.
    - **Timer10** (Display string: 'Timer 10'): Selects the Timer 10.
    - **Timer11** (Display string: 'Timer 11'): Selects the Timer 11.
    - **Timer12** (Display string: 'Timer 12'): Selects the Timer 12.
    - **Timer13** (Display string: 'Timer 13'): Selects the Timer 13.
    - **Timer14** (Display string: 'Timer 14'): Selects the Timer 14.
    - **Timer15** (Display string: 'Timer 15'): Selects the Timer 15.
    - **Timer16** (Display string: 'Timer 16')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    timerDuration = property(lib_mvIMPACT_acquire.CounterAndTimerControl_timerDuration_get, doc=r"""
    A floating point property. Sets the duration (in microseconds) of the Timer pulse.
    Sets the duration (in microseconds) of the Timer pulse.
    """)
    timerDelay = property(lib_mvIMPACT_acquire.CounterAndTimerControl_timerDelay_get, doc=r"""
    A floating point property. Sets the duration (in microseconds) of the delay to apply at the reception of a trigger before starting the Timer.
    Sets the duration (in microseconds) of the delay to apply at the reception of a trigger before starting the Timer.
    """)
    timerReset = property(lib_mvIMPACT_acquire.CounterAndTimerControl_timerReset_get, doc=r"""
    A method object. Does a software reset of the selected timer and starts it.
    Does a software reset of the selected timer and starts it. The timer starts immediately after the reset unless a timer trigger is active.
    """)
    timerValue = property(lib_mvIMPACT_acquire.CounterAndTimerControl_timerValue_get, doc=r"""
    A floating point property. Reads or writes the current value (in microseconds) of the selected Timer.
    Reads or writes the current value (in microseconds) of the selected Timer.
    """)
    timerStatus = property(lib_mvIMPACT_acquire.CounterAndTimerControl_timerStatus_get, doc=r"""
    An enumerated integer property. Returns the current status of the Timer.
    Returns the current status of the Timer.

    The following string values might be valid for this feature:
    - **TimerIdle** (Display string: 'Timer Idle'): The Timer is idle.
    - **TimerTriggerWait** (Display string: 'Timer Trigger Wait'): The Timer is waiting for a start trigger.
    - **TimerActive** (Display string: 'Timer Active'): The Timer is counting for the specified duration.
    - **TimerCompleted** (Display string: 'Timer Completed'): The Timer reached the TimerDuration count.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    timerTriggerSource = property(lib_mvIMPACT_acquire.CounterAndTimerControl_timerTriggerSource_get, doc=r"""
    An enumerated integer property. Selects the source of the trigger to start the Timer.
    Selects the source of the trigger to start the Timer.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off'): Disables the Timer trigger.
    - **AcquisitionTrigger** (Display string: 'Acquisition Trigger'): Starts with the reception of the Acquisition Trigger.
    - **AcquisitionTriggerMissed** (Display string: 'Acquisition Trigger Missed'): Starts with the reception of a missed Acquisition Trigger.
    - **AcquisitionStart** (Display string: 'Acquisition Start'): Starts with the reception of the Acquisition Start.
    - **AcquisitionEnd** (Display string: 'Acquisition End'): Starts with the reception of the Acquisition End.
    - **FrameTrigger** (Display string: 'Frame Trigger'): Starts with the reception of the Frame Start Trigger.
    - **FrameTriggerMissed** (Display string: 'Frame Trigger Missed'): Starts with the reception of a missed Frame Trigger.
    - **FrameStart** (Display string: 'Frame Start'): Starts with the reception of the Frame Start.
    - **FrameEnd** (Display string: 'Frame End'): Starts with the reception of the Frame End.
    - **FrameBurstStart** (Display string: 'Frame Burst Start'): Starts with the reception of the Frame Burst Start.
    - **FrameBurstEnd** (Display string: 'Frame Burst End'): Starts with the reception of the Frame Burst End.
    - **LineTrigger** (Display string: 'Line Trigger'): Starts with the reception of the Line Start Trigger.
    - **LineTriggerMissed** (Display string: 'Line Trigger Missed'): Starts with the reception of a missed Line Trigger.
    - **LineStart** (Display string: 'Line Start'): Starts with the reception of the Line Start.
    - **LineEnd** (Display string: 'Line End'): Starts with the reception of the Line End.
    - **ExposureStart** (Display string: 'Exposure Start'): Starts with the reception of the Exposure Start.
    - **ExposureEnd** (Display string: 'Exposure End'): Starts with the reception of the Exposure End.
    - **Line0** (Display string: 'Line 0'): Starts when the specified TimerTriggerActivation condition is met on the chosen I/O Line.
    - **Line1** (Display string: 'Line 1'): Starts when the specified TimerTriggerActivation condition is met on the chosen I/O Line.
    - **Line2** (Display string: 'Line 2'): Starts when the specified TimerTriggerActivation condition is met on the chosen I/O Line.
    - **Line**#3# (Display string: 'Line #3#'): Starts when the specified TimerTriggerActivation condition is met on the chosen I/O Line.
    - **UserOutput0** (Display string: 'User Output 0'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **UserOutput1** (Display string: 'User Output 1'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **UserOutput2** (Display string: 'User Output 2'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **UserOutput**#3# (Display string: 'User Output #3#'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **Counter0Start** (Display string: 'Counter 0 Start'): Starts with the reception of the Counter Start.
    - **Counter1Start** (Display string: 'Counter 1 Start'): Starts with the reception of the Counter Start.
    - **Counter2Start** (Display string: 'Counter 2 Start'): Starts with the reception of the Counter Start.
    - **Counter**#3#Start (Display string: 'Counter #3# Start'): Starts with the reception of the Counter Start.
    - **Counter0End** (Display string: 'Counter 0 End'): Starts with the reception of the Counter End.
    - **Counter1End** (Display string: 'Counter 1 End'): Starts with the reception of the Counter End.
    - **Counter2End** (Display string: 'Counter 2 End'): Starts with the reception of the Counter End.
    - **Counter**#3#End (Display string: 'Counter #3# End'): Starts with the reception of the Counter End.
    - **Timer0Start** (Display string: 'Timer 0 Start'): Starts with the reception of the Timer Start.
    - **Timer1Start** (Display string: 'Timer 1 Start'): Starts with the reception of the Timer Start.
    - **Timer2Start** (Display string: 'Timer 2 Start'): Starts with the reception of the Timer Start.
    - **Timer**#3#Start (Display string: 'Timer #3# Start'): Starts with the reception of the Timer Start.
    - **Timer0End** (Display string: 'Timer 0 End'): Starts with the reception of the Timer End. Note that a timer can retrigger itself to achieve a free running Timer.
    - **Timer1End** (Display string: 'Timer 1 End'): Starts with the reception of the Timer End. Note that a timer can retrigger itself to achieve a free running Timer.
    - **Timer2End** (Display string: 'Timer 2 End'): Starts with the reception of the Timer End. Note that a timer can retrigger itself to achieve a free running Timer.
    - **Timer**#3#End (Display string: 'Timer #3# End'): Starts with the reception of the Timer End. Note that a timer can retrigger itself to achieve a free running Timer.
    - **Encoder0** (Display string: 'Encoder 0'): Starts with the reception of the Encoder output signal.
    - **Encoder1** (Display string: 'Encoder 1'): Starts with the reception of the Encoder output signal.
    - **Encoder2** (Display string: 'Encoder 2'): Starts with the reception of the Encoder output signal.
    - **Encoder**#3# (Display string: 'Encoder #3#'): Starts with the reception of the Encoder output signal.
    - **LogicBlock0** (Display string: 'Logic Block 0'): Starts with the reception of the Logic Block output signal.
    - **LogicBlock1** (Display string: 'Logic Block 1'): Starts with the reception of the Logic Block output signal.
    - **LogicBlock2** (Display string: 'Logic Block 2'): Starts with the reception of the Logic Block output signal.
    - **LogicBlock**#3# (Display string: 'Logic Block #3#'): Starts with the reception of the Logic Block output signal.
    - **SoftwareSignal0** (Display string: 'Software Signal 0'): Starts on the reception of the Software Signal.
    - **SoftwareSignal1** (Display string: 'Software Signal 1'): Starts on the reception of the Software Signal.
    - **SoftwareSignal2** (Display string: 'Software Signal 2'): Starts on the reception of the Software Signal.
    - **SoftwareSignal**#3# (Display string: 'Software Signal #3#'): Starts on the reception of the Software Signal.
    - **Action0** (Display string: 'Action 0'): Starts with the assertion of the chosen action signal.
    - **Action1** (Display string: 'Action 1'): Starts with the assertion of the chosen action signal.
    - **Action2** (Display string: 'Action 2'): Starts with the assertion of the chosen action signal.
    - **Action**#3# (Display string: 'Action #3#'): Starts with the assertion of the chosen action signal.
    - **LinkTrigger0** (Display string: 'Link Trigger 0'): Starts with the reception of the chosen Link Trigger.
    - **LinkTrigger1** (Display string: 'Link Trigger 1'): Starts with the reception of the chosen Link Trigger.
    - **LinkTrigger2** (Display string: 'Link Trigger 2'): Starts with the reception of the chosen Link Trigger.
    - **LinkTrigger**#3# (Display string: 'Link Trigger #3#'): Starts with the reception of the chosen Link Trigger.
    - **Line3** (Display string: 'Line 3'): Starts when the specified TimerTriggerActivation condition is met on the chosen I/O Line.
    - **Line4** (Display string: 'Line 4'): Starts when the specified TimerTriggerActivation condition is met on the chosen I/O Line.
    - **Line5** (Display string: 'Line 5'): Starts when the specified TimerTriggerActivation condition is met on the chosen I/O Line.
    - **Line6** (Display string: 'Line 6'): Starts when the specified TimerTriggerActivation condition is met on the chosen I/O Line.
    - **Line7** (Display string: 'Line 7'): Starts when the specified TimerTriggerActivation condition is met on the chosen I/O Line.
    - **Line8** (Display string: 'Line 8'): Starts when the specified TimerTriggerActivation condition is met on the chosen I/O Line.
    - **Line9** (Display string: 'Line 9'): Starts when the specified TimerTriggerActivation condition is met on the chosen I/O Line.
    - **Line10** (Display string: 'Line 10'): Starts when the specified TimerTriggerActivation condition is met on the chosen I/O Line.
    - **Line11** (Display string: 'Line 11'): Starts when the specified TimerTriggerActivation condition is met on the chosen I/O Line.
    - **Line12** (Display string: 'Line 12'): Starts when the specified TimerTriggerActivation condition is met on the chosen I/O Line.
    - **Line13** (Display string: 'Line 13'): Starts when the specified TimerTriggerActivation condition is met on the chosen I/O Line.
    - **Line14** (Display string: 'Line 14'): Starts when the specified TimerTriggerActivation condition is met on the chosen I/O Line.
    - **Line15** (Display string: 'Line 15'): Starts when the specified TimerTriggerActivation condition is met on the chosen I/O Line.
    - **UserOutput3** (Display string: 'User Output 3'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **UserOutput4** (Display string: 'User Output 4'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **UserOutput5** (Display string: 'User Output 5'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **UserOutput6** (Display string: 'User Output 6'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **UserOutput7** (Display string: 'User Output 7'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **Counter3End** (Display string: 'Counter 3 End'): Starts with the reception of the Counter End.
    - **Counter4End** (Display string: 'Counter 4 End'): Starts with the reception of the Counter End.
    - **Counter5End** (Display string: 'Counter 5 End'): Starts with the reception of the Counter End.
    - **Counter6End** (Display string: 'Counter 6 End'): Starts with the reception of the Counter End.
    - **Counter7End** (Display string: 'Counter 7 End'): Starts with the reception of the Counter End.
    - **Counter8End** (Display string: 'Counter 8 End'): Starts with the reception of the Counter End.
    - **Counter9End** (Display string: 'Counter 9 End'): Starts with the reception of the Counter End.
    - **Counter10End** (Display string: 'Counter 10 End'): Starts with the reception of the Counter End.
    - **Counter11End** (Display string: 'Counter 11 End'): Starts with the reception of the Counter End.
    - **Counter12End** (Display string: 'Counter 12 End'): Starts with the reception of the Counter End.
    - **Counter13End** (Display string: 'Counter 13 End'): Starts with the reception of the Counter End.
    - **Counter14End** (Display string: 'Counter 14 End'): Starts with the reception of the Counter End.
    - **Counter15End** (Display string: 'Counter 15 End'): Starts with the reception of the Counter End.
    - **Counter16End** (Display string: 'Counter 16 End')
    - **Timer3End** (Display string: 'Timer 3 End'): Starts with the reception of the Timer End. Note that a timer can retrigger itself to achieve a free running Timer.
    - **Timer4End** (Display string: 'Timer 4 End'): Starts with the reception of the Timer End. Note that a timer can retrigger itself to achieve a free running Timer.
    - **Timer5End** (Display string: 'Timer 5 End'): Starts with the reception of the Timer End. Note that a timer can retrigger itself to achieve a free running Timer.
    - **Timer6End** (Display string: 'Timer 6 End'): Starts with the reception of the Timer End. Note that a timer can retrigger itself to achieve a free running Timer.
    - **Timer7End** (Display string: 'Timer 7 End'): Starts with the reception of the Timer End. Note that a timer can retrigger itself to achieve a free running Timer.
    - **Timer8End** (Display string: 'Timer 8 End'): Starts with the reception of the Timer End. Note that a timer can retrigger itself to achieve a free running Timer.
    - **Timer9End** (Display string: 'Timer 9 End'): Starts with the reception of the Timer End. Note that a timer can retrigger itself to achieve a free running Timer.
    - **Timer10End** (Display string: 'Timer 10 End'): Starts with the reception of the Timer End. Note that a timer can retrigger itself to achieve a free running Timer.
    - **Timer11End** (Display string: 'Timer 11 End'): Starts with the reception of the Timer End. Note that a timer can retrigger itself to achieve a free running Timer.
    - **Timer12End** (Display string: 'Timer 12 End'): Starts with the reception of the Timer End. Note that a timer can retrigger itself to achieve a free running Timer.
    - **Timer13End** (Display string: 'Timer 13 End'): Starts with the reception of the Timer End. Note that a timer can retrigger itself to achieve a free running Timer.
    - **Timer14End** (Display string: 'Timer 14 End'): Starts with the reception of the Timer End. Note that a timer can retrigger itself to achieve a free running Timer.
    - **Timer15End** (Display string: 'Timer 15 End'): Starts with the reception of the Timer End. Note that a timer can retrigger itself to achieve a free running Timer.
    - **Timer16End** (Display string: 'Timer 16 End')
    - **Action3** (Display string: 'Action 3'): Starts with the assertion of the chosen action signal.
    - **Action4** (Display string: 'Action 4'): Starts with the assertion of the chosen action signal.
    - **Action5** (Display string: 'Action 5'): Starts with the assertion of the chosen action signal.
    - **Action6** (Display string: 'Action 6'): Starts with the assertion of the chosen action signal.
    - **Action7** (Display string: 'Action 7'): Starts with the assertion of the chosen action signal.
    - **Action8** (Display string: 'Action 8'): Starts with the assertion of the chosen action signal.
    - **Action9** (Display string: 'Action 9'): Starts with the assertion of the chosen action signal.
    - **Action10** (Display string: 'Action 10'): Starts with the assertion of the chosen action signal.
    - **Action11** (Display string: 'Action 11'): Starts with the assertion of the chosen action signal.
    - **Action12** (Display string: 'Action 12'): Starts with the assertion of the chosen action signal.
    - **Action13** (Display string: 'Action 13'): Starts with the assertion of the chosen action signal.
    - **Action14** (Display string: 'Action 14'): Starts with the assertion of the chosen action signal.
    - **Action15** (Display string: 'Action 15'): Starts with the assertion of the chosen action signal.
    - **Action16** (Display string: 'Action 16')
    - **mvLogicGateOR1Output** (Display string: 'mv Logic Gate OR 1 Output')
    - **mvLogicGateOR2Output** (Display string: 'mv Logic Gate OR 2 Output')
    - **mvLogicGateOR3Output** (Display string: 'mv Logic Gate OR 3 Output')
    - **mvLogicGateOR4Output** (Display string: 'mv Logic Gate OR 4 Output')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    timerTriggerActivation = property(lib_mvIMPACT_acquire.CounterAndTimerControl_timerTriggerActivation_get, doc=r"""
    An enumerated integer property. Selects the activation mode of the trigger to start the Timer.
    Selects the activation mode of the trigger to start the Timer.

    The following string values might be valid for this feature:
    - **RisingEdge** (Display string: 'Rising Edge'): Starts counting on the Rising Edge of the selected trigger signal.
    - **FallingEdge** (Display string: 'Falling Edge'): Starts counting on the Falling Edge of the selected trigger signal.
    - **AnyEdge** (Display string: 'Any Edge'): Starts counting on the Falling or Rising Edge of the selected trigger signal.
    - **LevelHigh** (Display string: 'Level High'): Counts as long as the selected trigger signal level is High.
    - **LevelLow** (Display string: 'Level Low'): Counts as long as the selected trigger signal level is Low.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    timerTriggerArmDelay = property(lib_mvIMPACT_acquire.CounterAndTimerControl_timerTriggerArmDelay_get, doc=r"""
    A floating point property. Sets the minimum period between two valid timer triggers.
    Sets the minimum period between two valid timer triggers.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_CounterAndTimerControl

# Register CounterAndTimerControl in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.CounterAndTimerControl_swigregister(CounterAndTimerControl)

class EncoderControl(object):
    r"""
    Category that contains the quadrature Encoder Control features.
    A category that contains the quadrature Encoder Control features.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::GenICam::EncoderControl** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.EncoderControl_swiginit(self, lib_mvIMPACT_acquire.new_EncoderControl(*args))
    encoderSelector = property(lib_mvIMPACT_acquire.EncoderControl_encoderSelector_get, doc=r"""
    An enumerated integer property. Selects which Encoder to configure.
    Selects which Encoder to configure.

    The following string values might be valid for this feature:
    - **Encoder0** (Display string: 'Encoder 0'): Selects Encoder 0.
    - **Encoder1** (Display string: 'Encoder 1'): Selects Encoder 1.
    - **Encoder2** (Display string: 'Encoder 2'): Selects Encoder 2.
    - **Encoder**#3# (Display string: 'Encoder #3#'): Selects Encoder #3#.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    encoderSourceA = property(lib_mvIMPACT_acquire.EncoderControl_encoderSourceA_get, doc=r"""
    An enumerated integer property. Selects the signal which will be the source of the A input of the Encoder.
    Selects the signal which will be the source of the A input of the Encoder.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off'): Counter is stopped.
    - **Line0** (Display string: 'Line 0'): Encoder Forward input is taken from the chosen I/O Line.
    - **Line1** (Display string: 'Line 1'): Encoder Forward input is taken from the chosen I/O Line.
    - **Line2** (Display string: 'Line 2'): Encoder Forward input is taken from the chosen I/O Line.
    - **Line**#3# (Display string: 'Line #3#'): Encoder Forward input is taken from the chosen I/O Line.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    encoderSourceB = property(lib_mvIMPACT_acquire.EncoderControl_encoderSourceB_get, doc=r"""
    An enumerated integer property. Selects the signal which will be the source of the B input of the Encoder.
    Selects the signal which will be the source of the B input of the Encoder.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off'): Counter is stopped.
    - **Line0** (Display string: 'Line 0'): Encoder Reverse input is taken from the chosen I/O Line.
    - **Line1** (Display string: 'Line 1'): Encoder Reverse input is taken from the chosen I/O Line.
    - **Line2** (Display string: 'Line 2'): Encoder Reverse input is taken from the chosen I/O Line.
    - **Line**#3# (Display string: 'Line #3#'): Encoder Reverse input is taken from the chosen I/O Line.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    encoderMode = property(lib_mvIMPACT_acquire.EncoderControl_encoderMode_get, doc=r"""
    An enumerated integer property. Selects if the count of encoder uses FourPhase mode with jitter filtering or the HighResolution mode without jitter filtering.
    Selects if the count of encoder uses FourPhase mode with jitter filtering or the HighResolution mode without jitter filtering.

    The following string values might be valid for this feature:
    - **FourPhase** (Display string: 'Four Phase'): The counter increments or decrements 1 for every full quadrature cycle with jitter filtering.
    - **HighResolution** (Display string: 'High Resolution'): The counter increments or decrements every quadrature phase for high resolution counting, but without jitter filtering.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    encoderDivider = property(lib_mvIMPACT_acquire.EncoderControl_encoderDivider_get, doc=r"""
    An integer property. Sets how many Encoder increments/decrements are needed to generate an Encoder output pulse signal.
    Sets how many Encoder increments/decrements are needed to generate an Encoder output pulse signal.
    """)
    encoderOutputMode = property(lib_mvIMPACT_acquire.EncoderControl_encoderOutputMode_get, doc=r"""
    An enumerated integer property. Selects the conditions for the Encoder interface to generate a valid Encoder output signal.
    Selects the conditions for the Encoder interface to generate a valid Encoder output signal.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off'): No output pulse are generated.
    - **PositionUp** (Display string: 'Position Up'): Output pulses are generated at all new positions in the positive direction. If the encoder reverses no output pulse are generated until it has again passed the position where the reversal started.
    - **PositionDown** (Display string: 'Position Down'): Output pulses are generated at all new positions in the negative direction. If the encoder reverses no output pulse are generated until it has again passed the position where the reversal started.
    - **DirectionUp** (Display string: 'Direction Up'): Output pulses are generated at all position increments in the positive direction while ignoring negative direction motion.
    - **DirectionDown** (Display string: 'Direction Down'): Output pulses are generated at all position increments in the negative direction while ignoring positive direction motion.
    - **Motion** (Display string: 'Motion'): Output pulses are generated at all motion increments in both directions.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.

    The following figure explains the different **encoderOutputModes**


       Image: EventControl.png
        encoderOutputModes

    """)
    encoderStatus = property(lib_mvIMPACT_acquire.EncoderControl_encoderStatus_get, doc=r"""
    An enumerated integer property. Returns the motion status of the encoder.
    Returns the motion status of the encoder.

    The following string values might be valid for this feature:
    - **EncoderUp** (Display string: 'Encoder Up'): The encoder counter last incremented.
    - **EncoderDown** (Display string: 'Encoder Down'): The encoder counter last decremented.
    - **EncoderIdle** (Display string: 'Encoder Idle'): The encoder is not active.
    - **EncoderStatic** (Display string: 'Encoder Static'): No motion within the EncoderTimeout time.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    encoderTimeout = property(lib_mvIMPACT_acquire.EncoderControl_encoderTimeout_get, doc=r"""
    A floating point property. Sets the maximum time interval between encoder counter increments before the status turns to static.
    Sets the maximum time interval between encoder counter increments before the status turns to static.
    """)
    encoderResetSource = property(lib_mvIMPACT_acquire.EncoderControl_encoderResetSource_get, doc=r"""
    An enumerated integer property. Selects the signals that will be the source to reset the Encoder.
    Selects the signals that will be the source to reset the Encoder.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off'): Disable the Encoder Reset trigger.
    - **AcquisitionTrigger** (Display string: 'Acquisition Trigger'): Resets with the reception of the Acquisition Trigger.
    - **AcquisitionTriggerMissed** (Display string: 'Acquisition Trigger Missed'): Resets with the reception of a missed Acquisition Trigger.
    - **AcquisitionStart** (Display string: 'Acquisition Start'): Resets with the reception of the Acquisition Start.
    - **AcquisitionEnd** (Display string: 'Acquisition End'): Resets with the reception of the Acquisition End.
    - **FrameTrigger** (Display string: 'Frame Trigger'): Resets with the reception of the Frame Start Trigger.
    - **FrameTriggerMissed** (Display string: 'Frame Trigger Missed'): Resets with the reception of a missed Frame Trigger.
    - **FrameStart** (Display string: 'Frame Start'): Resets with the reception of the Frame Start.
    - **FrameEnd** (Display string: 'Frame End'): Resets with the reception of the Frame End.
    - **ExposureStart** (Display string: 'Exposure Start'): Resets with the reception of the Exposure Start.
    - **ExposureEnd** (Display string: 'Exposure End'): Resets with the reception of the Exposure End.
    - **Line0** (Display string: 'Line 0'): Resets by the chosen I/O Line.
    - **Line1** (Display string: 'Line 1'): Resets by the chosen I/O Line.
    - **Line2** (Display string: 'Line 2'): Resets by the chosen I/O Line.
    - **Line**#3# (Display string: 'Line #3#'): Resets by the chosen I/O Line.
    - **UserOutput0** (Display string: 'User Output 0'): Resets by the chosen User Output bit.
    - **UserOutput1** (Display string: 'User Output 1'): Resets by the chosen User Output bit.
    - **UserOutput2** (Display string: 'User Output 2'): Resets by the chosen User Output bit.
    - **UserOutput**#3# (Display string: 'User Output #3#'): Resets by the chosen User Output bit.
    - **Counter0Start** (Display string: 'Counter 0 Start'): Resets with the reception of the Counter Start.
    - **Counter1Start** (Display string: 'Counter 1 Start'): Resets with the reception of the Counter Start.
    - **Counter2Start** (Display string: 'Counter 2 Start'): Resets with the reception of the Counter Start.
    - **Counter**#3#Start (Display string: 'Counter #3# Start'): Resets with the reception of the Counter Start.
    - **Counter0End** (Display string: 'Counter 0 End'): Resets with the reception of the Counter End.
    - **Counter1End** (Display string: 'Counter 1 End'): Resets with the reception of the Counter End.
    - **Counter2End** (Display string: 'Counter 2 End'): Resets with the reception of the Counter End.
    - **Counter**#3#End (Display string: 'Counter #3# End'): Resets with the reception of the Counter End.
    - **Timer0Start** (Display string: 'Timer 0 Start'): Resets with the reception of the Timer Start.
    - **Timer1Start** (Display string: 'Timer 1 Start'): Resets with the reception of the Timer Start.
    - **Timer2Start** (Display string: 'Timer 2 Start'): Resets with the reception of the Timer Start.
    - **Timer**#3#Start (Display string: 'Timer #3# Start'): Resets with the reception of the Timer Start.
    - **Timer0End** (Display string: 'Timer 0 End'): Resets with the reception of the Timer End.
    - **Timer1End** (Display string: 'Timer 1 End'): Resets with the reception of the Timer End.
    - **Timer2End** (Display string: 'Timer 2 End'): Resets with the reception of the Timer End.
    - **Timer**#3#End (Display string: 'Timer #3# End'): Resets with the reception of the Timer End.
    - **LogicBlock0** (Display string: 'Logic Block 0'): Reset by the choosen Logic Block signal.
    - **LogicBlock1** (Display string: 'Logic Block 1'): Reset by the choosen Logic Block signal.
    - **LogicBlock2** (Display string: 'Logic Block 2'): Reset by the choosen Logic Block signal.
    - **LogicBlock**#3# (Display string: 'Logic Block #3#'): Reset by the choosen Logic Block signal.
    - **SoftwareSignal0** (Display string: 'Software Signal 0'): Resets on the reception of the Software Signal.
    - **SoftwareSignal1** (Display string: 'Software Signal 1'): Resets on the reception of the Software Signal.
    - **SoftwareSignal2** (Display string: 'Software Signal 2'): Resets on the reception of the Software Signal.
    - **SoftwareSignal**#3# (Display string: 'Software Signal #3#'): Resets on the reception of the Software Signal.
    - **Action0** (Display string: 'Action 0'): Resets on assertions of the chosen action signal (Broadcasted signal on the transport layer).
    - **Action1** (Display string: 'Action 1'): Resets on assertions of the chosen action signal (Broadcasted signal on the transport layer).
    - **Action2** (Display string: 'Action 2'): Resets on assertions of the chosen action signal (Broadcasted signal on the transport layer).
    - **Action**#3# (Display string: 'Action #3#'): Resets on assertions of the chosen action signal (Broadcasted signal on the transport layer).
    - **LinkTrigger0** (Display string: 'Link Trigger 0'): Resets on the reception of the chosen Link Trigger (received from the transport layer).
    - **LinkTrigger1** (Display string: 'Link Trigger 1'): Resets on the reception of the chosen Link Trigger (received from the transport layer).
    - **LinkTrigger2** (Display string: 'Link Trigger 2'): Resets on the reception of the chosen Link Trigger (received from the transport layer).
    - **LinkTrigger**#3# (Display string: 'Link Trigger #3#'): Resets on the reception of the chosen Link Trigger (received from the transport layer).

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    encoderResetActivation = property(lib_mvIMPACT_acquire.EncoderControl_encoderResetActivation_get, doc=r"""
    An enumerated integer property. Selects the Activation mode of the Encoder Reset Source signal.
    Selects the Activation mode of the Encoder Reset Source signal.

    The following string values might be valid for this feature:
    - **RisingEdge** (Display string: 'Rising Edge'): Resets the Encoder on the Rising Edge of the signal.
    - **FallingEdge** (Display string: 'Falling Edge'): Resets the Encoder on the Falling Edge of the signal.
    - **AnyEdge** (Display string: 'Any Edge'): Resets the Encoder on the Falling or rising Edge of the selected signal.
    - **LevelHigh** (Display string: 'Level High'): Resets the Encoder as long as the selected signal level is High.
    - **LevelLow** (Display string: 'Level Low'): Resets the Encoder as long as the selected signal level is Low.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    encoderReset = property(lib_mvIMPACT_acquire.EncoderControl_encoderReset_get, doc=r"""
    A method object. Does a software reset of the selected Encoder and starts it.
    Does a software reset of the selected Encoder and starts it. The Encoder starts counting events immediately after the reset. EncoderReset can be used to reset the Encoder independently from the EncoderResetSource.
    """)
    encoderValue = property(lib_mvIMPACT_acquire.EncoderControl_encoderValue_get, doc=r"""
    An integer property. Reads or writes the current value of the position counter of the selected Encoder.
    Reads or writes the current value of the position counter of the selected Encoder.
    """)
    encoderValueAtReset = property(lib_mvIMPACT_acquire.EncoderControl_encoderValueAtReset_get, doc=r"""
    An integer property. Reads the value of the of the position counter of the selected Encoder when it was reset by a signal or by an explicit EncoderReset command.
    Reads the value of the of the position counter of the selected Encoder when it was reset by a signal or by an explicit EncoderReset command.
    """)
    encoderResolution = property(lib_mvIMPACT_acquire.EncoderControl_encoderResolution_get, doc=r"""
    A floating point property. Defines the resolution of one encoder step.
    Defines the resolution of one encoder step.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_EncoderControl

# Register EncoderControl in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.EncoderControl_swigregister(EncoderControl)

class LogicBlockControl(object):
    r"""
    Category that contains the Logic Block control features.
    A category that contains the Logic Block control features.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::GenICam::LogicBlockControl** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.LogicBlockControl_swiginit(self, lib_mvIMPACT_acquire.new_LogicBlockControl(*args))
    logicBlockSelector = property(lib_mvIMPACT_acquire.LogicBlockControl_logicBlockSelector_get, doc=r"""
    An enumerated integer property. Specifies the Logic Block to configure.
    Specifies the Logic Block to configure.

    The following string values might be valid for this feature:
    - **LogicBlock0** (Display string: 'Logic Block 0'): Logic Block 0 is selected.
    - **LogicBlock1** (Display string: 'Logic Block 1'): Logic Block 1 is selected.
    - **LogicBlock2** (Display string: 'Logic Block 2'): Logic Block 2 is selected.
    - **LogicBlock**#3# (Display string: 'Logic Block #3#'): Logic Block #3# is selected.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    logicBlockFunction = property(lib_mvIMPACT_acquire.LogicBlockControl_logicBlockFunction_get, doc=r"""
    An enumerated integer property. Selects the combinational logic Function of the Logic Block to configure.
    Selects the combinational logic Function of the Logic Block to configure.

    The following string values might be valid for this feature:
    - **AND** (Display string: 'AND'): Selects a Logic Block that does the logical AND of all the inputs.
    - **OR** (Display string: 'OR'): Selects a Logic Block that does the logical OR of all the inputs.
    - **LUT** (Display string: 'LUT'): Selects a Logic Block that does a Look Up Table Transformation on all the inputs.
    - **LatchedLUT** (Display string: 'Latched LUT'): Selects a Logic Block with 2 LUTs as inputs to a Flip-Flop.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    logicBlockInputNumber = property(lib_mvIMPACT_acquire.LogicBlockControl_logicBlockInputNumber_get, doc=r"""
    An integer property. Specifies the number of active signal inputs of the Logic Block.
    Specifies the number of active signal inputs of the Logic Block.
    """)
    logicBlockInputSelector = property(lib_mvIMPACT_acquire.LogicBlockControl_logicBlockInputSelector_get, doc=r"""
    An integer property. Selects the Logic Block's input to configure.
    Selects the Logic Block's input to configure.
    """)
    logicBlockInputSource = property(lib_mvIMPACT_acquire.LogicBlockControl_logicBlockInputSource_get, doc=r"""
    An enumerated integer property. Selects the source signal for the input into the Logic Block.
    Selects the source signal for the input into the Logic Block. True or False indicates the input is forced constant.

    The following string values might be valid for this feature:
    - **True** (Display string: 'True'): Logic Block input is forced to One.
    - **False** (Display string: 'False'): Logic Block input is forced to Zero.
    - **AcquisitionTriggerWait** (Display string: 'Acquisition Trigger Wait'): Device is currently waiting for a trigger for the capture of one or many Frames.
    - **AcquisitionTrigger** (Display string: 'Acquisition Trigger'): Device is currently waiting for a trigger for the capture of one or many Frames.
    - **AcquisitionTriggerMissed** (Display string: 'Acquisition Trigger Missed'): Device has missed a trigger for the capture of one or many Frames.
    - **AcquisitionActive** (Display string: 'Acquisition Active'): Device is acquiring one or many Frames.
    - **FrameTriggerWait** (Display string: 'Frame Trigger Wait'): Device is currently waiting for a Frame start trigger.
    - **FrameTrigger** (Display string: 'Frame Trigger'): Device is currently waiting for a Frame start trigger.
    - **FrameTriggerMissed** (Display string: 'Frame Trigger Missed'): Device has missed a Frame start trigger.
    - **FrameActive** (Display string: 'Frame Active'): Device is currently doing the capture of a Frame.
    - **ExposureActive** (Display string: 'Exposure Active'): Device is doing the exposure of a Frame (or Line).
    - **LineTriggerWait** (Display string: 'Line Trigger Wait'): Device is currently waiting for a Line start trigger.
    - **LineTrigger** (Display string: 'Line Trigger'): Device is currently waiting for a Line start trigger.
    - **LineTriggerMissed** (Display string: 'Line Trigger Missed'): Device has missed a Line start trigger.
    - **LineActive** (Display string: 'Line Active'): Device is currently doing the capture of a Line.
    - **Counter0Active** (Display string: 'Counter 0 Active'): The chosen counter is in active state (counting).
    - **Counter1Active** (Display string: 'Counter 1 Active'): The chosen counter is in active state (counting).
    - **Counter2Active** (Display string: 'Counter 2 Active'): The chosen counter is in active state (counting).
    - **Counter**#3#Active (Display string: 'Counter #3# Active'): The chosen counter is in active state (counting).
    - **Timer0Active** (Display string: 'Timer 0 Active'): The chosen Timer is in active state.
    - **Timer1Active** (Display string: 'Timer 1 Active'): The chosen Timer is in active state.
    - **Timer2Active** (Display string: 'Timer 2 Active'): The chosen Timer is in active state.
    - **Timer**#3#Active (Display string: 'Timer #3# Active'): The chosen Timer is in active state.
    - **Encoder0** (Display string: 'Encoder 0'): The chosen Encoder Output state.
    - **Encoder1** (Display string: 'Encoder 1'): The chosen Encoder Output state.
    - **Encoder2** (Display string: 'Encoder 2'): The chosen Encoder Output state.
    - **Encoder**#3# (Display string: 'Encoder #3#'): The chosen Encoder Output state.
    - **LogicBlock0** (Display string: 'Logic Block 0'): The choosen Logic Block output state.
    - **LogicBlock1** (Display string: 'Logic Block 1'): The choosen Logic Block output state.
    - **LogicBlock2** (Display string: 'Logic Block 2'): The choosen Logic Block output state.
    - **LogicBlock**#3# (Display string: 'Logic Block #3#'): The choosen Logic Block output state.
    - **SoftwareSignal0** (Display string: 'Software Signal 0'): The choosen Software Signal output state.
    - **SoftwareSignal1** (Display string: 'Software Signal 1'): The choosen Software Signal output state.
    - **SoftwareSignal2** (Display string: 'Software Signal 2'): The choosen Software Signal output state.
    - **SoftwareSignal**#3# (Display string: 'Software Signal #3#'): The choosen Software Signal output state.
    - **Line0** (Display string: 'Line 0'): The chosen I/OLine state.
    - **Line1** (Display string: 'Line 1'): The chosen I/OLine state.
    - **Line2** (Display string: 'Line 2'): The chosen I/OLine state.
    - **Line**#3# (Display string: 'Line #3#'): The chosen I/OLine state.
    - **UserOutput0** (Display string: 'User Output 0'): The chosen User Output bit state as defined by its current UserOutputValue.
    - **UserOutput1** (Display string: 'User Output 1'): The chosen User Output bit state as defined by its current UserOutputValue.
    - **UserOutput2** (Display string: 'User Output 2'): The chosen User Output bit state as defined by its current UserOutputValue.
    - **UserOutput**#3# (Display string: 'User Output #3#'): The chosen User Output bit state as defined by its current UserOutputValue.
    - **Stream0TransferActive** (Display string: 'Stream 0 Transfer Active'): Transfer on the stream is active.
    - **Stream1TransferActive** (Display string: 'Stream 1 Transfer Active'): Transfer on the stream is active.
    - **Stream**#2#TransferActive (Display string: 'Stream #2# Transfer Active'): Transfer on the stream is active.
    - **Stream0TransferPaused** (Display string: 'Stream 0 Transfer Paused'): Transfer on the stream is paused.
    - **Stream1TransferPaused** (Display string: 'Stream 1 Transfer Paused'): Transfer on the stream is paused.
    - **Stream**#2#TransferPaused (Display string: 'Stream #2# Transfer Paused'): Transfer on the stream is paused.
    - **Stream0TransferStopping** (Display string: 'Stream 0 Transfer Stopping'): Transfer on the stream is stopping.
    - **Stream1TransferStopping** (Display string: 'Stream 1 Transfer Stopping'): Transfer on the stream is stopping.
    - **Stream**#2#TransferStopping (Display string: 'Stream #2# Transfer Stopping'): Transfer on the stream is stopping.
    - **Stream0TransferStopped** (Display string: 'Stream 0 Transfer Stopped'): Transfer on the stream is stopped.
    - **Stream1TransferStopped** (Display string: 'Stream 1 Transfer Stopped'): Transfer on the stream is stopped.
    - **Stream**#2#TransferStopped (Display string: 'Stream #2# Transfer Stopped'): Transfer on the stream is stopped.
    - **Stream0TransferOverflow** (Display string: 'Stream 0 Transfer Overflow'): Transfer on the stream is in overflow.
    - **Stream1TransferOverflow** (Display string: 'Stream 1 Transfer Overflow'): Transfer on the stream is in overflow.
    - **Stream**#2#TransferOverflow (Display string: 'Stream #2# Transfer Overflow'): Transfer on the stream is in overflow.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    logicBlockInputInverter = property(lib_mvIMPACT_acquire.LogicBlockControl_logicBlockInputInverter_get, doc=r"""
    A boolean property. Selects if the selected Logic Block Input source signal is inverted.
    Selects if the selected Logic Block Input source signal is inverted. This feature is not available when the LogicBlockInputSource is set to True or False.
    """)
    logicBlockLUTIndex = property(lib_mvIMPACT_acquire.LogicBlockControl_logicBlockLUTIndex_get, doc=r"""
    An integer property. Controls the index of the truth table to access in the selected LUT.
    Controls the index of the truth table to access in the selected LUT.
    """)
    logicBlockLUTValue = property(lib_mvIMPACT_acquire.LogicBlockControl_logicBlockLUTValue_get, doc=r"""
    A boolean property. Read or Write the Value associated with the entry at index LogicBlockLUTIndex of the selected LUT.
    Read or Write the Value associated with the entry at index LogicBlockLUTIndex of the selected LUT.
    """)
    logicBlockLUTValueAll = property(lib_mvIMPACT_acquire.LogicBlockControl_logicBlockLUTValueAll_get, doc=r"""
    An integer property. Sets the values of all the output bits of the selected LUT in one access ignoring LogicBlockLUTIndex.
    Sets the values of all the output bits of the selected LUT in one access ignoring LogicBlockLUTIndex. LogicBlockLUTValueAll value can be any binary number and each bit correspond to the output value for the corresponding index (i.e. Bit 0 = LUT Index 0 output binary value).
    """)
    logicBlockLUTSelector = property(lib_mvIMPACT_acquire.LogicBlockControl_logicBlockLUTSelector_get, doc=r"""
    An enumerated integer property. Selects which of the two LUTs to configure when the selected Logic Block is a Latched dual LUTs (i.e: LogicalBlockFunction = LatchedLUT).
    Selects which of the two LUTs to configure when the selected Logic Block is a Latched dual LUTs (i.e: LogicalBlockFunction = LatchedLUT).

    The following string values might be valid for this feature:
    - **Value** (Display string: 'Value'): Selects the LUT controlling the data input of the flip-flop.
    - **Enable** (Display string: 'Enable'): Selects the LUT controlling the enable input of the flip-flop.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_LogicBlockControl

# Register LogicBlockControl in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.LogicBlockControl_swigregister(LogicBlockControl)

class SoftwareSignalControl(object):
    r"""
    Category that contains the Software Signal Control features.
    A category that contains the Software Signal Control features.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::GenICam::SoftwareSignalControl** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.SoftwareSignalControl_swiginit(self, lib_mvIMPACT_acquire.new_SoftwareSignalControl(*args))
    softwareSignalSelector = property(lib_mvIMPACT_acquire.SoftwareSignalControl_softwareSignalSelector_get, doc=r"""
    An enumerated integer property. Selects which Software Signal features to control.
    Selects which Software Signal features to control.

    The following string values might be valid for this feature:
    - **SoftwareSignal0** (Display string: 'Software Signal 0'): Selects the software generated signal to control.
    - **SoftwareSignal1** (Display string: 'Software Signal 1'): Selects the software generated signal to control.
    - **SoftwareSignal2** (Display string: 'Software Signal 2'): Selects the software generated signal to control.
    - **SoftwareSignal**#3# (Display string: 'Software Signal #3#'): Selects the software generated signal to control.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    softwareSignalPulse = property(lib_mvIMPACT_acquire.SoftwareSignalControl_softwareSignalPulse_get, doc=r"""
    A method object. Generates a pulse signal that can be used as a software trigger.
    Generates a pulse signal that can be used as a software trigger. This command can be used to trigger other modules that accept a SoftwareSignal as trigger source.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_SoftwareSignalControl

# Register SoftwareSignalControl in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.SoftwareSignalControl_swigregister(SoftwareSignalControl)

class ActionControl(object):
    r"""
    Category that contains the Action control features.
    A category that contains the Action control features.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::GenICam::ActionControl** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.ActionControl_swiginit(self, lib_mvIMPACT_acquire.new_ActionControl(*args))
    actionUnconditionalMode = property(lib_mvIMPACT_acquire.ActionControl_actionUnconditionalMode_get, doc=r"""
    An enumerated integer property. Enables the unconditional action command mode where action commands are processed even when the primary control channel is closed.
    Enables the unconditional action command mode where action commands are processed even when the primary control channel is closed.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off'): Unconditional mode is disabled.
    - **On** (Display string: 'On'): Unconditional mode is enabled.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    actionDeviceKey = property(lib_mvIMPACT_acquire.ActionControl_actionDeviceKey_get, doc=r"""
    An integer property. Provides the device key that allows the device to check the validity of action commands.
    Provides the device key that allows the device to check the validity of action commands. The device internal assertion of an action signal is only authorized if the ActionDeviceKey and the action device key value in the protocol message are equal.
    """)
    actionQueueSize = property(lib_mvIMPACT_acquire.ActionControl_actionQueueSize_get, doc=r"""
    An integer property. Indicates the size of the scheduled action commands queue.
    Indicates the size of the scheduled action commands queue. This number represents the maximum number of scheduled action commands that can be pending at a given point in time.
    """)
    actionSelector = property(lib_mvIMPACT_acquire.ActionControl_actionSelector_get, doc=r"""
    An integer property. Selects to which Action Signal further Action settings apply.
    Selects to which Action Signal further Action settings apply.
    """)
    actionGroupMask = property(lib_mvIMPACT_acquire.ActionControl_actionGroupMask_get, doc=r"""
    An integer property. Provides the mask that the device will use to validate the action on reception of the action protocol message.
    Provides the mask that the device will use to validate the action on reception of the action protocol message.
    """)
    actionGroupKey = property(lib_mvIMPACT_acquire.ActionControl_actionGroupKey_get, doc=r"""
    An integer property. Provides the key that the device will use to validate the action on reception of the action protocol message.
    Provides the key that the device will use to validate the action on reception of the action protocol message.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_ActionControl

# Register ActionControl in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.ActionControl_swigregister(ActionControl)

class EventControl(object):
    r"""
    Category that contains Event control features.
    A category that contains Event control features.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::GenICam::EventControl** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.EventControl_swiginit(self, lib_mvIMPACT_acquire.new_EventControl(*args))
    eventSelector = property(lib_mvIMPACT_acquire.EventControl_eventSelector_get, doc=r"""
    An enumerated integer property. Selects which Event to signal to the host application.
    Selects which Event to signal to the host application.

    The following string values might be valid for this feature:
    - **AcquisitionTrigger** (Display string: 'Acquisition Trigger'): Device just received a trigger for the Acquisition of one or many Frames.
    - **AcquisitionTriggerMissed** (Display string: 'Acquisition Trigger Missed'): Device just missed a trigger for the Acquisition of one or many Frames.
    - **AcquisitionStart** (Display string: 'Acquisition Start'): Device just started the Acquisition of one or many Frames.
    - **AcquisitionEnd** (Display string: 'Acquisition End'): Device just completed the Acquisition of one or many Frames.
    - **AcquisitionTransferStart** (Display string: 'Acquisition Transfer Start'): Device just started the transfer of one or many Frames.
    - **AcquisitionTransferEnd** (Display string: 'Acquisition Transfer End'): Device just completed the transfer of one or many Frames.
    - **AcquisitionError** (Display string: 'Acquisition Error'): Device just detected an error during the active Acquisition.
    - **FrameBurstStart** (Display string: 'Frame Burst Start'): Device just started the capture of a burst of Frames.
    - **FrameBurstEnd** (Display string: 'Frame Burst End'): Device just completed the capture of a burst of Frames.
    - **FrameTrigger** (Display string: 'Frame Trigger'): Device just received a trigger to start the capture of one Frame.
    - **FrameTriggerMissed** (Display string: 'Frame Trigger Missed'): Device just missed a trigger to start the capture of one Frame.
    - **FrameStart** (Display string: 'Frame Start'): Device just started the capture of one Frame.
    - **FrameEnd** (Display string: 'Frame End'): Device just completed the capture of one Frame.
    - **FrameTransferStart** (Display string: 'Frame Transfer Start'): Device just started the transfer of one Frame.
    - **FrameTransferEnd** (Display string: 'Frame Transfer End'): Device just completed the transfer of one Frame.
    - **LineTrigger** (Display string: 'Line Trigger'): Device just received a trigger to start the capture of one Line.
    - **LineTriggerMissed** (Display string: 'Line Trigger Missed'): Device just missed a trigger to start the capture of one Line.
    - **LineStart** (Display string: 'Line Start'): Device just started the capture of one Line.
    - **LineEnd** (Display string: 'Line End'): Device just completed the capture of one Line.
    - **ExposureStart** (Display string: 'Exposure Start'): Device just started the exposure of one Frame (or Line).
    - **ExposureEnd** (Display string: 'Exposure End'): Device just completed the exposure of one Frame (or Line).
    - **Stream0TransferStart** (Display string: 'Stream 0 Transfer Start'): Device just started the transfer of one or many Blocks.
    - **Stream0TransferEnd** (Display string: 'Stream 0 Transfer End'): Device just completed the transfer of one or many Blocks.
    - **Stream0TransferPause** (Display string: 'Stream 0 Transfer Pause'): Device just paused the transfer.
    - **Stream0TransferResume** (Display string: 'Stream 0 Transfer Resume'): Device just resumed the transfer.
    - **Stream0TransferBlockStart** (Display string: 'Stream 0 Transfer Block Start'): Device just started the transfer of one Block.
    - **Stream0TransferBlockEnd** (Display string: 'Stream 0 Transfer Block End'): Device just completed the transfer of one Block.
    - **Stream0TransferBlockTrigger** (Display string: 'Stream 0 Transfer Block Trigger'): Device just received a trigger to start the transfer of one Block.
    - **Stream0TransferBurstStart** (Display string: 'Stream 0 Transfer Burst Start'): Device just started the transfer of a burst of Blocks.
    - **Stream0TransferBurstEnd** (Display string: 'Stream 0 Transfer Burst End'): Device just completed the transfer of a burst of Blocks.
    - **Stream0TransferOverflow** (Display string: 'Stream 0 Transfer Overflow'): Device transfer queue overflowed.
    - **SequencerSetChange** (Display string: 'Sequencer Set Change'): Device sequencer set has changed.
    - **Counter0Start** (Display string: 'Counter 0 Start'): The event will be generated when counter 0 starts counting.
    - **Counter1Start** (Display string: 'Counter 1 Start'): The event will be generated when counter 1 starts counting.
    - **Counter**#2#Start (Display string: 'Counter #2# Start'): The event will be generated when counter #2# starts counting.
    - **Counter0End** (Display string: 'Counter 0 End'): The event will be generated when counter 0 ends counting.
    - **Counter1End** (Display string: 'Counter 1 End'): The event will be generated when counter 1 ends counting.
    - **Counter**#2#End (Display string: 'Counter #2# End'): The event will be generated when counter #2# ends counting.
    - **Timer0Start** (Display string: 'Timer 0 Start'): The event will be generated when Timer 0 starts counting.
    - **Timer1Start** (Display string: 'Timer 1 Start'): The event will be generated when Timer 1 starts counting.
    - **Timer**#2#Start (Display string: 'Timer #2# Start'): The event will be generated when Timer #2# starts counting.
    - **Timer0End** (Display string: 'Timer 0 End'): The event will be generated when Timer 0 ends counting.
    - **Timer1End** (Display string: 'Timer 1 End'): The event will be generated when Timer 1 ends counting.
    - **Timer**#2#End (Display string: 'Timer #2# End'): The event will be generated when Timer #2# ends counting.
    - **Encoder0Stopped** (Display string: 'Encoder 0 Stopped'): The event will be generated when the Encoder 0 stops for longer than EncoderTimeout.
    - **Encoder1Stopped** (Display string: 'Encoder 1 Stopped'): The event will be generated when the Encoder 1 stops for longer than EncoderTimeout.
    - **Encoder**#2#Stopped (Display string: 'Encoder #2# Stopped'): The event will be generated when the Encoder #2# stops for longer than EncoderTimeout.
    - **Encoder0Restarted** (Display string: 'Encoder 0 Restarted'): The event will be generated when the Encoder 0 restarts moving.
    - **Encoder1Restarted** (Display string: 'Encoder 1 Restarted'): The event will be generated when the Encoder 1 restarts moving.
    - **Encoder**#2#Restarted (Display string: 'Encoder #2# Restarted'): The event will be generated when the Encoder #2# restarts moving.
    - **Line0RisingEdge** (Display string: 'Line 0 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 0.
    - **Line1RisingEdge** (Display string: 'Line 1 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 1.
    - **Line**#2#RisingEdge (Display string: 'Line #2# Rising Edge'): The event will be generated when a Rising Edge is detected on the Line #2#.
    - **Line0FallingEdge** (Display string: 'Line 0 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 0.
    - **Line1FallingEdge** (Display string: 'Line 1 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 1.
    - **Line**#2#FallingEdge (Display string: 'Line #2# Falling Edge'): The event will be generated when a Falling Edge is detected on the Line #2#.
    - **Line0AnyEdge** (Display string: 'Line 0 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 0.
    - **Line1AnyEdge** (Display string: 'Line 1 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 1.
    - **Line**#2#AnyEdge (Display string: 'Line #2# Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line #2#.
    - **LinkTrigger0** (Display string: 'Link Trigger 0'): The event will be generated when a Rising Edge is detected on the LinkTrigger 0.
    - **LinkTrigger1** (Display string: 'Link Trigger 1'): The event will be generated when a Rising Edge is detected on the LinkTrigger 1.
    - **LinkTrigger**#2# (Display string: 'Link Trigger #2#'): The event will be generated when a Rising Edge is detected on the LinkTrigger #2#.
    - **LinkSpeedChange** (Display string: 'Link Speed Change'): The event will be generated when the link speed has changed.
    - **ActionLate** (Display string: 'Action Late'): The event will be generated when a valid scheduled action command is received and is scheduled to be executed at a time that is already past.
    - **Error** (Display string: 'Error'): Device just detected an error during the active Acquisition.
    - **Test** (Display string: 'Test'): The test event will be generated when the device receives the TestEventGenerate command (EventNotification for the Test event is always On).
    - **PrimaryApplicationSwitch** (Display string: 'Primary Application Switch'): The event will be generated when a primary application switchover has been granted (GigE Vision Specific).
    - **Counter2Start** (Display string: 'Counter 2 Start'): The event will be generated when counter 2 starts counting.
    - **Counter3Start** (Display string: 'Counter 3 Start'): The event will be generated when counter 3 starts counting.
    - **Counter4Start** (Display string: 'Counter 4 Start'): The event will be generated when counter 4 starts counting.
    - **Counter5Start** (Display string: 'Counter 5 Start'): The event will be generated when counter 5 starts counting.
    - **Counter6Start** (Display string: 'Counter 6 Start'): The event will be generated when counter 6 starts counting.
    - **Counter7Start** (Display string: 'Counter 7 Start'): The event will be generated when counter 7 starts counting.
    - **Counter8Start** (Display string: 'Counter 8 Start'): The event will be generated when counter 8 starts counting.
    - **Counter9Start** (Display string: 'Counter 9 Start'): The event will be generated when counter 9 starts counting.
    - **Counter10Start** (Display string: 'Counter 10 Start'): The event will be generated when counter 10 starts counting.
    - **Counter11Start** (Display string: 'Counter 11 Start'): The event will be generated when counter 11 starts counting.
    - **Counter12Start** (Display string: 'Counter 12 Start'): The event will be generated when counter 12 starts counting.
    - **Counter13Start** (Display string: 'Counter 13 Start'): The event will be generated when counter 13 starts counting.
    - **Counter14Start** (Display string: 'Counter 14 Start'): The event will be generated when counter 14 starts counting.
    - **Counter15Start** (Display string: 'Counter 15 Start'): The event will be generated when counter 15 starts counting.
    - **Counter2End** (Display string: 'Counter 2 End'): The event will be generated when counter 2 ends counting.
    - **Counter3End** (Display string: 'Counter 3 End'): The event will be generated when counter 3 ends counting.
    - **Counter4End** (Display string: 'Counter 4 End'): The event will be generated when counter 4 ends counting.
    - **Counter5End** (Display string: 'Counter 5 End'): The event will be generated when counter 5 ends counting.
    - **Counter6End** (Display string: 'Counter 6 End'): The event will be generated when counter 6 ends counting.
    - **Counter7End** (Display string: 'Counter 7 End'): The event will be generated when counter 7 ends counting.
    - **Counter8End** (Display string: 'Counter 8 End'): The event will be generated when counter 8 ends counting.
    - **Counter9End** (Display string: 'Counter 9 End'): The event will be generated when counter 9 ends counting.
    - **Counter10End** (Display string: 'Counter 10 End'): The event will be generated when counter 10 ends counting.
    - **Counter11End** (Display string: 'Counter 11 End'): The event will be generated when counter 11 ends counting.
    - **Counter12End** (Display string: 'Counter 12 End'): The event will be generated when counter 12 ends counting.
    - **Counter13End** (Display string: 'Counter 13 End'): The event will be generated when counter 13 ends counting.
    - **Counter14End** (Display string: 'Counter 14 End'): The event will be generated when counter 14 ends counting.
    - **Counter15End** (Display string: 'Counter 15 End'): The event will be generated when counter 15 ends counting.
    - **Timer2Start** (Display string: 'Timer 2 Start'): The event will be generated when Timer 2 starts counting.
    - **Timer3Start** (Display string: 'Timer 3 Start'): The event will be generated when Timer 3 starts counting.
    - **Timer4Start** (Display string: 'Timer 4 Start'): The event will be generated when Timer 4 starts counting.
    - **Timer5Start** (Display string: 'Timer 5 Start'): The event will be generated when Timer 5 starts counting.
    - **Timer6Start** (Display string: 'Timer 6 Start'): The event will be generated when Timer 6 starts counting.
    - **Timer7Start** (Display string: 'Timer 7 Start'): The event will be generated when Timer 7 starts counting.
    - **Timer8Start** (Display string: 'Timer 8 Start'): The event will be generated when Timer 8 starts counting.
    - **Timer9Start** (Display string: 'Timer 9 Start'): The event will be generated when Timer 9 starts counting.
    - **Timer10Start** (Display string: 'Timer 10 Start'): The event will be generated when Timer 10 starts counting.
    - **Timer11Start** (Display string: 'Timer 11 Start'): The event will be generated when Timer 11 starts counting.
    - **Timer12Start** (Display string: 'Timer 12 Start'): The event will be generated when Timer 12 starts counting.
    - **Timer13Start** (Display string: 'Timer 13 Start'): The event will be generated when Timer 13 starts counting.
    - **Timer14Start** (Display string: 'Timer 14 Start'): The event will be generated when Timer 14 starts counting.
    - **Timer15Start** (Display string: 'Timer 15 Start'): The event will be generated when Timer 15 starts counting.
    - **Timer2End** (Display string: 'Timer 2 End'): The event will be generated when Timer 2 ends counting.
    - **Timer3End** (Display string: 'Timer 3 End'): The event will be generated when Timer 3 ends counting.
    - **Timer4End** (Display string: 'Timer 4 End'): The event will be generated when Timer 4 ends counting.
    - **Timer5End** (Display string: 'Timer 5 End'): The event will be generated when Timer 5 ends counting.
    - **Timer6End** (Display string: 'Timer 6 End'): The event will be generated when Timer 6 ends counting.
    - **Timer7End** (Display string: 'Timer 7 End'): The event will be generated when Timer 7 ends counting.
    - **Timer8End** (Display string: 'Timer 8 End'): The event will be generated when Timer 8 ends counting.
    - **Timer9End** (Display string: 'Timer 9 End'): The event will be generated when Timer 9 ends counting.
    - **Timer10End** (Display string: 'Timer 10 End'): The event will be generated when Timer 10 ends counting.
    - **Timer11End** (Display string: 'Timer 11 End'): The event will be generated when Timer 11 ends counting.
    - **Timer12End** (Display string: 'Timer 12 End'): The event will be generated when Timer 12 ends counting.
    - **Timer13End** (Display string: 'Timer 13 End'): The event will be generated when Timer 13 ends counting.
    - **Timer14End** (Display string: 'Timer 14 End'): The event will be generated when Timer 14 ends counting.
    - **Timer15End** (Display string: 'Timer 15 End'): The event will be generated when Timer 15 ends counting.
    - **Encoder2Stopped** (Display string: 'Encoder 2 Stopped'): The event will be generated when the Encoder 2 stops for longer than EncoderTimeout.
    - **Encoder3Stopped** (Display string: 'Encoder 3 Stopped'): The event will be generated when the Encoder 3 stops for longer than EncoderTimeout.
    - **Encoder4Stopped** (Display string: 'Encoder 4 Stopped'): The event will be generated when the Encoder 4 stops for longer than EncoderTimeout.
    - **Encoder5Stopped** (Display string: 'Encoder 5 Stopped'): The event will be generated when the Encoder 5 stops for longer than EncoderTimeout.
    - **Encoder6Stopped** (Display string: 'Encoder 6 Stopped'): The event will be generated when the Encoder 6 stops for longer than EncoderTimeout.
    - **Encoder7Stopped** (Display string: 'Encoder 7 Stopped'): The event will be generated when the Encoder 7 stops for longer than EncoderTimeout.
    - **Encoder8Stopped** (Display string: 'Encoder 8 Stopped'): The event will be generated when the Encoder 8 stops for longer than EncoderTimeout.
    - **Encoder9Stopped** (Display string: 'Encoder 9 Stopped'): The event will be generated when the Encoder 9 stops for longer than EncoderTimeout.
    - **Encoder10Stopped** (Display string: 'Encoder 10 Stopped'): The event will be generated when the Encoder 10 stops for longer than EncoderTimeout.
    - **Encoder11Stopped** (Display string: 'Encoder 11 Stopped'): The event will be generated when the Encoder 11 stops for longer than EncoderTimeout.
    - **Encoder12Stopped** (Display string: 'Encoder 12 Stopped'): The event will be generated when the Encoder 12 stops for longer than EncoderTimeout.
    - **Encoder13Stopped** (Display string: 'Encoder 13 Stopped'): The event will be generated when the Encoder 13 stops for longer than EncoderTimeout.
    - **Encoder14Stopped** (Display string: 'Encoder 14 Stopped'): The event will be generated when the Encoder 14 stops for longer than EncoderTimeout.
    - **Encoder15Stopped** (Display string: 'Encoder 15 Stopped'): The event will be generated when the Encoder 15 stops for longer than EncoderTimeout.
    - **Encoder2Restarted** (Display string: 'Encoder 2 Restarted'): The event will be generated when the Encoder 2 restarts moving.
    - **Encoder3Restarted** (Display string: 'Encoder 3 Restarted'): The event will be generated when the Encoder 3 restarts moving.
    - **Encoder4Restarted** (Display string: 'Encoder 4 Restarted'): The event will be generated when the Encoder 4 restarts moving.
    - **Encoder5Restarted** (Display string: 'Encoder 5 Restarted'): The event will be generated when the Encoder 5 restarts moving.
    - **Encoder6Restarted** (Display string: 'Encoder 6 Restarted'): The event will be generated when the Encoder 6 restarts moving.
    - **Encoder7Restarted** (Display string: 'Encoder 7 Restarted'): The event will be generated when the Encoder 7 restarts moving.
    - **Encoder8Restarted** (Display string: 'Encoder 8 Restarted'): The event will be generated when the Encoder 8 restarts moving.
    - **Encoder9Restarted** (Display string: 'Encoder 9 Restarted'): The event will be generated when the Encoder 9 restarts moving.
    - **Encoder10Restarted** (Display string: 'Encoder 10 Restarted'): The event will be generated when the Encoder 10 restarts moving.
    - **Encoder11Restarted** (Display string: 'Encoder 11 Restarted'): The event will be generated when the Encoder 11 restarts moving.
    - **Encoder12Restarted** (Display string: 'Encoder 12 Restarted'): The event will be generated when the Encoder 12 restarts moving.
    - **Encoder13Restarted** (Display string: 'Encoder 13 Restarted'): The event will be generated when the Encoder 13 restarts moving.
    - **Encoder14Restarted** (Display string: 'Encoder 14 Restarted'): The event will be generated when the Encoder 14 restarts moving.
    - **Encoder15Restarted** (Display string: 'Encoder 15 Restarted'): The event will be generated when the Encoder 15 restarts moving.
    - **Line2RisingEdge** (Display string: 'Line 2 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 2.
    - **Line3RisingEdge** (Display string: 'Line 3 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 3.
    - **Line4RisingEdge** (Display string: 'Line 4 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 4.
    - **Line5RisingEdge** (Display string: 'Line 5 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 5.
    - **Line6RisingEdge** (Display string: 'Line 6 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 6.
    - **Line7RisingEdge** (Display string: 'Line 7 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 7.
    - **Line8RisingEdge** (Display string: 'Line 8 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 8.
    - **Line9RisingEdge** (Display string: 'Line 9 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 9.
    - **Line10RisingEdge** (Display string: 'Line 10 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 10.
    - **Line11RisingEdge** (Display string: 'Line 11 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 11.
    - **Line12RisingEdge** (Display string: 'Line 12 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 12.
    - **Line13RisingEdge** (Display string: 'Line 13 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 13.
    - **Line14RisingEdge** (Display string: 'Line 14 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 14.
    - **Line15RisingEdge** (Display string: 'Line 15 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 15.
    - **Line2FallingEdge** (Display string: 'Line 2 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 2.
    - **Line3FallingEdge** (Display string: 'Line 3 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 3.
    - **Line4FallingEdge** (Display string: 'Line 4 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 4.
    - **Line5FallingEdge** (Display string: 'Line 5 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 5.
    - **Line6FallingEdge** (Display string: 'Line 6 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 6.
    - **Line7FallingEdge** (Display string: 'Line 7 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 7.
    - **Line8FallingEdge** (Display string: 'Line 8 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 8.
    - **Line9FallingEdge** (Display string: 'Line 9 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 9.
    - **Line10FallingEdge** (Display string: 'Line 10 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 10.
    - **Line11FallingEdge** (Display string: 'Line 11 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 11.
    - **Line12FallingEdge** (Display string: 'Line 12 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 12.
    - **Line13FallingEdge** (Display string: 'Line 13 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 13.
    - **Line14FallingEdge** (Display string: 'Line 14 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 14.
    - **Line15FallingEdge** (Display string: 'Line 15 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 15.
    - **Line2AnyEdge** (Display string: 'Line 2 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 2.
    - **Line3AnyEdge** (Display string: 'Line 3 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 3.
    - **Line4AnyEdge** (Display string: 'Line 4 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 4.
    - **Line5AnyEdge** (Display string: 'Line 5 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 5.
    - **Line6AnyEdge** (Display string: 'Line 6 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 6.
    - **Line7AnyEdge** (Display string: 'Line 7 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 7.
    - **Line8AnyEdge** (Display string: 'Line 8 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 8.
    - **Line9AnyEdge** (Display string: 'Line 9 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 9.
    - **Line10AnyEdge** (Display string: 'Line 10 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 10.
    - **Line11AnyEdge** (Display string: 'Line 11 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 11.
    - **Line12AnyEdge** (Display string: 'Line 12 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 12.
    - **Line13AnyEdge** (Display string: 'Line 13 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 13.
    - **Line14AnyEdge** (Display string: 'Line 14 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 14.
    - **Line15AnyEdge** (Display string: 'Line 15 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 15.
    - **Link0Trigger** (Display string: 'Link 0 Trigger')
    - **Link1Trigger** (Display string: 'Link 1 Trigger')
    - **Link2Trigger** (Display string: 'Link 2 Trigger')
    - **Link3Trigger** (Display string: 'Link 3 Trigger')
    - **Link4Trigger** (Display string: 'Link 4 Trigger')
    - **Link5Trigger** (Display string: 'Link 5 Trigger')
    - **Link6Trigger** (Display string: 'Link 6 Trigger')
    - **Link7Trigger** (Display string: 'Link 7 Trigger')
    - **Link8Trigger** (Display string: 'Link 8 Trigger')
    - **Link9Trigger** (Display string: 'Link 9 Trigger')
    - **Link10Trigger** (Display string: 'Link 10 Trigger')
    - **Link11Trigger** (Display string: 'Link 11 Trigger')
    - **Link12Trigger** (Display string: 'Link 12 Trigger')
    - **Link13Trigger** (Display string: 'Link 13 Trigger')
    - **Link14Trigger** (Display string: 'Link 14 Trigger')
    - **Link15Trigger** (Display string: 'Link 15 Trigger')
    - **InterfaceListChanged** (Display string: 'Interface List Changed'): This enumeration value indicates an event that is fired when the list of interfaces has been updated.
    - **InterfaceLost** (Display string: 'Interface Lost'): This enumeration value indicates an event that is raised when the interface connection is lost.
    - **DeviceListChanged** (Display string: 'Device List Changed'): This enumeration value indicates an event that is fired when the list of devices has been updated.
    - **DeviceLost** (Display string: 'Device Lost'): This enumeration value indicates an event that is raised when the local host looses connection to the physical(remote) device.
    - **BufferTooSmall** (Display string: 'Buffer Too Small'): This enumeration value indicates an event that is raised when the buffer was too small to receive the expected amount of data.
    - **BuffersDiscarded** (Display string: 'Buffers Discarded'): This enumeration value indicates an event that is raised when buffers discared by GenTL or device. This event could optionally carry two numeric child data fields EventBuffersDiscardedDeviceCount and EventBuffersDiscardedProducerCount.
    - **BuffersDiscardedDeviceCount** (Display string: 'Buffers Discarded Device Count'): This enumeration value indicates the number of buffers discarded by the device since last fired instance of this event (the producer would get to know about this for example by observing a gap in the block_id sequence).
    - **BuffersDiscardedProducerCount** (Display string: 'Buffers Discarded Producer Count'): This enumeration value indicates the number of buffers discarded by the producer since last fired instance of this event (this would happen e.g. if there are no free buffers available or if given buffer handling mode requires discarding old buffers etc.).

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    eventNotification = property(lib_mvIMPACT_acquire.EventControl_eventNotification_get, doc=r"""
    An enumerated integer property. Activate or deactivate the notification to the host application of the occurrence of the selected Event.
    Activate or deactivate the notification to the host application of the occurrence of the selected Event.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off'): The selected Event notification is disabled.
    - **On** (Display string: 'On'): The selected Event notification is enabled.
    - **Once** (Display string: 'Once'): The selected Event notification is enabled for one event then return to Off state.
    - **GigEVisionEvent** (Display string: 'Gig E Vision Event')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    eventAcquisitionTrigger = property(lib_mvIMPACT_acquire.EventControl_eventAcquisitionTrigger_get, doc=r"""
    An integer property. Returns the unique Identifier of the Acquisition Trigger type of Event.
    Returns the unique Identifier of the Acquisition Trigger type of Event.
    """)
    eventAcquisitionTriggerTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventAcquisitionTriggerTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Acquisition Trigger Event.
    Returns the Timestamp of the Acquisition Trigger Event.
    """)
    eventAcquisitionTriggerFrameID = property(lib_mvIMPACT_acquire.EventControl_eventAcquisitionTriggerFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Acquisition Trigger Event.
    Returns the unique Identifier of the Frame (or image) that generated the Acquisition Trigger Event.
    """)
    eventAcquisitionTriggerMissed = property(lib_mvIMPACT_acquire.EventControl_eventAcquisitionTriggerMissed_get, doc=r"""
    An integer property. Returns the unique Identifier of the Acquisition Trigger Missed type of Event.
    Returns the unique Identifier of the Acquisition Trigger Missed type of Event.
    """)
    eventAcquisitionTriggerMissedTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventAcquisitionTriggerMissedTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Acquisition Trigger Missed Event.
    Returns the Timestamp of the Acquisition Trigger Missed Event.
    """)
    eventAcquisitionTriggerMissedFrameID = property(lib_mvIMPACT_acquire.EventControl_eventAcquisitionTriggerMissedFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Acquisition Trigger Missed Event.
    Returns the unique Identifier of the Frame (or image) that generated the Acquisition Trigger Missed Event.
    """)
    eventAcquisitionStart = property(lib_mvIMPACT_acquire.EventControl_eventAcquisitionStart_get, doc=r"""
    An integer property. Returns the unique Identifier of the Acquisition Start type of Event.
    Returns the unique Identifier of the Acquisition Start type of Event.
    """)
    eventAcquisitionStartTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventAcquisitionStartTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Acquisition Start Event.
    Returns the Timestamp of the Acquisition Start Event.
    """)
    eventAcquisitionStartFrameID = property(lib_mvIMPACT_acquire.EventControl_eventAcquisitionStartFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Acquisition Start Event.
    Returns the unique Identifier of the Frame (or image) that generated the Acquisition Start Event.
    """)
    eventAcquisitionEnd = property(lib_mvIMPACT_acquire.EventControl_eventAcquisitionEnd_get, doc=r"""
    An integer property. Returns the unique Identifier of the Acquisition End type of Event.
    Returns the unique Identifier of the Acquisition End type of Event.
    """)
    eventAcquisitionEndTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventAcquisitionEndTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Acquisition End Event.
    Returns the Timestamp of the Acquisition End Event.
    """)
    eventAcquisitionEndFrameID = property(lib_mvIMPACT_acquire.EventControl_eventAcquisitionEndFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Acquisition End Event.
    Returns the unique Identifier of the Frame (or image) that generated the Acquisition End Event.
    """)
    eventAcquisitionTransferStart = property(lib_mvIMPACT_acquire.EventControl_eventAcquisitionTransferStart_get, doc=r"""
    An integer property. Returns the unique Identifier of the Acquisition Transfer Start type of Event.
    Returns the unique Identifier of the Acquisition Transfer Start type of Event.
    """)
    eventAcquisitionTransferStartTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventAcquisitionTransferStartTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Acquisition Transfer Start Event.
    Returns the Timestamp of the Acquisition Transfer Start Event.
    """)
    eventAcquisitionTransferStartFrameID = property(lib_mvIMPACT_acquire.EventControl_eventAcquisitionTransferStartFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Acquisition Transfer Start Event.
    Returns the unique Identifier of the Frame (or image) that generated the Acquisition Transfer Start Event.
    """)
    eventAcquisitionTransferEnd = property(lib_mvIMPACT_acquire.EventControl_eventAcquisitionTransferEnd_get, doc=r"""
    An integer property. Returns the unique Identifier of the Acquisition Transfer End type of Event.
    Returns the unique Identifier of the Acquisition Transfer End type of Event.
    """)
    eventAcquisitionTransferEndTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventAcquisitionTransferEndTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Acquisition Transfer End Event.
    Returns the Timestamp of the Acquisition Transfer End Event.
    """)
    eventAcquisitionTransferEndFrameID = property(lib_mvIMPACT_acquire.EventControl_eventAcquisitionTransferEndFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Acquisition Transfer End Event.
    Returns the unique Identifier of the Frame (or image) that generated the Acquisition Transfer End Event.
    """)
    eventAcquisitionError = property(lib_mvIMPACT_acquire.EventControl_eventAcquisitionError_get, doc=r"""
    An integer property. Returns the unique Identifier of the Acquisition Error type of Event.
    Returns the unique Identifier of the Acquisition Error type of Event.
    """)
    eventAcquisitionErrorTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventAcquisitionErrorTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Acquisition Error Event.
    Returns the Timestamp of the Acquisition Error Event.
    """)
    eventAcquisitionErrorFrameID = property(lib_mvIMPACT_acquire.EventControl_eventAcquisitionErrorFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Acquisition Error Event.
    Returns the unique Identifier of the Frame (or image) that generated the Acquisition Error Event.
    """)
    eventFrameBurstStart = property(lib_mvIMPACT_acquire.EventControl_eventFrameBurstStart_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame Burst Start type of Event.
    Returns the unique Identifier of the Frame Burst Start type of Event.
    """)
    eventFrameBurstStartTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventFrameBurstStartTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Frame Burst Start Event.
    Returns the Timestamp of the Frame Burst Start Event.
    """)
    eventFrameBurstStartFrameID = property(lib_mvIMPACT_acquire.EventControl_eventFrameBurstStartFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Frame Burst Start Event.
    Returns the unique Identifier of the Frame (or image) that generated the Frame Burst Start Event.
    """)
    eventFrameBurstEnd = property(lib_mvIMPACT_acquire.EventControl_eventFrameBurstEnd_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame Burst End type of Event.
    Returns the unique Identifier of the Frame Burst End type of Event.
    """)
    eventFrameBurstEndTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventFrameBurstEndTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Frame Burst End Event.
    Returns the Timestamp of the Frame Burst End Event.
    """)
    eventFrameBurstEndFrameID = property(lib_mvIMPACT_acquire.EventControl_eventFrameBurstEndFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Frame Burst End Event.
    Returns the unique Identifier of the Frame (or image) that generated the Frame Burst End Event.
    """)
    eventFrameTrigger = property(lib_mvIMPACT_acquire.EventControl_eventFrameTrigger_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame Trigger type of Event.
    Returns the unique Identifier of the Frame Trigger type of Event.
    """)
    eventFrameTriggerTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventFrameTriggerTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Frame Trigger Event.
    Returns the Timestamp of the Frame Trigger Event.
    """)
    eventFrameTriggerFrameID = property(lib_mvIMPACT_acquire.EventControl_eventFrameTriggerFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Frame Trigger Event.
    Returns the unique Identifier of the Frame (or image) that generated the Frame Trigger Event.
    """)
    eventFrameTriggerMissed = property(lib_mvIMPACT_acquire.EventControl_eventFrameTriggerMissed_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame Trigger Missed type of Event.
    Returns the unique Identifier of the Frame Trigger Missed type of Event.
    """)
    eventFrameTriggerMissedTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventFrameTriggerMissedTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Frame Trigger Missed Event.
    Returns the Timestamp of the Frame Trigger Missed Event.
    """)
    eventFrameTriggerMissedFrameID = property(lib_mvIMPACT_acquire.EventControl_eventFrameTriggerMissedFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Frame Trigger Missed Event.
    Returns the unique Identifier of the Frame (or image) that generated the Frame Trigger Missed Event.
    """)
    eventFrameStart = property(lib_mvIMPACT_acquire.EventControl_eventFrameStart_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame Start type of Event.
    Returns the unique Identifier of the Frame Start type of Event.
    """)
    eventFrameStartTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventFrameStartTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Frame Start Event.
    Returns the Timestamp of the Frame Start Event.
    """)
    eventFrameStartFrameID = property(lib_mvIMPACT_acquire.EventControl_eventFrameStartFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Frame Start Event.
    Returns the unique Identifier of the Frame (or image) that generated the Frame Start Event.
    """)
    eventFrameEnd = property(lib_mvIMPACT_acquire.EventControl_eventFrameEnd_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame End type of Event.
    Returns the unique Identifier of the Frame End type of Event.
    """)
    eventFrameEndTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventFrameEndTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Frame End Event.
    Returns the Timestamp of the Frame End Event.
    """)
    eventFrameEndFrameID = property(lib_mvIMPACT_acquire.EventControl_eventFrameEndFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Frame End Event.
    Returns the unique Identifier of the Frame (or image) that generated the Frame End Event.
    """)
    eventFrameTransferStart = property(lib_mvIMPACT_acquire.EventControl_eventFrameTransferStart_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame Transfer Start type of Event.
    Returns the unique Identifier of the Frame Transfer Start type of Event.
    """)
    eventFrameTransferStartTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventFrameTransferStartTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Frame Transfer Start Event.
    Returns the Timestamp of the Frame Transfer Start Event.
    """)
    eventFrameTransferStartFrameID = property(lib_mvIMPACT_acquire.EventControl_eventFrameTransferStartFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Frame Transfer Start Event.
    Returns the unique Identifier of the Frame (or image) that generated the Frame Transfer Start Event.
    """)
    eventFrameTransferEnd = property(lib_mvIMPACT_acquire.EventControl_eventFrameTransferEnd_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame Transfer End type of Event.
    Returns the unique Identifier of the Frame Transfer End type of Event.
    """)
    eventFrameTransferEndTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventFrameTransferEndTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Frame Transfer End Event.
    Returns the Timestamp of the Frame Transfer End Event.
    """)
    eventFrameTransferEndFrameID = property(lib_mvIMPACT_acquire.EventControl_eventFrameTransferEndFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Frame Transfer End Event.
    Returns the unique Identifier of the Frame (or image) that generated the Frame Transfer End Event.
    """)
    eventLineTrigger = property(lib_mvIMPACT_acquire.EventControl_eventLineTrigger_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line Trigger type of Event.
    Returns the unique Identifier of the Line Trigger type of Event.
    """)
    eventLineTriggerTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLineTriggerTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line Trigger Event.
    Returns the Timestamp of the Line Trigger Event.
    """)
    eventLineTriggerFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLineTriggerFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line Trigger Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line Trigger Event.
    """)
    eventLineTriggerMissed = property(lib_mvIMPACT_acquire.EventControl_eventLineTriggerMissed_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line Trigger Missed type of Event.
    Returns the unique Identifier of the Line Trigger Missed type of Event.
    """)
    eventLineTriggerMissedTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLineTriggerMissedTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line Trigger Missed Event.
    Returns the Timestamp of the Line Trigger Missed Event.
    """)
    eventLineTriggerMissedFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLineTriggerMissedFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line Trigger Missed Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line Trigger Missed Event.
    """)
    eventLineStart = property(lib_mvIMPACT_acquire.EventControl_eventLineStart_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line Start type of Event.
    Returns the unique Identifier of the Line Start type of Event.
    """)
    eventLineStartTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLineStartTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line Start Event.
    Returns the Timestamp of the Line Start Event.
    """)
    eventLineStartFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLineStartFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line Start Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line Start Event.
    """)
    eventLineEnd = property(lib_mvIMPACT_acquire.EventControl_eventLineEnd_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line End type of Event.
    Returns the unique Identifier of the Line End type of Event.
    """)
    eventLineEndTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLineEndTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line End Event.
    Returns the Timestamp of the Line End Event.
    """)
    eventLineEndFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLineEndFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line End Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line End Event.
    """)
    eventExposureStart = property(lib_mvIMPACT_acquire.EventControl_eventExposureStart_get, doc=r"""
    An integer property. Returns the unique Identifier of the Exposure Start type of Event.
    Returns the unique Identifier of the Exposure Start type of Event.
    """)
    eventExposureStartTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventExposureStartTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Exposure Start Event.
    Returns the Timestamp of the Exposure Start Event.
    """)
    eventExposureStartFrameID = property(lib_mvIMPACT_acquire.EventControl_eventExposureStartFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Exposure Start Event.
    Returns the unique Identifier of the Frame (or image) that generated the Exposure Start Event.
    """)
    eventExposureEnd = property(lib_mvIMPACT_acquire.EventControl_eventExposureEnd_get, doc=r"""
    An integer property. Returns the unique Identifier of the Exposure End type of Event.
    Returns the unique Identifier of the Exposure End type of Event.
    """)
    eventExposureEndTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventExposureEndTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Exposure End Event.
    Returns the Timestamp of the Exposure End Event.
    """)
    eventExposureEndFrameID = property(lib_mvIMPACT_acquire.EventControl_eventExposureEndFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Exposure End Event.
    Returns the unique Identifier of the Frame (or image) that generated the Exposure End Event.
    """)
    eventActionLate = property(lib_mvIMPACT_acquire.EventControl_eventActionLate_get, doc=r"""
    An integer property. Returns the unique Identifier of the Action Late type of Event.
    Returns the unique Identifier of the Action Late type of Event.
    """)
    eventActionLateTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventActionLateTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Action Late Event.
    Returns the Timestamp of the Action Late Event.
    """)
    eventActionLateFrameID = property(lib_mvIMPACT_acquire.EventControl_eventActionLateFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Action Late Event.
    Returns the unique Identifier of the Frame (or image) that generated the Action Late Event.
    """)
    eventPrimaryApplicationSwitch = property(lib_mvIMPACT_acquire.EventControl_eventPrimaryApplicationSwitch_get, doc=r"""
    An integer property. Returns the unique Identifier of the Primary Application Switch type of Event.
    Returns the unique Identifier of the Primary Application Switch type of Event.
    """)
    eventPrimaryApplicationSwitchTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventPrimaryApplicationSwitchTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Primary Application Switch Event.
    Returns the Timestamp of the Primary Application Switch Event.
    """)
    eventPrimaryApplicationSwitchFrameID = property(lib_mvIMPACT_acquire.EventControl_eventPrimaryApplicationSwitchFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Primary Application Switch Event.
    Returns the unique Identifier of the Frame (or image) that generated the Primary Application Switch Event.
    """)
    eventTest = property(lib_mvIMPACT_acquire.EventControl_eventTest_get, doc=r"""
    An integer property. Returns the unique identifier of the Event Test type of event generated using the TestEventGenerate command.
    Returns the unique identifier of the Event Test type of event generated using the TestEventGenerate command. It can be used to register a callback function to be notified of the EventTest event occurrence. Its value uniquely identifies that the event received was an Event Test.
    """)
    eventTestTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventTestTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Event Test event.
    Returns the Timestamp of the Event Test event. It can be used to determine when the event occurred.
    """)
    eventCounter0Start = property(lib_mvIMPACT_acquire.EventControl_eventCounter0Start_get, doc=r"""
    An integer property. Returns the unique Identifier of the Counter 0 Start type of Event.
    Returns the unique Identifier of the Counter 0 Start type of Event.
    """)
    eventCounter0StartTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventCounter0StartTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Counter 0 Start Event.
    Returns the Timestamp of the Counter 0 Start Event.
    """)
    eventCounter0StartFrameID = property(lib_mvIMPACT_acquire.EventControl_eventCounter0StartFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 0 Start Event.
    Returns the unique Identifier of the Frame (or image) that generated the Counter 0 Start Event.
    """)
    eventCounter1Start = property(lib_mvIMPACT_acquire.EventControl_eventCounter1Start_get, doc=r"""
    An integer property. Returns the unique Identifier of the Counter 1 Start type of Event.
    Returns the unique Identifier of the Counter 1 Start type of Event.
    """)
    eventCounter1StartTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventCounter1StartTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Counter 1 Start Event.
    Returns the Timestamp of the Counter 1 Start Event.
    """)
    eventCounter1StartFrameID = property(lib_mvIMPACT_acquire.EventControl_eventCounter1StartFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 1 Start Event.
    Returns the unique Identifier of the Frame (or image) that generated the Counter 1 Start Event.
    """)
    eventCounter2Start = property(lib_mvIMPACT_acquire.EventControl_eventCounter2Start_get, doc=r"""
    An integer property. Returns the unique Identifier of the Counter 2 Start type of Event.
    Returns the unique Identifier of the Counter 2 Start type of Event.
    """)
    eventCounter2StartTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventCounter2StartTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Counter 2 Start Event.
    Returns the Timestamp of the Counter 2 Start Event.
    """)
    eventCounter2StartFrameID = property(lib_mvIMPACT_acquire.EventControl_eventCounter2StartFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 2 Start Event.
    Returns the unique Identifier of the Frame (or image) that generated the Counter 2 Start Event.
    """)
    eventCounter3Start = property(lib_mvIMPACT_acquire.EventControl_eventCounter3Start_get, doc=r"""
    An integer property. Returns the unique Identifier of the Counter 3 Start type of Event.
    Returns the unique Identifier of the Counter 3 Start type of Event.
    """)
    eventCounter3StartTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventCounter3StartTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Counter 3 Start Event.
    Returns the Timestamp of the Counter 3 Start Event.
    """)
    eventCounter3StartFrameID = property(lib_mvIMPACT_acquire.EventControl_eventCounter3StartFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 3 Start Event.
    Returns the unique Identifier of the Frame (or image) that generated the Counter 3 Start Event.
    """)
    eventCounter4Start = property(lib_mvIMPACT_acquire.EventControl_eventCounter4Start_get, doc=r"""
    An integer property. Returns the unique Identifier of the Counter 4 Start type of Event.
    Returns the unique Identifier of the Counter 4 Start type of Event.
    """)
    eventCounter4StartTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventCounter4StartTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Counter 4 Start Event.
    Returns the Timestamp of the Counter 4 Start Event.
    """)
    eventCounter4StartFrameID = property(lib_mvIMPACT_acquire.EventControl_eventCounter4StartFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 4 Start Event.
    Returns the unique Identifier of the Frame (or image) that generated the Counter 4 Start Event.
    """)
    eventCounter5Start = property(lib_mvIMPACT_acquire.EventControl_eventCounter5Start_get, doc=r"""
    An integer property. Returns the unique Identifier of the Counter 5 Start type of Event.
    Returns the unique Identifier of the Counter 5 Start type of Event.
    """)
    eventCounter5StartTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventCounter5StartTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Counter 5 Start Event.
    Returns the Timestamp of the Counter 5 Start Event.
    """)
    eventCounter5StartFrameID = property(lib_mvIMPACT_acquire.EventControl_eventCounter5StartFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 5 Start Event.
    Returns the unique Identifier of the Frame (or image) that generated the Counter 5 Start Event.
    """)
    eventCounter6Start = property(lib_mvIMPACT_acquire.EventControl_eventCounter6Start_get, doc=r"""
    An integer property. Returns the unique Identifier of the Counter 6 Start type of Event.
    Returns the unique Identifier of the Counter 6 Start type of Event.
    """)
    eventCounter6StartTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventCounter6StartTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Counter 6 Start Event.
    Returns the Timestamp of the Counter 6 Start Event.
    """)
    eventCounter6StartFrameID = property(lib_mvIMPACT_acquire.EventControl_eventCounter6StartFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 6 Start Event.
    Returns the unique Identifier of the Frame (or image) that generated the Counter 6 Start Event.
    """)
    eventCounter7Start = property(lib_mvIMPACT_acquire.EventControl_eventCounter7Start_get, doc=r"""
    An integer property. Returns the unique Identifier of the Counter 7 Start type of Event.
    Returns the unique Identifier of the Counter 7 Start type of Event.
    """)
    eventCounter7StartTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventCounter7StartTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Counter 7 Start Event.
    Returns the Timestamp of the Counter 7 Start Event.
    """)
    eventCounter7StartFrameID = property(lib_mvIMPACT_acquire.EventControl_eventCounter7StartFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 7 Start Event.
    Returns the unique Identifier of the Frame (or image) that generated the Counter 7 Start Event.
    """)
    eventCounter8Start = property(lib_mvIMPACT_acquire.EventControl_eventCounter8Start_get, doc=r"""
    An integer property. Returns the unique Identifier of the Counter 8 Start type of Event.
    Returns the unique Identifier of the Counter 8 Start type of Event.
    """)
    eventCounter8StartTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventCounter8StartTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Counter 8 Start Event.
    Returns the Timestamp of the Counter 8 Start Event.
    """)
    eventCounter8StartFrameID = property(lib_mvIMPACT_acquire.EventControl_eventCounter8StartFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 8 Start Event.
    Returns the unique Identifier of the Frame (or image) that generated the Counter 8 Start Event.
    """)
    eventCounter9Start = property(lib_mvIMPACT_acquire.EventControl_eventCounter9Start_get, doc=r"""
    An integer property. Returns the unique Identifier of the Counter 9 Start type of Event.
    Returns the unique Identifier of the Counter 9 Start type of Event.
    """)
    eventCounter9StartTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventCounter9StartTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Counter 9 Start Event.
    Returns the Timestamp of the Counter 9 Start Event.
    """)
    eventCounter9StartFrameID = property(lib_mvIMPACT_acquire.EventControl_eventCounter9StartFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 9 Start Event.
    Returns the unique Identifier of the Frame (or image) that generated the Counter 9 Start Event.
    """)
    eventCounter10Start = property(lib_mvIMPACT_acquire.EventControl_eventCounter10Start_get, doc=r"""
    An integer property. Returns the unique Identifier of the Counter 10 Start type of Event.
    Returns the unique Identifier of the Counter 10 Start type of Event.
    """)
    eventCounter10StartTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventCounter10StartTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Counter 10 Start Event.
    Returns the Timestamp of the Counter 10 Start Event.
    """)
    eventCounter10StartFrameID = property(lib_mvIMPACT_acquire.EventControl_eventCounter10StartFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 10 Start Event.
    Returns the unique Identifier of the Frame (or image) that generated the Counter 10 Start Event.
    """)
    eventCounter11Start = property(lib_mvIMPACT_acquire.EventControl_eventCounter11Start_get, doc=r"""
    An integer property. Returns the unique Identifier of the Counter 11 Start type of Event.
    Returns the unique Identifier of the Counter 11 Start type of Event.
    """)
    eventCounter11StartTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventCounter11StartTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Counter 11 Start Event.
    Returns the Timestamp of the Counter 11 Start Event.
    """)
    eventCounter11StartFrameID = property(lib_mvIMPACT_acquire.EventControl_eventCounter11StartFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 11 Start Event.
    Returns the unique Identifier of the Frame (or image) that generated the Counter 11 Start Event.
    """)
    eventCounter12Start = property(lib_mvIMPACT_acquire.EventControl_eventCounter12Start_get, doc=r"""
    An integer property. Returns the unique Identifier of the Counter 12 Start type of Event.
    Returns the unique Identifier of the Counter 12 Start type of Event.
    """)
    eventCounter12StartTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventCounter12StartTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Counter 12 Start Event.
    Returns the Timestamp of the Counter 12 Start Event.
    """)
    eventCounter12StartFrameID = property(lib_mvIMPACT_acquire.EventControl_eventCounter12StartFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 12 Start Event.
    Returns the unique Identifier of the Frame (or image) that generated the Counter 12 Start Event.
    """)
    eventCounter13Start = property(lib_mvIMPACT_acquire.EventControl_eventCounter13Start_get, doc=r"""
    An integer property. Returns the unique Identifier of the Counter 13 Start type of Event.
    Returns the unique Identifier of the Counter 13 Start type of Event.
    """)
    eventCounter13StartTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventCounter13StartTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Counter 13 Start Event.
    Returns the Timestamp of the Counter 13 Start Event.
    """)
    eventCounter13StartFrameID = property(lib_mvIMPACT_acquire.EventControl_eventCounter13StartFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 13 Start Event.
    Returns the unique Identifier of the Frame (or image) that generated the Counter 13 Start Event.
    """)
    eventCounter14Start = property(lib_mvIMPACT_acquire.EventControl_eventCounter14Start_get, doc=r"""
    An integer property. Returns the unique Identifier of the Counter 14 Start type of Event.
    Returns the unique Identifier of the Counter 14 Start type of Event.
    """)
    eventCounter14StartTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventCounter14StartTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Counter 14 Start Event.
    Returns the Timestamp of the Counter 14 Start Event.
    """)
    eventCounter14StartFrameID = property(lib_mvIMPACT_acquire.EventControl_eventCounter14StartFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 14 Start Event.
    Returns the unique Identifier of the Frame (or image) that generated the Counter 14 Start Event.
    """)
    eventCounter0End = property(lib_mvIMPACT_acquire.EventControl_eventCounter0End_get, doc=r"""
    An integer property. Returns the unique Identifier of the Counter 0 End type of Event.
    Returns the unique Identifier of the Counter 0 End type of Event.
    """)
    eventCounter0EndTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventCounter0EndTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Counter 0 End Event.
    Returns the Timestamp of the Counter 0 End Event.
    """)
    eventCounter0EndFrameID = property(lib_mvIMPACT_acquire.EventControl_eventCounter0EndFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 0 End Event.
    Returns the unique Identifier of the Frame (or image) that generated the Counter 0 End Event.
    """)
    eventCounter1End = property(lib_mvIMPACT_acquire.EventControl_eventCounter1End_get, doc=r"""
    An integer property. Returns the unique Identifier of the Counter 1 End type of Event.
    Returns the unique Identifier of the Counter 1 End type of Event.
    """)
    eventCounter1EndTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventCounter1EndTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Counter 1 End Event.
    Returns the Timestamp of the Counter 1 End Event.
    """)
    eventCounter1EndFrameID = property(lib_mvIMPACT_acquire.EventControl_eventCounter1EndFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 1 End Event.
    Returns the unique Identifier of the Frame (or image) that generated the Counter 1 End Event.
    """)
    eventCounter2End = property(lib_mvIMPACT_acquire.EventControl_eventCounter2End_get, doc=r"""
    An integer property. Returns the unique Identifier of the Counter 2 End type of Event.
    Returns the unique Identifier of the Counter 2 End type of Event.
    """)
    eventCounter2EndTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventCounter2EndTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Counter 2 End Event.
    Returns the Timestamp of the Counter 2 End Event.
    """)
    eventCounter2EndFrameID = property(lib_mvIMPACT_acquire.EventControl_eventCounter2EndFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 2 End Event.
    Returns the unique Identifier of the Frame (or image) that generated the Counter 2 End Event.
    """)
    eventCounter3End = property(lib_mvIMPACT_acquire.EventControl_eventCounter3End_get, doc=r"""
    An integer property. Returns the unique Identifier of the Counter 3 End type of Event.
    Returns the unique Identifier of the Counter 3 End type of Event.
    """)
    eventCounter3EndTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventCounter3EndTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Counter 3 End Event.
    Returns the Timestamp of the Counter 3 End Event.
    """)
    eventCounter3EndFrameID = property(lib_mvIMPACT_acquire.EventControl_eventCounter3EndFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 3 End Event.
    Returns the unique Identifier of the Frame (or image) that generated the Counter 3 End Event.
    """)
    eventCounter4End = property(lib_mvIMPACT_acquire.EventControl_eventCounter4End_get, doc=r"""
    An integer property. Returns the unique Identifier of the Counter 4 End type of Event.
    Returns the unique Identifier of the Counter 4 End type of Event.
    """)
    eventCounter4EndTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventCounter4EndTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Counter 4 End Event.
    Returns the Timestamp of the Counter 4 End Event.
    """)
    eventCounter4EndFrameID = property(lib_mvIMPACT_acquire.EventControl_eventCounter4EndFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 4 End Event.
    Returns the unique Identifier of the Frame (or image) that generated the Counter 4 End Event.
    """)
    eventCounter5End = property(lib_mvIMPACT_acquire.EventControl_eventCounter5End_get, doc=r"""
    An integer property. Returns the unique Identifier of the Counter 5 End type of Event.
    Returns the unique Identifier of the Counter 5 End type of Event.
    """)
    eventCounter5EndTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventCounter5EndTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Counter 5 End Event.
    Returns the Timestamp of the Counter 5 End Event.
    """)
    eventCounter5EndFrameID = property(lib_mvIMPACT_acquire.EventControl_eventCounter5EndFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 5 End Event.
    Returns the unique Identifier of the Frame (or image) that generated the Counter 5 End Event.
    """)
    eventCounter6End = property(lib_mvIMPACT_acquire.EventControl_eventCounter6End_get, doc=r"""
    An integer property. Returns the unique Identifier of the Counter 6 End type of Event.
    Returns the unique Identifier of the Counter 6 End type of Event.
    """)
    eventCounter6EndTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventCounter6EndTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Counter 6 End Event.
    Returns the Timestamp of the Counter 6 End Event.
    """)
    eventCounter6EndFrameID = property(lib_mvIMPACT_acquire.EventControl_eventCounter6EndFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 6 End Event.
    Returns the unique Identifier of the Frame (or image) that generated the Counter 6 End Event.
    """)
    eventCounter7End = property(lib_mvIMPACT_acquire.EventControl_eventCounter7End_get, doc=r"""
    An integer property. Returns the unique Identifier of the Counter 7 End type of Event.
    Returns the unique Identifier of the Counter 7 End type of Event.
    """)
    eventCounter7EndTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventCounter7EndTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Counter 7 End Event.
    Returns the Timestamp of the Counter 7 End Event.
    """)
    eventCounter7EndFrameID = property(lib_mvIMPACT_acquire.EventControl_eventCounter7EndFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 7 End Event.
    Returns the unique Identifier of the Frame (or image) that generated the Counter 7 End Event.
    """)
    eventCounter8End = property(lib_mvIMPACT_acquire.EventControl_eventCounter8End_get, doc=r"""
    An integer property. Returns the unique Identifier of the Counter 8 End type of Event.
    Returns the unique Identifier of the Counter 8 End type of Event.
    """)
    eventCounter8EndTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventCounter8EndTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Counter 8 End Event.
    Returns the Timestamp of the Counter 8 End Event.
    """)
    eventCounter8EndFrameID = property(lib_mvIMPACT_acquire.EventControl_eventCounter8EndFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 8 End Event.
    Returns the unique Identifier of the Frame (or image) that generated the Counter 8 End Event.
    """)
    eventCounter9End = property(lib_mvIMPACT_acquire.EventControl_eventCounter9End_get, doc=r"""
    An integer property. Returns the unique Identifier of the Counter 9 End type of Event.
    Returns the unique Identifier of the Counter 9 End type of Event.
    """)
    eventCounter9EndTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventCounter9EndTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Counter 9 End Event.
    Returns the Timestamp of the Counter 9 End Event.
    """)
    eventCounter9EndFrameID = property(lib_mvIMPACT_acquire.EventControl_eventCounter9EndFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 9 End Event.
    Returns the unique Identifier of the Frame (or image) that generated the Counter 9 End Event.
    """)
    eventCounter10End = property(lib_mvIMPACT_acquire.EventControl_eventCounter10End_get, doc=r"""
    An integer property. Returns the unique Identifier of the Counter 10 End type of Event.
    Returns the unique Identifier of the Counter 10 End type of Event.
    """)
    eventCounter10EndTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventCounter10EndTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Counter 10 End Event.
    Returns the Timestamp of the Counter 10 End Event.
    """)
    eventCounter10EndFrameID = property(lib_mvIMPACT_acquire.EventControl_eventCounter10EndFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 10 End Event.
    Returns the unique Identifier of the Frame (or image) that generated the Counter 10 End Event.
    """)
    eventCounter11End = property(lib_mvIMPACT_acquire.EventControl_eventCounter11End_get, doc=r"""
    An integer property. Returns the unique Identifier of the Counter 11 End type of Event.
    Returns the unique Identifier of the Counter 11 End type of Event.
    """)
    eventCounter11EndTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventCounter11EndTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Counter 11 End Event.
    Returns the Timestamp of the Counter 11 End Event.
    """)
    eventCounter11EndFrameID = property(lib_mvIMPACT_acquire.EventControl_eventCounter11EndFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 11 End Event.
    Returns the unique Identifier of the Frame (or image) that generated the Counter 11 End Event.
    """)
    eventCounter12End = property(lib_mvIMPACT_acquire.EventControl_eventCounter12End_get, doc=r"""
    An integer property. Returns the unique Identifier of the Counter 12 End type of Event.
    Returns the unique Identifier of the Counter 12 End type of Event.
    """)
    eventCounter12EndTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventCounter12EndTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Counter 12 End Event.
    Returns the Timestamp of the Counter 12 End Event.
    """)
    eventCounter12EndFrameID = property(lib_mvIMPACT_acquire.EventControl_eventCounter12EndFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 12 End Event.
    Returns the unique Identifier of the Frame (or image) that generated the Counter 12 End Event.
    """)
    eventCounter13End = property(lib_mvIMPACT_acquire.EventControl_eventCounter13End_get, doc=r"""
    An integer property. Returns the unique Identifier of the Counter 13 End type of Event.
    Returns the unique Identifier of the Counter 13 End type of Event.
    """)
    eventCounter13EndTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventCounter13EndTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Counter 13 End Event.
    Returns the Timestamp of the Counter 13 End Event.
    """)
    eventCounter13EndFrameID = property(lib_mvIMPACT_acquire.EventControl_eventCounter13EndFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 13 End Event.
    Returns the unique Identifier of the Frame (or image) that generated the Counter 13 End Event.
    """)
    eventCounter14End = property(lib_mvIMPACT_acquire.EventControl_eventCounter14End_get, doc=r"""
    An integer property. Returns the unique Identifier of the Counter 14 End type of Event.
    Returns the unique Identifier of the Counter 14 End type of Event.
    """)
    eventCounter14EndTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventCounter14EndTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Counter 14 End Event.
    Returns the Timestamp of the Counter 14 End Event.
    """)
    eventCounter14EndFrameID = property(lib_mvIMPACT_acquire.EventControl_eventCounter14EndFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Counter 14 End Event.
    Returns the unique Identifier of the Frame (or image) that generated the Counter 14 End Event.
    """)
    eventTimer0Start = property(lib_mvIMPACT_acquire.EventControl_eventTimer0Start_get, doc=r"""
    An integer property. Returns the unique Identifier of the Timer 0 Start type of Event.
    Returns the unique Identifier of the Timer 0 Start type of Event.
    """)
    eventTimer0StartTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventTimer0StartTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Timer 0 Start Event.
    Returns the Timestamp of the Timer 0 Start Event.
    """)
    eventTimer0StartFrameID = property(lib_mvIMPACT_acquire.EventControl_eventTimer0StartFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 0 Start Event.
    Returns the unique Identifier of the Frame (or image) that generated the Timer 0 Start Event.
    """)
    eventTimer1Start = property(lib_mvIMPACT_acquire.EventControl_eventTimer1Start_get, doc=r"""
    An integer property. Returns the unique Identifier of the Timer 1 Start type of Event.
    Returns the unique Identifier of the Timer 1 Start type of Event.
    """)
    eventTimer1StartTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventTimer1StartTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Timer 1 Start Event.
    Returns the Timestamp of the Timer 1 Start Event.
    """)
    eventTimer1StartFrameID = property(lib_mvIMPACT_acquire.EventControl_eventTimer1StartFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 1 Start Event.
    Returns the unique Identifier of the Frame (or image) that generated the Timer 1 Start Event.
    """)
    eventTimer2Start = property(lib_mvIMPACT_acquire.EventControl_eventTimer2Start_get, doc=r"""
    An integer property. Returns the unique Identifier of the Timer 2 Start type of Event.
    Returns the unique Identifier of the Timer 2 Start type of Event.
    """)
    eventTimer2StartTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventTimer2StartTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Timer 2 Start Event.
    Returns the Timestamp of the Timer 2 Start Event.
    """)
    eventTimer2StartFrameID = property(lib_mvIMPACT_acquire.EventControl_eventTimer2StartFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 2 Start Event.
    Returns the unique Identifier of the Frame (or image) that generated the Timer 2 Start Event.
    """)
    eventTimer3Start = property(lib_mvIMPACT_acquire.EventControl_eventTimer3Start_get, doc=r"""
    An integer property. Returns the unique Identifier of the Timer 3 Start type of Event.
    Returns the unique Identifier of the Timer 3 Start type of Event.
    """)
    eventTimer3StartTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventTimer3StartTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Timer 3 Start Event.
    Returns the Timestamp of the Timer 3 Start Event.
    """)
    eventTimer3StartFrameID = property(lib_mvIMPACT_acquire.EventControl_eventTimer3StartFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 3 Start Event.
    Returns the unique Identifier of the Frame (or image) that generated the Timer 3 Start Event.
    """)
    eventTimer4Start = property(lib_mvIMPACT_acquire.EventControl_eventTimer4Start_get, doc=r"""
    An integer property. Returns the unique Identifier of the Timer 4 Start type of Event.
    Returns the unique Identifier of the Timer 4 Start type of Event.
    """)
    eventTimer4StartTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventTimer4StartTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Timer 4 Start Event.
    Returns the Timestamp of the Timer 4 Start Event.
    """)
    eventTimer4StartFrameID = property(lib_mvIMPACT_acquire.EventControl_eventTimer4StartFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 4 Start Event.
    Returns the unique Identifier of the Frame (or image) that generated the Timer 4 Start Event.
    """)
    eventTimer5Start = property(lib_mvIMPACT_acquire.EventControl_eventTimer5Start_get, doc=r"""
    An integer property. Returns the unique Identifier of the Timer 5 Start type of Event.
    Returns the unique Identifier of the Timer 5 Start type of Event.
    """)
    eventTimer5StartTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventTimer5StartTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Timer 5 Start Event.
    Returns the Timestamp of the Timer 5 Start Event.
    """)
    eventTimer5StartFrameID = property(lib_mvIMPACT_acquire.EventControl_eventTimer5StartFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 5 Start Event.
    Returns the unique Identifier of the Frame (or image) that generated the Timer 5 Start Event.
    """)
    eventTimer6Start = property(lib_mvIMPACT_acquire.EventControl_eventTimer6Start_get, doc=r"""
    An integer property. Returns the unique Identifier of the Timer 6 Start type of Event.
    Returns the unique Identifier of the Timer 6 Start type of Event.
    """)
    eventTimer6StartTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventTimer6StartTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Timer 6 Start Event.
    Returns the Timestamp of the Timer 6 Start Event.
    """)
    eventTimer6StartFrameID = property(lib_mvIMPACT_acquire.EventControl_eventTimer6StartFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 6 Start Event.
    Returns the unique Identifier of the Frame (or image) that generated the Timer 6 Start Event.
    """)
    eventTimer7Start = property(lib_mvIMPACT_acquire.EventControl_eventTimer7Start_get, doc=r"""
    An integer property. Returns the unique Identifier of the Timer 7 Start type of Event.
    Returns the unique Identifier of the Timer 7 Start type of Event.
    """)
    eventTimer7StartTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventTimer7StartTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Timer 7 Start Event.
    Returns the Timestamp of the Timer 7 Start Event.
    """)
    eventTimer7StartFrameID = property(lib_mvIMPACT_acquire.EventControl_eventTimer7StartFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 7 Start Event.
    Returns the unique Identifier of the Frame (or image) that generated the Timer 7 Start Event.
    """)
    eventTimer8Start = property(lib_mvIMPACT_acquire.EventControl_eventTimer8Start_get, doc=r"""
    An integer property. Returns the unique Identifier of the Timer 8 Start type of Event.
    Returns the unique Identifier of the Timer 8 Start type of Event.
    """)
    eventTimer8StartTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventTimer8StartTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Timer 8 Start Event.
    Returns the Timestamp of the Timer 8 Start Event.
    """)
    eventTimer8StartFrameID = property(lib_mvIMPACT_acquire.EventControl_eventTimer8StartFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 8 Start Event.
    Returns the unique Identifier of the Frame (or image) that generated the Timer 8 Start Event.
    """)
    eventTimer9Start = property(lib_mvIMPACT_acquire.EventControl_eventTimer9Start_get, doc=r"""
    An integer property. Returns the unique Identifier of the Timer 9 Start type of Event.
    Returns the unique Identifier of the Timer 9 Start type of Event.
    """)
    eventTimer9StartTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventTimer9StartTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Timer 9 Start Event.
    Returns the Timestamp of the Timer 9 Start Event.
    """)
    eventTimer9StartFrameID = property(lib_mvIMPACT_acquire.EventControl_eventTimer9StartFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 9 Start Event.
    Returns the unique Identifier of the Frame (or image) that generated the Timer 9 Start Event.
    """)
    eventTimer10Start = property(lib_mvIMPACT_acquire.EventControl_eventTimer10Start_get, doc=r"""
    An integer property. Returns the unique Identifier of the Timer 10 Start type of Event.
    Returns the unique Identifier of the Timer 10 Start type of Event.
    """)
    eventTimer10StartTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventTimer10StartTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Timer 10 Start Event.
    Returns the Timestamp of the Timer 10 Start Event.
    """)
    eventTimer10StartFrameID = property(lib_mvIMPACT_acquire.EventControl_eventTimer10StartFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 10 Start Event.
    Returns the unique Identifier of the Frame (or image) that generated the Timer 10 Start Event.
    """)
    eventTimer11Start = property(lib_mvIMPACT_acquire.EventControl_eventTimer11Start_get, doc=r"""
    An integer property. Returns the unique Identifier of the Timer 11 Start type of Event.
    Returns the unique Identifier of the Timer 11 Start type of Event.
    """)
    eventTimer11StartTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventTimer11StartTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Timer 11 Start Event.
    Returns the Timestamp of the Timer 11 Start Event.
    """)
    eventTimer11StartFrameID = property(lib_mvIMPACT_acquire.EventControl_eventTimer11StartFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 11 Start Event.
    Returns the unique Identifier of the Frame (or image) that generated the Timer 11 Start Event.
    """)
    eventTimer12Start = property(lib_mvIMPACT_acquire.EventControl_eventTimer12Start_get, doc=r"""
    An integer property. Returns the unique Identifier of the Timer 12 Start type of Event.
    Returns the unique Identifier of the Timer 12 Start type of Event.
    """)
    eventTimer12StartTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventTimer12StartTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Timer 12 Start Event.
    Returns the Timestamp of the Timer 12 Start Event.
    """)
    eventTimer12StartFrameID = property(lib_mvIMPACT_acquire.EventControl_eventTimer12StartFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 12 Start Event.
    Returns the unique Identifier of the Frame (or image) that generated the Timer 12 Start Event.
    """)
    eventTimer13Start = property(lib_mvIMPACT_acquire.EventControl_eventTimer13Start_get, doc=r"""
    An integer property. Returns the unique Identifier of the Timer 13 Start type of Event.
    Returns the unique Identifier of the Timer 13 Start type of Event.
    """)
    eventTimer13StartTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventTimer13StartTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Timer 13 Start Event.
    Returns the Timestamp of the Timer 13 Start Event.
    """)
    eventTimer13StartFrameID = property(lib_mvIMPACT_acquire.EventControl_eventTimer13StartFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 13 Start Event.
    Returns the unique Identifier of the Frame (or image) that generated the Timer 13 Start Event.
    """)
    eventTimer14Start = property(lib_mvIMPACT_acquire.EventControl_eventTimer14Start_get, doc=r"""
    An integer property. Returns the unique Identifier of the Timer 14 Start type of Event.
    Returns the unique Identifier of the Timer 14 Start type of Event.
    """)
    eventTimer14StartTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventTimer14StartTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Timer 14 Start Event.
    Returns the Timestamp of the Timer 14 Start Event.
    """)
    eventTimer14StartFrameID = property(lib_mvIMPACT_acquire.EventControl_eventTimer14StartFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 14 Start Event.
    Returns the unique Identifier of the Frame (or image) that generated the Timer 14 Start Event.
    """)
    eventTimer0End = property(lib_mvIMPACT_acquire.EventControl_eventTimer0End_get, doc=r"""
    An integer property. Returns the unique Identifier of the Timer 0 End type of Event.
    Returns the unique Identifier of the Timer 0 End type of Event.
    """)
    eventTimer0EndTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventTimer0EndTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Timer 0 End Event.
    Returns the Timestamp of the Timer 0 End Event.
    """)
    eventTimer0EndFrameID = property(lib_mvIMPACT_acquire.EventControl_eventTimer0EndFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 0 End Event.
    Returns the unique Identifier of the Frame (or image) that generated the Timer 0 End Event.
    """)
    eventTimer1End = property(lib_mvIMPACT_acquire.EventControl_eventTimer1End_get, doc=r"""
    An integer property. Returns the unique Identifier of the Timer 1 End type of Event.
    Returns the unique Identifier of the Timer 1 End type of Event.
    """)
    eventTimer1EndTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventTimer1EndTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Timer 1 End Event.
    Returns the Timestamp of the Timer 1 End Event.
    """)
    eventTimer1EndFrameID = property(lib_mvIMPACT_acquire.EventControl_eventTimer1EndFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 1 End Event.
    Returns the unique Identifier of the Frame (or image) that generated the Timer 1 End Event.
    """)
    eventTimer2End = property(lib_mvIMPACT_acquire.EventControl_eventTimer2End_get, doc=r"""
    An integer property. Returns the unique Identifier of the Timer 2 End type of Event.
    Returns the unique Identifier of the Timer 2 End type of Event.
    """)
    eventTimer2EndTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventTimer2EndTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Timer 2 End Event.
    Returns the Timestamp of the Timer 2 End Event.
    """)
    eventTimer2EndFrameID = property(lib_mvIMPACT_acquire.EventControl_eventTimer2EndFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 2 End Event.
    Returns the unique Identifier of the Frame (or image) that generated the Timer 2 End Event.
    """)
    eventTimer3End = property(lib_mvIMPACT_acquire.EventControl_eventTimer3End_get, doc=r"""
    An integer property. Returns the unique Identifier of the Timer 3 End type of Event.
    Returns the unique Identifier of the Timer 3 End type of Event.
    """)
    eventTimer3EndTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventTimer3EndTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Timer 3 End Event.
    Returns the Timestamp of the Timer 3 End Event.
    """)
    eventTimer3EndFrameID = property(lib_mvIMPACT_acquire.EventControl_eventTimer3EndFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 3 End Event.
    Returns the unique Identifier of the Frame (or image) that generated the Timer 3 End Event.
    """)
    eventTimer4End = property(lib_mvIMPACT_acquire.EventControl_eventTimer4End_get, doc=r"""
    An integer property. Returns the unique Identifier of the Timer 4 End type of Event.
    Returns the unique Identifier of the Timer 4 End type of Event.
    """)
    eventTimer4EndTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventTimer4EndTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Timer 4 End Event.
    Returns the Timestamp of the Timer 4 End Event.
    """)
    eventTimer4EndFrameID = property(lib_mvIMPACT_acquire.EventControl_eventTimer4EndFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 4 End Event.
    Returns the unique Identifier of the Frame (or image) that generated the Timer 4 End Event.
    """)
    eventTimer5End = property(lib_mvIMPACT_acquire.EventControl_eventTimer5End_get, doc=r"""
    An integer property. Returns the unique Identifier of the Timer 5 End type of Event.
    Returns the unique Identifier of the Timer 5 End type of Event.
    """)
    eventTimer5EndTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventTimer5EndTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Timer 5 End Event.
    Returns the Timestamp of the Timer 5 End Event.
    """)
    eventTimer5EndFrameID = property(lib_mvIMPACT_acquire.EventControl_eventTimer5EndFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 5 End Event.
    Returns the unique Identifier of the Frame (or image) that generated the Timer 5 End Event.
    """)
    eventTimer6End = property(lib_mvIMPACT_acquire.EventControl_eventTimer6End_get, doc=r"""
    An integer property. Returns the unique Identifier of the Timer 6 End type of Event.
    Returns the unique Identifier of the Timer 6 End type of Event.
    """)
    eventTimer6EndTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventTimer6EndTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Timer 6 End Event.
    Returns the Timestamp of the Timer 6 End Event.
    """)
    eventTimer6EndFrameID = property(lib_mvIMPACT_acquire.EventControl_eventTimer6EndFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 6 End Event.
    Returns the unique Identifier of the Frame (or image) that generated the Timer 6 End Event.
    """)
    eventTimer7End = property(lib_mvIMPACT_acquire.EventControl_eventTimer7End_get, doc=r"""
    An integer property. Returns the unique Identifier of the Timer 7 End type of Event.
    Returns the unique Identifier of the Timer 7 End type of Event.
    """)
    eventTimer7EndTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventTimer7EndTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Timer 7 End Event.
    Returns the Timestamp of the Timer 7 End Event.
    """)
    eventTimer7EndFrameID = property(lib_mvIMPACT_acquire.EventControl_eventTimer7EndFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 7 End Event.
    Returns the unique Identifier of the Frame (or image) that generated the Timer 7 End Event.
    """)
    eventTimer8End = property(lib_mvIMPACT_acquire.EventControl_eventTimer8End_get, doc=r"""
    An integer property. Returns the unique Identifier of the Timer 8 End type of Event.
    Returns the unique Identifier of the Timer 8 End type of Event.
    """)
    eventTimer8EndTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventTimer8EndTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Timer 8 End Event.
    Returns the Timestamp of the Timer 8 End Event.
    """)
    eventTimer8EndFrameID = property(lib_mvIMPACT_acquire.EventControl_eventTimer8EndFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 8 End Event.
    Returns the unique Identifier of the Frame (or image) that generated the Timer 8 End Event.
    """)
    eventTimer9End = property(lib_mvIMPACT_acquire.EventControl_eventTimer9End_get, doc=r"""
    An integer property. Returns the unique Identifier of the Timer 9 End type of Event.
    Returns the unique Identifier of the Timer 9 End type of Event.
    """)
    eventTimer9EndTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventTimer9EndTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Timer 9 End Event.
    Returns the Timestamp of the Timer 9 End Event.
    """)
    eventTimer9EndFrameID = property(lib_mvIMPACT_acquire.EventControl_eventTimer9EndFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 9 End Event.
    Returns the unique Identifier of the Frame (or image) that generated the Timer 9 End Event.
    """)
    eventTimer10End = property(lib_mvIMPACT_acquire.EventControl_eventTimer10End_get, doc=r"""
    An integer property. Returns the unique Identifier of the Timer 10 End type of Event.
    Returns the unique Identifier of the Timer 10 End type of Event.
    """)
    eventTimer10EndTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventTimer10EndTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Timer 10 End Event.
    Returns the Timestamp of the Timer 10 End Event.
    """)
    eventTimer10EndFrameID = property(lib_mvIMPACT_acquire.EventControl_eventTimer10EndFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 10 End Event.
    Returns the unique Identifier of the Frame (or image) that generated the Timer 10 End Event.
    """)
    eventTimer11End = property(lib_mvIMPACT_acquire.EventControl_eventTimer11End_get, doc=r"""
    An integer property. Returns the unique Identifier of the Timer 11 End type of Event.
    Returns the unique Identifier of the Timer 11 End type of Event.
    """)
    eventTimer11EndTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventTimer11EndTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Timer 11 End Event.
    Returns the Timestamp of the Timer 11 End Event.
    """)
    eventTimer11EndFrameID = property(lib_mvIMPACT_acquire.EventControl_eventTimer11EndFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 11 End Event.
    Returns the unique Identifier of the Frame (or image) that generated the Timer 11 End Event.
    """)
    eventTimer12End = property(lib_mvIMPACT_acquire.EventControl_eventTimer12End_get, doc=r"""
    An integer property. Returns the unique Identifier of the Timer 12 End type of Event.
    Returns the unique Identifier of the Timer 12 End type of Event.
    """)
    eventTimer12EndTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventTimer12EndTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Timer 12 End Event.
    Returns the Timestamp of the Timer 12 End Event.
    """)
    eventTimer12EndFrameID = property(lib_mvIMPACT_acquire.EventControl_eventTimer12EndFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 12 End Event.
    Returns the unique Identifier of the Frame (or image) that generated the Timer 12 End Event.
    """)
    eventTimer13End = property(lib_mvIMPACT_acquire.EventControl_eventTimer13End_get, doc=r"""
    An integer property. Returns the unique Identifier of the Timer 13 End type of Event.
    Returns the unique Identifier of the Timer 13 End type of Event.
    """)
    eventTimer13EndTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventTimer13EndTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Timer 13 End Event.
    Returns the Timestamp of the Timer 13 End Event.
    """)
    eventTimer13EndFrameID = property(lib_mvIMPACT_acquire.EventControl_eventTimer13EndFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 13 End Event.
    Returns the unique Identifier of the Frame (or image) that generated the Timer 13 End Event.
    """)
    eventTimer14End = property(lib_mvIMPACT_acquire.EventControl_eventTimer14End_get, doc=r"""
    An integer property. Returns the unique Identifier of the Timer 14 End type of Event.
    Returns the unique Identifier of the Timer 14 End type of Event.
    """)
    eventTimer14EndTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventTimer14EndTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Timer 14 End Event.
    Returns the Timestamp of the Timer 14 End Event.
    """)
    eventTimer14EndFrameID = property(lib_mvIMPACT_acquire.EventControl_eventTimer14EndFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Timer 14 End Event.
    Returns the unique Identifier of the Frame (or image) that generated the Timer 14 End Event.
    """)
    eventEncoder0Stopped = property(lib_mvIMPACT_acquire.EventControl_eventEncoder0Stopped_get, doc=r"""
    An integer property. Returns the unique Identifier of the Encoder 0 Stopped type of Event.
    Returns the unique Identifier of the Encoder 0 Stopped type of Event.
    """)
    eventEncoder0StoppedTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventEncoder0StoppedTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Encoder 0 Stopped Event.
    Returns the Timestamp of the Encoder 0 Stopped Event.
    """)
    eventEncoder0StoppedFrameID = property(lib_mvIMPACT_acquire.EventControl_eventEncoder0StoppedFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 0 Stopped Event.
    Returns the unique Identifier of the Frame (or image) that generated the Encoder 0 Stopped Event.
    """)
    eventEncoder1Stopped = property(lib_mvIMPACT_acquire.EventControl_eventEncoder1Stopped_get, doc=r"""
    An integer property. Returns the unique Identifier of the Encoder 1 Stopped type of Event.
    Returns the unique Identifier of the Encoder 1 Stopped type of Event.
    """)
    eventEncoder1StoppedTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventEncoder1StoppedTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Encoder 1 Stopped Event.
    Returns the Timestamp of the Encoder 1 Stopped Event.
    """)
    eventEncoder1StoppedFrameID = property(lib_mvIMPACT_acquire.EventControl_eventEncoder1StoppedFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 1 Stopped Event.
    Returns the unique Identifier of the Frame (or image) that generated the Encoder 1 Stopped Event.
    """)
    eventEncoder2Stopped = property(lib_mvIMPACT_acquire.EventControl_eventEncoder2Stopped_get, doc=r"""
    An integer property. Returns the unique Identifier of the Encoder 2 Stopped type of Event.
    Returns the unique Identifier of the Encoder 2 Stopped type of Event.
    """)
    eventEncoder2StoppedTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventEncoder2StoppedTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Encoder 2 Stopped Event.
    Returns the Timestamp of the Encoder 2 Stopped Event.
    """)
    eventEncoder2StoppedFrameID = property(lib_mvIMPACT_acquire.EventControl_eventEncoder2StoppedFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 2 Stopped Event.
    Returns the unique Identifier of the Frame (or image) that generated the Encoder 2 Stopped Event.
    """)
    eventEncoder3Stopped = property(lib_mvIMPACT_acquire.EventControl_eventEncoder3Stopped_get, doc=r"""
    An integer property. Returns the unique Identifier of the Encoder 3 Stopped type of Event.
    Returns the unique Identifier of the Encoder 3 Stopped type of Event.
    """)
    eventEncoder3StoppedTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventEncoder3StoppedTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Encoder 3 Stopped Event.
    Returns the Timestamp of the Encoder 3 Stopped Event.
    """)
    eventEncoder3StoppedFrameID = property(lib_mvIMPACT_acquire.EventControl_eventEncoder3StoppedFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 3 Stopped Event.
    Returns the unique Identifier of the Frame (or image) that generated the Encoder 3 Stopped Event.
    """)
    eventEncoder4Stopped = property(lib_mvIMPACT_acquire.EventControl_eventEncoder4Stopped_get, doc=r"""
    An integer property. Returns the unique Identifier of the Encoder 4 Stopped type of Event.
    Returns the unique Identifier of the Encoder 4 Stopped type of Event.
    """)
    eventEncoder4StoppedTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventEncoder4StoppedTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Encoder 4 Stopped Event.
    Returns the Timestamp of the Encoder 4 Stopped Event.
    """)
    eventEncoder4StoppedFrameID = property(lib_mvIMPACT_acquire.EventControl_eventEncoder4StoppedFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 4 Stopped Event.
    Returns the unique Identifier of the Frame (or image) that generated the Encoder 4 Stopped Event.
    """)
    eventEncoder5Stopped = property(lib_mvIMPACT_acquire.EventControl_eventEncoder5Stopped_get, doc=r"""
    An integer property. Returns the unique Identifier of the Encoder 5 Stopped type of Event.
    Returns the unique Identifier of the Encoder 5 Stopped type of Event.
    """)
    eventEncoder5StoppedTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventEncoder5StoppedTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Encoder 5 Stopped Event.
    Returns the Timestamp of the Encoder 5 Stopped Event.
    """)
    eventEncoder5StoppedFrameID = property(lib_mvIMPACT_acquire.EventControl_eventEncoder5StoppedFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 5 Stopped Event.
    Returns the unique Identifier of the Frame (or image) that generated the Encoder 5 Stopped Event.
    """)
    eventEncoder6Stopped = property(lib_mvIMPACT_acquire.EventControl_eventEncoder6Stopped_get, doc=r"""
    An integer property. Returns the unique Identifier of the Encoder 6 Stopped type of Event.
    Returns the unique Identifier of the Encoder 6 Stopped type of Event.
    """)
    eventEncoder6StoppedTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventEncoder6StoppedTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Encoder 6 Stopped Event.
    Returns the Timestamp of the Encoder 6 Stopped Event.
    """)
    eventEncoder6StoppedFrameID = property(lib_mvIMPACT_acquire.EventControl_eventEncoder6StoppedFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 6 Stopped Event.
    Returns the unique Identifier of the Frame (or image) that generated the Encoder 6 Stopped Event.
    """)
    eventEncoder7Stopped = property(lib_mvIMPACT_acquire.EventControl_eventEncoder7Stopped_get, doc=r"""
    An integer property. Returns the unique Identifier of the Encoder 7 Stopped type of Event.
    Returns the unique Identifier of the Encoder 7 Stopped type of Event.
    """)
    eventEncoder7StoppedTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventEncoder7StoppedTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Encoder 7 Stopped Event.
    Returns the Timestamp of the Encoder 7 Stopped Event.
    """)
    eventEncoder7StoppedFrameID = property(lib_mvIMPACT_acquire.EventControl_eventEncoder7StoppedFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 7 Stopped Event.
    Returns the unique Identifier of the Frame (or image) that generated the Encoder 7 Stopped Event.
    """)
    eventEncoder8Stopped = property(lib_mvIMPACT_acquire.EventControl_eventEncoder8Stopped_get, doc=r"""
    An integer property. Returns the unique Identifier of the Encoder 8 Stopped type of Event.
    Returns the unique Identifier of the Encoder 8 Stopped type of Event.
    """)
    eventEncoder8StoppedTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventEncoder8StoppedTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Encoder 8 Stopped Event.
    Returns the Timestamp of the Encoder 8 Stopped Event.
    """)
    eventEncoder8StoppedFrameID = property(lib_mvIMPACT_acquire.EventControl_eventEncoder8StoppedFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 8 Stopped Event.
    Returns the unique Identifier of the Frame (or image) that generated the Encoder 8 Stopped Event.
    """)
    eventEncoder9Stopped = property(lib_mvIMPACT_acquire.EventControl_eventEncoder9Stopped_get, doc=r"""
    An integer property. Returns the unique Identifier of the Encoder 9 Stopped type of Event.
    Returns the unique Identifier of the Encoder 9 Stopped type of Event.
    """)
    eventEncoder9StoppedTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventEncoder9StoppedTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Encoder 9 Stopped Event.
    Returns the Timestamp of the Encoder 9 Stopped Event.
    """)
    eventEncoder9StoppedFrameID = property(lib_mvIMPACT_acquire.EventControl_eventEncoder9StoppedFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 9 Stopped Event.
    Returns the unique Identifier of the Frame (or image) that generated the Encoder 9 Stopped Event.
    """)
    eventEncoder10Stopped = property(lib_mvIMPACT_acquire.EventControl_eventEncoder10Stopped_get, doc=r"""
    An integer property. Returns the unique Identifier of the Encoder 10 Stopped type of Event.
    Returns the unique Identifier of the Encoder 10 Stopped type of Event.
    """)
    eventEncoder10StoppedTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventEncoder10StoppedTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Encoder 10 Stopped Event.
    Returns the Timestamp of the Encoder 10 Stopped Event.
    """)
    eventEncoder10StoppedFrameID = property(lib_mvIMPACT_acquire.EventControl_eventEncoder10StoppedFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 10 Stopped Event.
    Returns the unique Identifier of the Frame (or image) that generated the Encoder 10 Stopped Event.
    """)
    eventEncoder11Stopped = property(lib_mvIMPACT_acquire.EventControl_eventEncoder11Stopped_get, doc=r"""
    An integer property. Returns the unique Identifier of the Encoder 11 Stopped type of Event.
    Returns the unique Identifier of the Encoder 11 Stopped type of Event.
    """)
    eventEncoder11StoppedTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventEncoder11StoppedTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Encoder 11 Stopped Event.
    Returns the Timestamp of the Encoder 11 Stopped Event.
    """)
    eventEncoder11StoppedFrameID = property(lib_mvIMPACT_acquire.EventControl_eventEncoder11StoppedFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 11 Stopped Event.
    Returns the unique Identifier of the Frame (or image) that generated the Encoder 11 Stopped Event.
    """)
    eventEncoder12Stopped = property(lib_mvIMPACT_acquire.EventControl_eventEncoder12Stopped_get, doc=r"""
    An integer property. Returns the unique Identifier of the Encoder 12 Stopped type of Event.
    Returns the unique Identifier of the Encoder 12 Stopped type of Event.
    """)
    eventEncoder12StoppedTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventEncoder12StoppedTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Encoder 12 Stopped Event.
    Returns the Timestamp of the Encoder 12 Stopped Event.
    """)
    eventEncoder12StoppedFrameID = property(lib_mvIMPACT_acquire.EventControl_eventEncoder12StoppedFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 12 Stopped Event.
    Returns the unique Identifier of the Frame (or image) that generated the Encoder 12 Stopped Event.
    """)
    eventEncoder13Stopped = property(lib_mvIMPACT_acquire.EventControl_eventEncoder13Stopped_get, doc=r"""
    An integer property. Returns the unique Identifier of the Encoder 13 Stopped type of Event.
    Returns the unique Identifier of the Encoder 13 Stopped type of Event.
    """)
    eventEncoder13StoppedTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventEncoder13StoppedTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Encoder 13 Stopped Event.
    Returns the Timestamp of the Encoder 13 Stopped Event.
    """)
    eventEncoder13StoppedFrameID = property(lib_mvIMPACT_acquire.EventControl_eventEncoder13StoppedFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 13 Stopped Event.
    Returns the unique Identifier of the Frame (or image) that generated the Encoder 13 Stopped Event.
    """)
    eventEncoder14Stopped = property(lib_mvIMPACT_acquire.EventControl_eventEncoder14Stopped_get, doc=r"""
    An integer property. Returns the unique Identifier of the Encoder 14 Stopped type of Event.
    Returns the unique Identifier of the Encoder 14 Stopped type of Event.
    """)
    eventEncoder14StoppedTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventEncoder14StoppedTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Encoder 14 Stopped Event.
    Returns the Timestamp of the Encoder 14 Stopped Event.
    """)
    eventEncoder14StoppedFrameID = property(lib_mvIMPACT_acquire.EventControl_eventEncoder14StoppedFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 14 Stopped Event.
    Returns the unique Identifier of the Frame (or image) that generated the Encoder 14 Stopped Event.
    """)
    eventEncoder0Restarted = property(lib_mvIMPACT_acquire.EventControl_eventEncoder0Restarted_get, doc=r"""
    An integer property. Returns the unique Identifier of the Encoder 0 Restarted type of Event.
    Returns the unique Identifier of the Encoder 0 Restarted type of Event.
    """)
    eventEncoder0RestartedTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventEncoder0RestartedTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Encoder 0 Restarted Event.
    Returns the Timestamp of the Encoder 0 Restarted Event.
    """)
    eventEncoder0RestartedFrameID = property(lib_mvIMPACT_acquire.EventControl_eventEncoder0RestartedFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 0 Restarted Event.
    Returns the unique Identifier of the Frame (or image) that generated the Encoder 0 Restarted Event.
    """)
    eventEncoder1Restarted = property(lib_mvIMPACT_acquire.EventControl_eventEncoder1Restarted_get, doc=r"""
    An integer property. Returns the unique Identifier of the Encoder 1 Restarted type of Event.
    Returns the unique Identifier of the Encoder 1 Restarted type of Event.
    """)
    eventEncoder1RestartedTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventEncoder1RestartedTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Encoder 1 Restarted Event.
    Returns the Timestamp of the Encoder 1 Restarted Event.
    """)
    eventEncoder1RestartedFrameID = property(lib_mvIMPACT_acquire.EventControl_eventEncoder1RestartedFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 1 Restarted Event.
    Returns the unique Identifier of the Frame (or image) that generated the Encoder 1 Restarted Event.
    """)
    eventEncoder2Restarted = property(lib_mvIMPACT_acquire.EventControl_eventEncoder2Restarted_get, doc=r"""
    An integer property. Returns the unique Identifier of the Encoder 2 Restarted type of Event.
    Returns the unique Identifier of the Encoder 2 Restarted type of Event.
    """)
    eventEncoder2RestartedTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventEncoder2RestartedTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Encoder 2 Restarted Event.
    Returns the Timestamp of the Encoder 2 Restarted Event.
    """)
    eventEncoder2RestartedFrameID = property(lib_mvIMPACT_acquire.EventControl_eventEncoder2RestartedFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 2 Restarted Event.
    Returns the unique Identifier of the Frame (or image) that generated the Encoder 2 Restarted Event.
    """)
    eventEncoder3Restarted = property(lib_mvIMPACT_acquire.EventControl_eventEncoder3Restarted_get, doc=r"""
    An integer property. Returns the unique Identifier of the Encoder 3 Restarted type of Event.
    Returns the unique Identifier of the Encoder 3 Restarted type of Event.
    """)
    eventEncoder3RestartedTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventEncoder3RestartedTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Encoder 3 Restarted Event.
    Returns the Timestamp of the Encoder 3 Restarted Event.
    """)
    eventEncoder3RestartedFrameID = property(lib_mvIMPACT_acquire.EventControl_eventEncoder3RestartedFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 3 Restarted Event.
    Returns the unique Identifier of the Frame (or image) that generated the Encoder 3 Restarted Event.
    """)
    eventEncoder4Restarted = property(lib_mvIMPACT_acquire.EventControl_eventEncoder4Restarted_get, doc=r"""
    An integer property. Returns the unique Identifier of the Encoder 4 Restarted type of Event.
    Returns the unique Identifier of the Encoder 4 Restarted type of Event.
    """)
    eventEncoder4RestartedTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventEncoder4RestartedTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Encoder 4 Restarted Event.
    Returns the Timestamp of the Encoder 4 Restarted Event.
    """)
    eventEncoder4RestartedFrameID = property(lib_mvIMPACT_acquire.EventControl_eventEncoder4RestartedFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 4 Restarted Event.
    Returns the unique Identifier of the Frame (or image) that generated the Encoder 4 Restarted Event.
    """)
    eventEncoder5Restarted = property(lib_mvIMPACT_acquire.EventControl_eventEncoder5Restarted_get, doc=r"""
    An integer property. Returns the unique Identifier of the Encoder 5 Restarted type of Event.
    Returns the unique Identifier of the Encoder 5 Restarted type of Event.
    """)
    eventEncoder5RestartedTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventEncoder5RestartedTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Encoder 5 Restarted Event.
    Returns the Timestamp of the Encoder 5 Restarted Event.
    """)
    eventEncoder5RestartedFrameID = property(lib_mvIMPACT_acquire.EventControl_eventEncoder5RestartedFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 5 Restarted Event.
    Returns the unique Identifier of the Frame (or image) that generated the Encoder 5 Restarted Event.
    """)
    eventEncoder6Restarted = property(lib_mvIMPACT_acquire.EventControl_eventEncoder6Restarted_get, doc=r"""
    An integer property. Returns the unique Identifier of the Encoder 6 Restarted type of Event.
    Returns the unique Identifier of the Encoder 6 Restarted type of Event.
    """)
    eventEncoder6RestartedTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventEncoder6RestartedTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Encoder 6 Restarted Event.
    Returns the Timestamp of the Encoder 6 Restarted Event.
    """)
    eventEncoder6RestartedFrameID = property(lib_mvIMPACT_acquire.EventControl_eventEncoder6RestartedFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 6 Restarted Event.
    Returns the unique Identifier of the Frame (or image) that generated the Encoder 6 Restarted Event.
    """)
    eventEncoder7Restarted = property(lib_mvIMPACT_acquire.EventControl_eventEncoder7Restarted_get, doc=r"""
    An integer property. Returns the unique Identifier of the Encoder 7 Restarted type of Event.
    Returns the unique Identifier of the Encoder 7 Restarted type of Event.
    """)
    eventEncoder7RestartedTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventEncoder7RestartedTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Encoder 7 Restarted Event.
    Returns the Timestamp of the Encoder 7 Restarted Event.
    """)
    eventEncoder7RestartedFrameID = property(lib_mvIMPACT_acquire.EventControl_eventEncoder7RestartedFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 7 Restarted Event.
    Returns the unique Identifier of the Frame (or image) that generated the Encoder 7 Restarted Event.
    """)
    eventEncoder8Restarted = property(lib_mvIMPACT_acquire.EventControl_eventEncoder8Restarted_get, doc=r"""
    An integer property. Returns the unique Identifier of the Encoder 8 Restarted type of Event.
    Returns the unique Identifier of the Encoder 8 Restarted type of Event.
    """)
    eventEncoder8RestartedTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventEncoder8RestartedTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Encoder 8 Restarted Event.
    Returns the Timestamp of the Encoder 8 Restarted Event.
    """)
    eventEncoder8RestartedFrameID = property(lib_mvIMPACT_acquire.EventControl_eventEncoder8RestartedFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 8 Restarted Event.
    Returns the unique Identifier of the Frame (or image) that generated the Encoder 8 Restarted Event.
    """)
    eventEncoder9Restarted = property(lib_mvIMPACT_acquire.EventControl_eventEncoder9Restarted_get, doc=r"""
    An integer property. Returns the unique Identifier of the Encoder 9 Restarted type of Event.
    Returns the unique Identifier of the Encoder 9 Restarted type of Event.
    """)
    eventEncoder9RestartedTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventEncoder9RestartedTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Encoder 9 Restarted Event.
    Returns the Timestamp of the Encoder 9 Restarted Event.
    """)
    eventEncoder9RestartedFrameID = property(lib_mvIMPACT_acquire.EventControl_eventEncoder9RestartedFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 9 Restarted Event.
    Returns the unique Identifier of the Frame (or image) that generated the Encoder 9 Restarted Event.
    """)
    eventEncoder10Restarted = property(lib_mvIMPACT_acquire.EventControl_eventEncoder10Restarted_get, doc=r"""
    An integer property. Returns the unique Identifier of the Encoder 10 Restarted type of Event.
    Returns the unique Identifier of the Encoder 10 Restarted type of Event.
    """)
    eventEncoder10RestartedTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventEncoder10RestartedTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Encoder 10 Restarted Event.
    Returns the Timestamp of the Encoder 10 Restarted Event.
    """)
    eventEncoder10RestartedFrameID = property(lib_mvIMPACT_acquire.EventControl_eventEncoder10RestartedFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 10 Restarted Event.
    Returns the unique Identifier of the Frame (or image) that generated the Encoder 10 Restarted Event.
    """)
    eventEncoder11Restarted = property(lib_mvIMPACT_acquire.EventControl_eventEncoder11Restarted_get, doc=r"""
    An integer property. Returns the unique Identifier of the Encoder 11 Restarted type of Event.
    Returns the unique Identifier of the Encoder 11 Restarted type of Event.
    """)
    eventEncoder11RestartedTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventEncoder11RestartedTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Encoder 11 Restarted Event.
    Returns the Timestamp of the Encoder 11 Restarted Event.
    """)
    eventEncoder11RestartedFrameID = property(lib_mvIMPACT_acquire.EventControl_eventEncoder11RestartedFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 11 Restarted Event.
    Returns the unique Identifier of the Frame (or image) that generated the Encoder 11 Restarted Event.
    """)
    eventEncoder12Restarted = property(lib_mvIMPACT_acquire.EventControl_eventEncoder12Restarted_get, doc=r"""
    An integer property. Returns the unique Identifier of the Encoder 12 Restarted type of Event.
    Returns the unique Identifier of the Encoder 12 Restarted type of Event.
    """)
    eventEncoder12RestartedTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventEncoder12RestartedTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Encoder 12 Restarted Event.
    Returns the Timestamp of the Encoder 12 Restarted Event.
    """)
    eventEncoder12RestartedFrameID = property(lib_mvIMPACT_acquire.EventControl_eventEncoder12RestartedFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 12 Restarted Event.
    Returns the unique Identifier of the Frame (or image) that generated the Encoder 12 Restarted Event.
    """)
    eventEncoder13Restarted = property(lib_mvIMPACT_acquire.EventControl_eventEncoder13Restarted_get, doc=r"""
    An integer property. Returns the unique Identifier of the Encoder 13 Restarted type of Event.
    Returns the unique Identifier of the Encoder 13 Restarted type of Event.
    """)
    eventEncoder13RestartedTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventEncoder13RestartedTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Encoder 13 Restarted Event.
    Returns the Timestamp of the Encoder 13 Restarted Event.
    """)
    eventEncoder13RestartedFrameID = property(lib_mvIMPACT_acquire.EventControl_eventEncoder13RestartedFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 13 Restarted Event.
    Returns the unique Identifier of the Frame (or image) that generated the Encoder 13 Restarted Event.
    """)
    eventEncoder14Restarted = property(lib_mvIMPACT_acquire.EventControl_eventEncoder14Restarted_get, doc=r"""
    An integer property. Returns the unique Identifier of the Encoder 14 Restarted type of Event.
    Returns the unique Identifier of the Encoder 14 Restarted type of Event.
    """)
    eventEncoder14RestartedTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventEncoder14RestartedTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Encoder 14 Restarted Event.
    Returns the Timestamp of the Encoder 14 Restarted Event.
    """)
    eventEncoder14RestartedFrameID = property(lib_mvIMPACT_acquire.EventControl_eventEncoder14RestartedFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Encoder 14 Restarted Event.
    Returns the unique Identifier of the Frame (or image) that generated the Encoder 14 Restarted Event.
    """)
    eventLine0RisingEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine0RisingEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 0 Rising Edge type of Event.
    Returns the unique Identifier of the Line 0 Rising Edge type of Event.
    """)
    eventLine0RisingEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine0RisingEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 0 Rising Edge Event.
    Returns the Timestamp of the Line 0 Rising Edge Event.
    """)
    eventLine0RisingEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine0RisingEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 0 Rising Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 0 Rising Edge Event.
    """)
    eventLine1RisingEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine1RisingEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 1 Rising Edge type of Event.
    Returns the unique Identifier of the Line 1 Rising Edge type of Event.
    """)
    eventLine1RisingEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine1RisingEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 1 Rising Edge Event.
    Returns the Timestamp of the Line 1 Rising Edge Event.
    """)
    eventLine1RisingEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine1RisingEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 1 Rising Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 1 Rising Edge Event.
    """)
    eventLine2RisingEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine2RisingEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 2 Rising Edge type of Event.
    Returns the unique Identifier of the Line 2 Rising Edge type of Event.
    """)
    eventLine2RisingEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine2RisingEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 2 Rising Edge Event.
    Returns the Timestamp of the Line 2 Rising Edge Event.
    """)
    eventLine2RisingEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine2RisingEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 2 Rising Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 2 Rising Edge Event.
    """)
    eventLine3RisingEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine3RisingEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 3 Rising Edge type of Event.
    Returns the unique Identifier of the Line 3 Rising Edge type of Event.
    """)
    eventLine3RisingEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine3RisingEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 3 Rising Edge Event.
    Returns the Timestamp of the Line 3 Rising Edge Event.
    """)
    eventLine3RisingEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine3RisingEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 3 Rising Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 3 Rising Edge Event.
    """)
    eventLine4RisingEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine4RisingEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 4 Rising Edge type of Event.
    Returns the unique Identifier of the Line 4 Rising Edge type of Event.
    """)
    eventLine4RisingEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine4RisingEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 4 Rising Edge Event.
    Returns the Timestamp of the Line 4 Rising Edge Event.
    """)
    eventLine4RisingEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine4RisingEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 4 Rising Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 4 Rising Edge Event.
    """)
    eventLine5RisingEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine5RisingEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 5 Rising Edge type of Event.
    Returns the unique Identifier of the Line 5 Rising Edge type of Event.
    """)
    eventLine5RisingEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine5RisingEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 5 Rising Edge Event.
    Returns the Timestamp of the Line 5 Rising Edge Event.
    """)
    eventLine5RisingEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine5RisingEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 5 Rising Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 5 Rising Edge Event.
    """)
    eventLine6RisingEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine6RisingEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 6 Rising Edge type of Event.
    Returns the unique Identifier of the Line 6 Rising Edge type of Event.
    """)
    eventLine6RisingEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine6RisingEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 6 Rising Edge Event.
    Returns the Timestamp of the Line 6 Rising Edge Event.
    """)
    eventLine6RisingEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine6RisingEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 6 Rising Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 6 Rising Edge Event.
    """)
    eventLine7RisingEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine7RisingEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 7 Rising Edge type of Event.
    Returns the unique Identifier of the Line 7 Rising Edge type of Event.
    """)
    eventLine7RisingEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine7RisingEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 7 Rising Edge Event.
    Returns the Timestamp of the Line 7 Rising Edge Event.
    """)
    eventLine7RisingEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine7RisingEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 7 Rising Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 7 Rising Edge Event.
    """)
    eventLine8RisingEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine8RisingEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 8 Rising Edge type of Event.
    Returns the unique Identifier of the Line 8 Rising Edge type of Event.
    """)
    eventLine8RisingEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine8RisingEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 8 Rising Edge Event.
    Returns the Timestamp of the Line 8 Rising Edge Event.
    """)
    eventLine8RisingEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine8RisingEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 8 Rising Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 8 Rising Edge Event.
    """)
    eventLine9RisingEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine9RisingEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 9 Rising Edge type of Event.
    Returns the unique Identifier of the Line 9 Rising Edge type of Event.
    """)
    eventLine9RisingEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine9RisingEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 9 Rising Edge Event.
    Returns the Timestamp of the Line 9 Rising Edge Event.
    """)
    eventLine9RisingEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine9RisingEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 9 Rising Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 9 Rising Edge Event.
    """)
    eventLine10RisingEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine10RisingEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 10 Rising Edge type of Event.
    Returns the unique Identifier of the Line 10 Rising Edge type of Event.
    """)
    eventLine10RisingEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine10RisingEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 10 Rising Edge Event.
    Returns the Timestamp of the Line 10 Rising Edge Event.
    """)
    eventLine10RisingEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine10RisingEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 10 Rising Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 10 Rising Edge Event.
    """)
    eventLine11RisingEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine11RisingEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 11 Rising Edge type of Event.
    Returns the unique Identifier of the Line 11 Rising Edge type of Event.
    """)
    eventLine11RisingEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine11RisingEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 11 Rising Edge Event.
    Returns the Timestamp of the Line 11 Rising Edge Event.
    """)
    eventLine11RisingEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine11RisingEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 11 Rising Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 11 Rising Edge Event.
    """)
    eventLine12RisingEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine12RisingEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 12 Rising Edge type of Event.
    Returns the unique Identifier of the Line 12 Rising Edge type of Event.
    """)
    eventLine12RisingEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine12RisingEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 12 Rising Edge Event.
    Returns the Timestamp of the Line 12 Rising Edge Event.
    """)
    eventLine12RisingEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine12RisingEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 12 Rising Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 12 Rising Edge Event.
    """)
    eventLine13RisingEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine13RisingEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 13 Rising Edge type of Event.
    Returns the unique Identifier of the Line 13 Rising Edge type of Event.
    """)
    eventLine13RisingEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine13RisingEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 13 Rising Edge Event.
    Returns the Timestamp of the Line 13 Rising Edge Event.
    """)
    eventLine13RisingEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine13RisingEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 13 Rising Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 13 Rising Edge Event.
    """)
    eventLine14RisingEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine14RisingEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 14 Rising Edge type of Event.
    Returns the unique Identifier of the Line 14 Rising Edge type of Event.
    """)
    eventLine14RisingEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine14RisingEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 14 Rising Edge Event.
    Returns the Timestamp of the Line 14 Rising Edge Event.
    """)
    eventLine14RisingEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine14RisingEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 14 Rising Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 14 Rising Edge Event.
    """)
    eventLine0FallingEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine0FallingEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 0 Falling Edge type of Event.
    Returns the unique Identifier of the Line 0 Falling Edge type of Event.
    """)
    eventLine0FallingEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine0FallingEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 0 Falling Edge Event.
    Returns the Timestamp of the Line 0 Falling Edge Event.
    """)
    eventLine0FallingEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine0FallingEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 0 Falling Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 0 Falling Edge Event.
    """)
    eventLine1FallingEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine1FallingEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 1 Falling Edge type of Event.
    Returns the unique Identifier of the Line 1 Falling Edge type of Event.
    """)
    eventLine1FallingEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine1FallingEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 1 Falling Edge Event.
    Returns the Timestamp of the Line 1 Falling Edge Event.
    """)
    eventLine1FallingEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine1FallingEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 1 Falling Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 1 Falling Edge Event.
    """)
    eventLine2FallingEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine2FallingEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 2 Falling Edge type of Event.
    Returns the unique Identifier of the Line 2 Falling Edge type of Event.
    """)
    eventLine2FallingEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine2FallingEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 2 Falling Edge Event.
    Returns the Timestamp of the Line 2 Falling Edge Event.
    """)
    eventLine2FallingEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine2FallingEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 2 Falling Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 2 Falling Edge Event.
    """)
    eventLine3FallingEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine3FallingEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 3 Falling Edge type of Event.
    Returns the unique Identifier of the Line 3 Falling Edge type of Event.
    """)
    eventLine3FallingEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine3FallingEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 3 Falling Edge Event.
    Returns the Timestamp of the Line 3 Falling Edge Event.
    """)
    eventLine3FallingEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine3FallingEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 3 Falling Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 3 Falling Edge Event.
    """)
    eventLine4FallingEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine4FallingEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 4 Falling Edge type of Event.
    Returns the unique Identifier of the Line 4 Falling Edge type of Event.
    """)
    eventLine4FallingEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine4FallingEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 4 Falling Edge Event.
    Returns the Timestamp of the Line 4 Falling Edge Event.
    """)
    eventLine4FallingEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine4FallingEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 4 Falling Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 4 Falling Edge Event.
    """)
    eventLine5FallingEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine5FallingEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 5 Falling Edge type of Event.
    Returns the unique Identifier of the Line 5 Falling Edge type of Event.
    """)
    eventLine5FallingEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine5FallingEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 5 Falling Edge Event.
    Returns the Timestamp of the Line 5 Falling Edge Event.
    """)
    eventLine5FallingEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine5FallingEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 5 Falling Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 5 Falling Edge Event.
    """)
    eventLine6FallingEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine6FallingEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 6 Falling Edge type of Event.
    Returns the unique Identifier of the Line 6 Falling Edge type of Event.
    """)
    eventLine6FallingEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine6FallingEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 6 Falling Edge Event.
    Returns the Timestamp of the Line 6 Falling Edge Event.
    """)
    eventLine6FallingEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine6FallingEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 6 Falling Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 6 Falling Edge Event.
    """)
    eventLine7FallingEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine7FallingEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 7 Falling Edge type of Event.
    Returns the unique Identifier of the Line 7 Falling Edge type of Event.
    """)
    eventLine7FallingEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine7FallingEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 7 Falling Edge Event.
    Returns the Timestamp of the Line 7 Falling Edge Event.
    """)
    eventLine7FallingEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine7FallingEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 7 Falling Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 7 Falling Edge Event.
    """)
    eventLine8FallingEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine8FallingEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 8 Falling Edge type of Event.
    Returns the unique Identifier of the Line 8 Falling Edge type of Event.
    """)
    eventLine8FallingEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine8FallingEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 8 Falling Edge Event.
    Returns the Timestamp of the Line 8 Falling Edge Event.
    """)
    eventLine8FallingEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine8FallingEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 8 Falling Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 8 Falling Edge Event.
    """)
    eventLine9FallingEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine9FallingEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 9 Falling Edge type of Event.
    Returns the unique Identifier of the Line 9 Falling Edge type of Event.
    """)
    eventLine9FallingEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine9FallingEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 9 Falling Edge Event.
    Returns the Timestamp of the Line 9 Falling Edge Event.
    """)
    eventLine9FallingEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine9FallingEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 9 Falling Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 9 Falling Edge Event.
    """)
    eventLine10FallingEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine10FallingEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 10 Falling Edge type of Event.
    Returns the unique Identifier of the Line 10 Falling Edge type of Event.
    """)
    eventLine10FallingEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine10FallingEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 10 Falling Edge Event.
    Returns the Timestamp of the Line 10 Falling Edge Event.
    """)
    eventLine10FallingEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine10FallingEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 10 Falling Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 10 Falling Edge Event.
    """)
    eventLine11FallingEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine11FallingEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 11 Falling Edge type of Event.
    Returns the unique Identifier of the Line 11 Falling Edge type of Event.
    """)
    eventLine11FallingEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine11FallingEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 11 Falling Edge Event.
    Returns the Timestamp of the Line 11 Falling Edge Event.
    """)
    eventLine11FallingEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine11FallingEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 11 Falling Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 11 Falling Edge Event.
    """)
    eventLine12FallingEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine12FallingEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 12 Falling Edge type of Event.
    Returns the unique Identifier of the Line 12 Falling Edge type of Event.
    """)
    eventLine12FallingEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine12FallingEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 12 Falling Edge Event.
    Returns the Timestamp of the Line 12 Falling Edge Event.
    """)
    eventLine12FallingEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine12FallingEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 12 Falling Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 12 Falling Edge Event.
    """)
    eventLine13FallingEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine13FallingEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 13 Falling Edge type of Event.
    Returns the unique Identifier of the Line 13 Falling Edge type of Event.
    """)
    eventLine13FallingEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine13FallingEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 13 Falling Edge Event.
    Returns the Timestamp of the Line 13 Falling Edge Event.
    """)
    eventLine13FallingEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine13FallingEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 13 Falling Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 13 Falling Edge Event.
    """)
    eventLine14FallingEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine14FallingEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 14 Falling Edge type of Event.
    Returns the unique Identifier of the Line 14 Falling Edge type of Event.
    """)
    eventLine14FallingEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine14FallingEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 14 Falling Edge Event.
    Returns the Timestamp of the Line 14 Falling Edge Event.
    """)
    eventLine14FallingEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine14FallingEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 14 Falling Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 14 Falling Edge Event.
    """)
    eventLine0AnyEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine0AnyEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 0 Any Edge type of Event.
    Returns the unique Identifier of the Line 0 Any Edge type of Event.
    """)
    eventLine0AnyEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine0AnyEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 0 Any Edge Event.
    Returns the Timestamp of the Line 0 Any Edge Event.
    """)
    eventLine0AnyEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine0AnyEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 0 Any Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 0 Any Edge Event.
    """)
    eventLine1AnyEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine1AnyEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 1 Any Edge type of Event.
    Returns the unique Identifier of the Line 1 Any Edge type of Event.
    """)
    eventLine1AnyEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine1AnyEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 1 Any Edge Event.
    Returns the Timestamp of the Line 1 Any Edge Event.
    """)
    eventLine1AnyEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine1AnyEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 1 Any Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 1 Any Edge Event.
    """)
    eventLine2AnyEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine2AnyEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 2 Any Edge type of Event.
    Returns the unique Identifier of the Line 2 Any Edge type of Event.
    """)
    eventLine2AnyEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine2AnyEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 2 Any Edge Event.
    Returns the Timestamp of the Line 2 Any Edge Event.
    """)
    eventLine2AnyEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine2AnyEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 2 Any Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 2 Any Edge Event.
    """)
    eventLine3AnyEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine3AnyEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 3 Any Edge type of Event.
    Returns the unique Identifier of the Line 3 Any Edge type of Event.
    """)
    eventLine3AnyEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine3AnyEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 3 Any Edge Event.
    Returns the Timestamp of the Line 3 Any Edge Event.
    """)
    eventLine3AnyEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine3AnyEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 3 Any Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 3 Any Edge Event.
    """)
    eventLine4AnyEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine4AnyEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 4 Any Edge type of Event.
    Returns the unique Identifier of the Line 4 Any Edge type of Event.
    """)
    eventLine4AnyEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine4AnyEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 4 Any Edge Event.
    Returns the Timestamp of the Line 4 Any Edge Event.
    """)
    eventLine4AnyEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine4AnyEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 4 Any Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 4 Any Edge Event.
    """)
    eventLine5AnyEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine5AnyEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 5 Any Edge type of Event.
    Returns the unique Identifier of the Line 5 Any Edge type of Event.
    """)
    eventLine5AnyEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine5AnyEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 5 Any Edge Event.
    Returns the Timestamp of the Line 5 Any Edge Event.
    """)
    eventLine5AnyEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine5AnyEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 5 Any Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 5 Any Edge Event.
    """)
    eventLine6AnyEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine6AnyEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 6 Any Edge type of Event.
    Returns the unique Identifier of the Line 6 Any Edge type of Event.
    """)
    eventLine6AnyEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine6AnyEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 6 Any Edge Event.
    Returns the Timestamp of the Line 6 Any Edge Event.
    """)
    eventLine6AnyEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine6AnyEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 6 Any Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 6 Any Edge Event.
    """)
    eventLine7AnyEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine7AnyEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 7 Any Edge type of Event.
    Returns the unique Identifier of the Line 7 Any Edge type of Event.
    """)
    eventLine7AnyEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine7AnyEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 7 Any Edge Event.
    Returns the Timestamp of the Line 7 Any Edge Event.
    """)
    eventLine7AnyEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine7AnyEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 7 Any Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 7 Any Edge Event.
    """)
    eventLine8AnyEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine8AnyEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 8 Any Edge type of Event.
    Returns the unique Identifier of the Line 8 Any Edge type of Event.
    """)
    eventLine8AnyEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine8AnyEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 8 Any Edge Event.
    Returns the Timestamp of the Line 8 Any Edge Event.
    """)
    eventLine8AnyEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine8AnyEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 8 Any Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 8 Any Edge Event.
    """)
    eventLine9AnyEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine9AnyEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 9 Any Edge type of Event.
    Returns the unique Identifier of the Line 9 Any Edge type of Event.
    """)
    eventLine9AnyEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine9AnyEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 9 Any Edge Event.
    Returns the Timestamp of the Line 9 Any Edge Event.
    """)
    eventLine9AnyEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine9AnyEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 9 Any Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 9 Any Edge Event.
    """)
    eventLine10AnyEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine10AnyEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 10 Any Edge type of Event.
    Returns the unique Identifier of the Line 10 Any Edge type of Event.
    """)
    eventLine10AnyEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine10AnyEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 10 Any Edge Event.
    Returns the Timestamp of the Line 10 Any Edge Event.
    """)
    eventLine10AnyEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine10AnyEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 10 Any Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 10 Any Edge Event.
    """)
    eventLine11AnyEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine11AnyEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 11 Any Edge type of Event.
    Returns the unique Identifier of the Line 11 Any Edge type of Event.
    """)
    eventLine11AnyEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine11AnyEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 11 Any Edge Event.
    Returns the Timestamp of the Line 11 Any Edge Event.
    """)
    eventLine11AnyEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine11AnyEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 11 Any Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 11 Any Edge Event.
    """)
    eventLine12AnyEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine12AnyEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 12 Any Edge type of Event.
    Returns the unique Identifier of the Line 12 Any Edge type of Event.
    """)
    eventLine12AnyEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine12AnyEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 12 Any Edge Event.
    Returns the Timestamp of the Line 12 Any Edge Event.
    """)
    eventLine12AnyEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine12AnyEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 12 Any Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 12 Any Edge Event.
    """)
    eventLine13AnyEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine13AnyEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 13 Any Edge type of Event.
    Returns the unique Identifier of the Line 13 Any Edge type of Event.
    """)
    eventLine13AnyEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine13AnyEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 13 Any Edge Event.
    Returns the Timestamp of the Line 13 Any Edge Event.
    """)
    eventLine13AnyEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine13AnyEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 13 Any Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 13 Any Edge Event.
    """)
    eventLine14AnyEdge = property(lib_mvIMPACT_acquire.EventControl_eventLine14AnyEdge_get, doc=r"""
    An integer property. Returns the unique Identifier of the Line 14 Any Edge type of Event.
    Returns the unique Identifier of the Line 14 Any Edge type of Event.
    """)
    eventLine14AnyEdgeTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventLine14AnyEdgeTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Line 14 Any Edge Event.
    Returns the Timestamp of the Line 14 Any Edge Event.
    """)
    eventLine14AnyEdgeFrameID = property(lib_mvIMPACT_acquire.EventControl_eventLine14AnyEdgeFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Line 14 Any Edge Event.
    Returns the unique Identifier of the Frame (or image) that generated the Line 14 Any Edge Event.
    """)
    eventLinkTrigger0 = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger0_get, doc=r"""
    An integer property. Returns the unique Identifier of the Link Trigger 0 type of Event.
    Returns the unique Identifier of the Link Trigger 0 type of Event.
    """)
    eventLinkTrigger0Timestamp = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger0Timestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Link Trigger 0 Event.
    Returns the Timestamp of the Link Trigger 0 Event.
    """)
    eventLinkTrigger0FrameID = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger0FrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 0 Event.
    Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 0 Event.
    """)
    eventLinkTrigger1 = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger1_get, doc=r"""
    An integer property. Returns the unique Identifier of the Link Trigger 1 type of Event.
    Returns the unique Identifier of the Link Trigger 1 type of Event.
    """)
    eventLinkTrigger1Timestamp = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger1Timestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Link Trigger 1 Event.
    Returns the Timestamp of the Link Trigger 1 Event.
    """)
    eventLinkTrigger1FrameID = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger1FrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 1 Event.
    Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 1 Event.
    """)
    eventLinkTrigger2 = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger2_get, doc=r"""
    An integer property. Returns the unique Identifier of the Link Trigger 2 type of Event.
    Returns the unique Identifier of the Link Trigger 2 type of Event.
    """)
    eventLinkTrigger2Timestamp = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger2Timestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Link Trigger 2 Event.
    Returns the Timestamp of the Link Trigger 2 Event.
    """)
    eventLinkTrigger2FrameID = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger2FrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 2 Event.
    Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 2 Event.
    """)
    eventLinkTrigger3 = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger3_get, doc=r"""
    An integer property. Returns the unique Identifier of the Link Trigger 3 type of Event.
    Returns the unique Identifier of the Link Trigger 3 type of Event.
    """)
    eventLinkTrigger3Timestamp = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger3Timestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Link Trigger 3 Event.
    Returns the Timestamp of the Link Trigger 3 Event.
    """)
    eventLinkTrigger3FrameID = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger3FrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 3 Event.
    Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 3 Event.
    """)
    eventLinkTrigger4 = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger4_get, doc=r"""
    An integer property. Returns the unique Identifier of the Link Trigger 4 type of Event.
    Returns the unique Identifier of the Link Trigger 4 type of Event.
    """)
    eventLinkTrigger4Timestamp = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger4Timestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Link Trigger 4 Event.
    Returns the Timestamp of the Link Trigger 4 Event.
    """)
    eventLinkTrigger4FrameID = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger4FrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 4 Event.
    Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 4 Event.
    """)
    eventLinkTrigger5 = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger5_get, doc=r"""
    An integer property. Returns the unique Identifier of the Link Trigger 5 type of Event.
    Returns the unique Identifier of the Link Trigger 5 type of Event.
    """)
    eventLinkTrigger5Timestamp = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger5Timestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Link Trigger 5 Event.
    Returns the Timestamp of the Link Trigger 5 Event.
    """)
    eventLinkTrigger5FrameID = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger5FrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 5 Event.
    Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 5 Event.
    """)
    eventLinkTrigger6 = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger6_get, doc=r"""
    An integer property. Returns the unique Identifier of the Link Trigger 6 type of Event.
    Returns the unique Identifier of the Link Trigger 6 type of Event.
    """)
    eventLinkTrigger6Timestamp = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger6Timestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Link Trigger 6 Event.
    Returns the Timestamp of the Link Trigger 6 Event.
    """)
    eventLinkTrigger6FrameID = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger6FrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 6 Event.
    Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 6 Event.
    """)
    eventLinkTrigger7 = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger7_get, doc=r"""
    An integer property. Returns the unique Identifier of the Link Trigger 7 type of Event.
    Returns the unique Identifier of the Link Trigger 7 type of Event.
    """)
    eventLinkTrigger7Timestamp = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger7Timestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Link Trigger 7 Event.
    Returns the Timestamp of the Link Trigger 7 Event.
    """)
    eventLinkTrigger7FrameID = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger7FrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 7 Event.
    Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 7 Event.
    """)
    eventLinkTrigger8 = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger8_get, doc=r"""
    An integer property. Returns the unique Identifier of the Link Trigger 8 type of Event.
    Returns the unique Identifier of the Link Trigger 8 type of Event.
    """)
    eventLinkTrigger8Timestamp = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger8Timestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Link Trigger 8 Event.
    Returns the Timestamp of the Link Trigger 8 Event.
    """)
    eventLinkTrigger8FrameID = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger8FrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 8 Event.
    Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 8 Event.
    """)
    eventLinkTrigger9 = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger9_get, doc=r"""
    An integer property. Returns the unique Identifier of the Link Trigger 9 type of Event.
    Returns the unique Identifier of the Link Trigger 9 type of Event.
    """)
    eventLinkTrigger9Timestamp = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger9Timestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Link Trigger 9 Event.
    Returns the Timestamp of the Link Trigger 9 Event.
    """)
    eventLinkTrigger9FrameID = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger9FrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 9 Event.
    Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 9 Event.
    """)
    eventLinkTrigger10 = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger10_get, doc=r"""
    An integer property. Returns the unique Identifier of the Link Trigger 10 type of Event.
    Returns the unique Identifier of the Link Trigger 10 type of Event.
    """)
    eventLinkTrigger10Timestamp = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger10Timestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Link Trigger 10 Event.
    Returns the Timestamp of the Link Trigger 10 Event.
    """)
    eventLinkTrigger10FrameID = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger10FrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 10 Event.
    Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 10 Event.
    """)
    eventLinkTrigger11 = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger11_get, doc=r"""
    An integer property. Returns the unique Identifier of the Link Trigger 11 type of Event.
    Returns the unique Identifier of the Link Trigger 11 type of Event.
    """)
    eventLinkTrigger11Timestamp = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger11Timestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Link Trigger 11 Event.
    Returns the Timestamp of the Link Trigger 11 Event.
    """)
    eventLinkTrigger11FrameID = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger11FrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 11 Event.
    Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 11 Event.
    """)
    eventLinkTrigger12 = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger12_get, doc=r"""
    An integer property. Returns the unique Identifier of the Link Trigger 12 type of Event.
    Returns the unique Identifier of the Link Trigger 12 type of Event.
    """)
    eventLinkTrigger12Timestamp = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger12Timestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Link Trigger 12 Event.
    Returns the Timestamp of the Link Trigger 12 Event.
    """)
    eventLinkTrigger12FrameID = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger12FrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 12 Event.
    Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 12 Event.
    """)
    eventLinkTrigger13 = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger13_get, doc=r"""
    An integer property. Returns the unique Identifier of the Link Trigger 13 type of Event.
    Returns the unique Identifier of the Link Trigger 13 type of Event.
    """)
    eventLinkTrigger13Timestamp = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger13Timestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Link Trigger 13 Event.
    Returns the Timestamp of the Link Trigger 13 Event.
    """)
    eventLinkTrigger13FrameID = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger13FrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 13 Event.
    Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 13 Event.
    """)
    eventLinkTrigger14 = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger14_get, doc=r"""
    An integer property. Returns the unique Identifier of the Link Trigger 14 type of Event.
    Returns the unique Identifier of the Link Trigger 14 type of Event.
    """)
    eventLinkTrigger14Timestamp = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger14Timestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Link Trigger 14 Event.
    Returns the Timestamp of the Link Trigger 14 Event.
    """)
    eventLinkTrigger14FrameID = property(lib_mvIMPACT_acquire.EventControl_eventLinkTrigger14FrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 14 Event.
    Returns the unique Identifier of the Frame (or image) that generated the Link Trigger 14 Event.
    """)
    eventError = property(lib_mvIMPACT_acquire.EventControl_eventError_get, doc=r"""
    An integer property. Returns the unique identifier of the Error type of Event.
    Returns the unique identifier of the Error type of Event. It can be used to register a callback function to be notified of the Error event occurrence. Its value uniquely identifies that the event received was an Error.
    """)
    eventErrorTimestamp = property(lib_mvIMPACT_acquire.EventControl_eventErrorTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the Error Event.
    Returns the Timestamp of the Error Event. It can be used to determine when the event occurred.
    """)
    eventErrorFrameID = property(lib_mvIMPACT_acquire.EventControl_eventErrorFrameID_get, doc=r"""
    An integer property. If applicable, returns the unique Identifier of the Frame (or image) that generated the Error Event.
    If applicable, returns the unique Identifier of the Frame (or image) that generated the Error Event.
    """)
    eventErrorCode = property(lib_mvIMPACT_acquire.EventControl_eventErrorCode_get, doc=r"""
    An integer property. Returns an error code for the error(s) that happened.
    Returns an error code for the error(s) that happened.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_EventControl

# Register EventControl in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.EventControl_swigregister(EventControl)

class UserSetControl(object):
    r"""
    Category that contains the User Set control features.
    A category that contains the User Set control features.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::GenICam::UserSetControl** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.UserSetControl_swiginit(self, lib_mvIMPACT_acquire.new_UserSetControl(*args))
    userSetSelector = property(lib_mvIMPACT_acquire.UserSetControl_userSetSelector_get, doc=r"""
    An enumerated integer property. Selects the feature User Set to load, save or configure.
    Selects the feature User Set to load, save or configure.

    The following string values might be valid for this feature:
    - **Default** (Display string: 'Default'): Selects the factory setting user set.
    - **UserSet0** (Display string: 'User Set 0'): Selects the user set 0.
    - **UserSet1** (Display string: 'User Set 1'): Selects the user set 1.
    - **UserSet**#2# (Display string: 'User Set #2#'): Selects the user set #2#.
    - **UserSet2** (Display string: 'User Set 2'): Selects the user set 2.
    - **UserSet3** (Display string: 'User Set 3'): Selects the user set 3.
    - **UserSet4** (Display string: 'User Set 4'): Selects the user set 4.
    - **UserSet5** (Display string: 'User Set 5'): Selects the user set 5.
    - **UserSet6** (Display string: 'User Set 6'): Selects the user set 6.
    - **UserSet7** (Display string: 'User Set 7'): Selects the user set 7.
    - **UserSet8** (Display string: 'User Set 8'): Selects the user set 8.
    - **UserSet9** (Display string: 'User Set 9'): Selects the user set 9.
    - **UserSet10** (Display string: 'User Set 10'): Selects the user set 10.
    - **UserSet11** (Display string: 'User Set 11'): Selects the user set 11.
    - **UserSet12** (Display string: 'User Set 12'): Selects the user set 12.
    - **UserSet13** (Display string: 'User Set 13'): Selects the user set 13.
    - **UserSet14** (Display string: 'User Set 14'): Selects the user set 14.
    - **UserSet15** (Display string: 'User Set 15'): Selects the user set 15.
    - **UserSet16** (Display string: 'User Set 16')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    userSetDescription = property(lib_mvIMPACT_acquire.UserSetControl_userSetDescription_get, doc=r"""
    A string property. Description of the selected User Set content.
    Description of the selected User Set content.
    """)
    userSetLoad = property(lib_mvIMPACT_acquire.UserSetControl_userSetLoad_get, doc=r"""
    A method object. Loads the User Set specified by UserSetSelector to the device and makes it active.
    Loads the User Set specified by UserSetSelector to the device and makes it active.
    """)
    userSetSave = property(lib_mvIMPACT_acquire.UserSetControl_userSetSave_get, doc=r"""
    A method object. Save the User Set specified by UserSetSelector to the non-volatile memory of the device.
    Save the User Set specified by UserSetSelector to the non-volatile memory of the device.
    """)
    userSetDefault = property(lib_mvIMPACT_acquire.UserSetControl_userSetDefault_get, doc=r"""
    An enumerated integer property. Selects the feature User Set to load and make active by default when the device is reset.
    Selects the feature User Set to load and make active by default when the device is reset.

    The following string values might be valid for this feature:
    - **Default** (Display string: 'Default'): Select the factory setting user set.
    - **UserSet0** (Display string: 'User Set 0'): Select the user set 0.
    - **UserSet1** (Display string: 'User Set 1'): Select the user set 1.
    - **UserSet**#2# (Display string: 'User Set #2#'): Select the user set #2#.
    - **UserSet2** (Display string: 'User Set 2'): Select the user set 2.
    - **UserSet3** (Display string: 'User Set 3'): Select the user set 3.
    - **UserSet4** (Display string: 'User Set 4'): Select the user set 4.
    - **UserSet5** (Display string: 'User Set 5'): Select the user set 5.
    - **UserSet6** (Display string: 'User Set 6'): Select the user set 6.
    - **UserSet7** (Display string: 'User Set 7'): Select the user set 7.
    - **UserSet8** (Display string: 'User Set 8'): Select the user set 8.
    - **UserSet9** (Display string: 'User Set 9'): Select the user set 9.
    - **UserSet10** (Display string: 'User Set 10'): Select the user set 10.
    - **UserSet11** (Display string: 'User Set 11'): Select the user set 11.
    - **UserSet12** (Display string: 'User Set 12'): Select the user set 12.
    - **UserSet13** (Display string: 'User Set 13'): Select the user set 13.
    - **UserSet14** (Display string: 'User Set 14'): Select the user set 14.
    - **UserSet15** (Display string: 'User Set 15'): Select the user set 15.
    - **UserSet16** (Display string: 'User Set 16')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    userSetDefaultSelector = property(lib_mvIMPACT_acquire.UserSetControl_userSetDefaultSelector_get, doc=r"""
    An enumerated integer property. This feature is deprecated (See UserSetDefault).
    Deprecated: 
    This feature is deprecated (See UserSetDefault). Selects the feature User Set to load and make active when the device is reset.

    The following string values might be valid for this feature:
    - **Default** (Display string: 'Default'): Select the factory setting user set.
    - **UserSet0** (Display string: 'User Set 0'): Select the user set 0.
    - **UserSet1** (Display string: 'User Set 1'): Select the user set 1.
    - **UserSet**#2# (Display string: 'User Set #2#'): Select the user set #2#.
    - **UserSet2** (Display string: 'User Set 2'): Select the user set 2.
    - **UserSet3** (Display string: 'User Set 3'): Select the user set 3.
    - **UserSet4** (Display string: 'User Set 4'): Select the user set 4.
    - **UserSet5** (Display string: 'User Set 5'): Select the user set 5.
    - **UserSet6** (Display string: 'User Set 6'): Select the user set 6.
    - **UserSet7** (Display string: 'User Set 7'): Select the user set 7.
    - **UserSet8** (Display string: 'User Set 8'): Select the user set 8.
    - **UserSet9** (Display string: 'User Set 9'): Select the user set 9.
    - **UserSet10** (Display string: 'User Set 10'): Select the user set 10.
    - **UserSet11** (Display string: 'User Set 11'): Select the user set 11.
    - **UserSet12** (Display string: 'User Set 12'): Select the user set 12.
    - **UserSet13** (Display string: 'User Set 13'): Select the user set 13.
    - **UserSet14** (Display string: 'User Set 14'): Select the user set 14.
    - **UserSet15** (Display string: 'User Set 15'): Select the user set 15.
    - **UserSet16** (Display string: 'User Set 16')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    userSetFeatureSelector = property(lib_mvIMPACT_acquire.UserSetControl_userSetFeatureSelector_get, doc=r"""
    An enumerated integer property. Selects which individual UserSet feature to control.
    Selects which individual UserSet feature to control.

    The following string values might be valid for this feature:
    - **Device-Specific** (Display string: 'Device - Specific'): Device - Specific

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    userSetFeatureEnable = property(lib_mvIMPACT_acquire.UserSetControl_userSetFeatureEnable_get, doc=r"""
    A boolean property. Enables the selected feature and make it active in all the UserSets.
    Enables the selected feature and make it active in all the UserSets.
    """)
    mvUserData = property(lib_mvIMPACT_acquire.UserSetControl_mvUserData_get, doc=r"""
    A string property. A register to store arbitrary user data into the devices non-volatile memory.
    A register to store arbitrary user data into the devices non-volatile memory
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_UserSetControl

# Register UserSetControl in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.UserSetControl_swigregister(UserSetControl)

class SequencerControl(object):
    r"""
    Category for the Sequencer Control features.
    A category for the Sequencer Control features.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::GenICam::SequencerControl** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.SequencerControl_swiginit(self, lib_mvIMPACT_acquire.new_SequencerControl(*args))
    sequencerMode = property(lib_mvIMPACT_acquire.SequencerControl_sequencerMode_get, doc=r"""
    An enumerated integer property. Controls if the sequencer mechanism is active.
    Controls if the sequencer mechanism is active.

    The following string values might be valid for this feature:
    - **On** (Display string: 'On'): Enables the sequencer.
    - **Off** (Display string: 'Off'): Disables the sequencer.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    sequencerConfigurationMode = property(lib_mvIMPACT_acquire.SequencerControl_sequencerConfigurationMode_get, doc=r"""
    An enumerated integer property. Controls if the sequencer configuration mode is active.
    Controls if the sequencer configuration mode is active.

    The following string values might be valid for this feature:
    - **On** (Display string: 'On'): Enables the sequencer configuration mode.
    - **Off** (Display string: 'Off'): Disables the sequencer configuration mode.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    sequencerFeatureSelector = property(lib_mvIMPACT_acquire.SequencerControl_sequencerFeatureSelector_get, doc=r"""
    An enumerated integer property. Selects which sequencer features to control.
    Selects which sequencer features to control.

    The following string values might be valid for this feature:
    - **Device-Specific** (Display string: 'Device - Specific'): Device - Specific
    - **ExposureTime** (Display string: 'Exposure Time')
    - **CounterDuration** (Display string: 'Counter Duration')
    - **mvImagePositionAndSize** (Display string: 'mv Image Position And Size'): This value selects whether features affecting the image position and size shall be controlled by the sequencer.
    - **Width** (Display string: 'Width')
    - **Height** (Display string: 'Height')
    - **OffsetX** (Display string: 'Offset X')
    - **OffsetY** (Display string: 'Offset Y')
    - **BinningHorizontal** (Display string: 'Binning Horizontal')
    - **BinningVertical** (Display string: 'Binning Vertical')
    - **DecimationHorizontal** (Display string: 'Decimation Horizontal')
    - **DecimationVertical** (Display string: 'Decimation Vertical')
    - **Gain** (Display string: 'Gain')
    - **UserOutputValueAll** (Display string: 'User Output Value All')
    - **UserOutputValueAllMask** (Display string: 'User Output Value All Mask')
    - **mvUserOutput** (Display string: 'mv User Output'): This value selects whether features affecting the user outputs shall be controlled by the sequencer.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    sequencerFeatureEnable = property(lib_mvIMPACT_acquire.SequencerControl_sequencerFeatureEnable_get, doc=r"""
    A boolean property. Enables the selected feature and make it active in all the sequencer sets.
    Enables the selected feature and make it active in all the sequencer sets.
    """)
    sequencerSetSelector = property(lib_mvIMPACT_acquire.SequencerControl_sequencerSetSelector_get, doc=r"""
    An integer property. Selects the sequencer set to which further feature settings applies.
    Selects the sequencer set to which further feature settings applies.
    """)
    sequencerSetSave = property(lib_mvIMPACT_acquire.SequencerControl_sequencerSetSave_get, doc=r"""
    A method object. Saves the current device state to the sequencer set selected by the SequencerSetSelector.
    Saves the current device state to the sequencer set selected by the SequencerSetSelector.
    """)
    sequencerSetLoad = property(lib_mvIMPACT_acquire.SequencerControl_sequencerSetLoad_get, doc=r"""
    A method object. Loads the sequencer set selected by SequencerSetSelector in the device.
    Loads the sequencer set selected by SequencerSetSelector in the device. Even if SequencerMode is off, this will change the device state to the configuration of the selected set.
    """)
    sequencerSetActive = property(lib_mvIMPACT_acquire.SequencerControl_sequencerSetActive_get, doc=r"""
    An integer property. Contains the currently active sequencer set.
    Contains the currently active sequencer set.
    """)
    sequencerSetStart = property(lib_mvIMPACT_acquire.SequencerControl_sequencerSetStart_get, doc=r"""
    An integer property. Sets the initial/start sequencer set, which is the first set used within a sequencer.
    Sets the initial/start sequencer set, which is the first set used within a sequencer.
    """)
    sequencerPathSelector = property(lib_mvIMPACT_acquire.SequencerControl_sequencerPathSelector_get, doc=r"""
    An integer property. Selects to which branching path further path settings applies.
    Selects to which branching path further path settings applies.
    """)
    sequencerSetNext = property(lib_mvIMPACT_acquire.SequencerControl_sequencerSetNext_get, doc=r"""
    An integer property. Specifies the next sequencer set.
    Specifies the next sequencer set.
    """)
    sequencerTriggerSource = property(lib_mvIMPACT_acquire.SequencerControl_sequencerTriggerSource_get, doc=r"""
    An enumerated integer property. Specifies the internal signal or physical input line to use as the sequencer trigger source.
    Specifies the internal signal or physical input line to use as the sequencer trigger source.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off'): Disables the sequencer trigger.
    - **AcquisitionTrigger** (Display string: 'Acquisition Trigger'): Starts with the reception of the Acquisition Trigger.
    - **AcquisitionTriggerMissed** (Display string: 'Acquisition Trigger Missed'): Starts with the reception of the missed Acquisition Trigger.
    - **AcquisitionStart** (Display string: 'Acquisition Start'): Starts with the reception of the Acquisition Start.
    - **AcquisitionEnd** (Display string: 'Acquisition End'): Starts with the reception of the Acquisition End.
    - **FrameTrigger** (Display string: 'Frame Trigger'): Starts with the reception of the Frame Start Trigger.
    - **FrameTriggerMissed** (Display string: 'Frame Trigger Missed'): Starts with the reception of the missed Frame Trigger.
    - **FrameStart** (Display string: 'Frame Start'): Starts with the reception of the Frame Start.
    - **FrameEnd** (Display string: 'Frame End'): Starts with the reception of the Frame End.
    - **FrameBurstStart** (Display string: 'Frame Burst Start'): Starts with the reception of the Frame Burst Start.
    - **FrameBurstEnd** (Display string: 'Frame Burst End'): Starts with the reception of the Frame Burst End.
    - **ExposureStart** (Display string: 'Exposure Start'): Starts with the reception of the Exposure Start.
    - **ExposureEnd** (Display string: 'Exposure End'): Starts with the reception of the Exposure End.
    - **Line0** (Display string: 'Line 0'): Starts when the specified TimerTriggerActivation condition is met on the chosen I/O Line.
    - **Line1** (Display string: 'Line 1'): Starts when the specified TimerTriggerActivation condition is met on the chosen I/O Line.
    - **Line2** (Display string: 'Line 2'): Starts when the specified TimerTriggerActivation condition is met on the chosen I/O Line.
    - **Line**#3# (Display string: 'Line #3#'): Starts when the specified TimerTriggerActivation condition is met on the chosen I/O Line.
    - **UserOutput0** (Display string: 'User Output 0'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **UserOutput1** (Display string: 'User Output 1'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **UserOutput2** (Display string: 'User Output 2'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **UserOutput**#3# (Display string: 'User Output #3#'): Specifies which User Output bit signal to use as internal source for the trigger.
    - **Counter0Start** (Display string: 'Counter 0 Start'): Starts with the reception of the Counter Start.
    - **Counter1Start** (Display string: 'Counter 1 Start'): Starts with the reception of the Counter Start.
    - **Counter2Start** (Display string: 'Counter 2 Start'): Starts with the reception of the Counter Start.
    - **Counter**#3#Start (Display string: 'Counter #3# Start'): Starts with the reception of the Counter Start.
    - **Counter0End** (Display string: 'Counter 0 End'): Starts with the reception of the Counter End.
    - **Counter1End** (Display string: 'Counter 1 End'): Starts with the reception of the Counter End.
    - **Counter2End** (Display string: 'Counter 2 End'): Starts with the reception of the Counter End.
    - **Counter**#3#End (Display string: 'Counter #3# End'): Starts with the reception of the Counter End.
    - **Timer0Start** (Display string: 'Timer 0 Start'): Starts with the reception of the Timer Start.
    - **Timer1Start** (Display string: 'Timer 1 Start'): Starts with the reception of the Timer Start.
    - **Timer2Start** (Display string: 'Timer 2 Start'): Starts with the reception of the Timer Start.
    - **Timer**#3#Start (Display string: 'Timer #3# Start'): Starts with the reception of the Timer Start.
    - **Timer0End** (Display string: 'Timer 0 End'): Starts with the reception of the Timer End.
    - **Timer1End** (Display string: 'Timer 1 End'): Starts with the reception of the Timer End.
    - **Timer2End** (Display string: 'Timer 2 End'): Starts with the reception of the Timer End.
    - **Timer**#3#End (Display string: 'Timer #3# End'): Starts with the reception of the Timer End.
    - **Encoder0** (Display string: 'Encoder 0'): Starts with the reception of the Encoder output signal.
    - **Encoder1** (Display string: 'Encoder 1'): Starts with the reception of the Encoder output signal.
    - **Encoder2** (Display string: 'Encoder 2'): Starts with the reception of the Encoder output signal.
    - **Encoder**#3# (Display string: 'Encoder #3#'): Starts with the reception of the Encoder output signal.
    - **LogicBlock0** (Display string: 'Logic Block 0'): Starts with the reception of the Logic Block output signal.
    - **LogicBlock1** (Display string: 'Logic Block 1'): Starts with the reception of the Logic Block output signal.
    - **LogicBlock2** (Display string: 'Logic Block 2'): Starts with the reception of the Logic Block output signal.
    - **LogicBlock**#3# (Display string: 'Logic Block #3#'): Starts with the reception of the Logic Block output signal.
    - **SoftwareSignal0** (Display string: 'Software Signal 0'): Starts on the reception of the Software Signal.
    - **SoftwareSignal1** (Display string: 'Software Signal 1'): Starts on the reception of the Software Signal.
    - **SoftwareSignal2** (Display string: 'Software Signal 2'): Starts on the reception of the Software Signal.
    - **SoftwareSignal**#3# (Display string: 'Software Signal #3#'): Starts on the reception of the Software Signal.
    - **Action0** (Display string: 'Action 0'): Starts with the assertion of the chosen action signal.
    - **Action1** (Display string: 'Action 1'): Starts with the assertion of the chosen action signal.
    - **Action2** (Display string: 'Action 2'): Starts with the assertion of the chosen action signal.
    - **Action**#3# (Display string: 'Action #3#'): Starts with the assertion of the chosen action signal.
    - **LinkTrigger0** (Display string: 'Link Trigger 0'): Starts with the reception of the chosen Link Trigger.
    - **LinkTrigger1** (Display string: 'Link Trigger 1'): Starts with the reception of the chosen Link Trigger.
    - **LinkTrigger2** (Display string: 'Link Trigger 2'): Starts with the reception of the chosen Link Trigger.
    - **LinkTrigger**#3# (Display string: 'Link Trigger #3#'): Starts with the reception of the chosen Link Trigger.
    - **CC1** (Display string: 'CC 1'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink products only.
    - **CC2** (Display string: 'CC 2'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink products only.
    - **CC3** (Display string: 'CC 3'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink products only.
    - **CC4** (Display string: 'CC 4'): Index of the Camera Link physical line and associated I/O control block to use. This ensures a direct mapping between the lines on the frame grabber and on the camera. Applicable to CameraLink products only.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    sequencerTriggerActivation = property(lib_mvIMPACT_acquire.SequencerControl_sequencerTriggerActivation_get, doc=r"""
    An enumerated integer property. Specifies the activation mode of the sequencer trigger.
    Specifies the activation mode of the sequencer trigger.

    The following string values might be valid for this feature:
    - **RisingEdge** (Display string: 'Rising Edge'): Specifies that the trigger is considered valid on the rising edge of the source signal.
    - **FallingEdge** (Display string: 'Falling Edge'): Specifies that the trigger is considered valid on the falling edge of the source signal.
    - **AnyEdge** (Display string: 'Any Edge'): Specifies that the trigger is considered valid on the falling or rising edge of the source signal.
    - **LevelHigh** (Display string: 'Level High'): Specifies that the trigger is considered valid as long as the level of the source signal is high.
    - **LevelLow** (Display string: 'Level Low'): Specifies that the trigger is considered valid as long as the level of the source signal is low.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_SequencerControl

# Register SequencerControl in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.SequencerControl_swigregister(SequencerControl)

class mvDefectivePixelCorrectionControl(ComponentCollection):
    r"""
    Contains features to control the device's defective pixel correction parameters.
    Contains features to control the device's defective pixel correction parameters.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::GenICam::mvDefectivePixelCorrectionControl** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.mvDefectivePixelCorrectionControl_swiginit(self, lib_mvIMPACT_acquire.new_mvDefectivePixelCorrectionControl(*args))
    mvDefectivePixelEnable = property(lib_mvIMPACT_acquire.mvDefectivePixelCorrectionControl_mvDefectivePixelEnable_get, doc=r"""
    A boolean property. Activates the camera's defective pixel correction.
    Activates the camera's defective pixel correction.
    """)
    mvDefectivePixelBlinkingMode = property(lib_mvIMPACT_acquire.mvDefectivePixelCorrectionControl_mvDefectivePixelBlinkingMode_get, doc=r"""
    A boolean property. Activates the blinking mode of the camera's defective pixel correction.
    Activates the blinking mode of the camera's defective pixel correction.
    """)
    mvDefectivePixelSelector = property(lib_mvIMPACT_acquire.mvDefectivePixelCorrectionControl_mvDefectivePixelSelector_get, doc=r"""
    An integer property. Controls the index (offset) of the defective pixel to access.
    Controls the index (offset) of the defective pixel to access. Data selected by this selector is NOT part of a user set, but must be written to non volatile memory by calling 'mvDefectivePixelDataSave' explicitly.
    """)
    mvDefectivePixelOffsetX = property(lib_mvIMPACT_acquire.mvDefectivePixelCorrectionControl_mvDefectivePixelOffsetX_get, doc=r"""
    An integer property. Returns the horizontal offset of the defective pixel selected by mvDefectivePixelSelector.
    Returns the horizontal offset of the defective pixel selected by mvDefectivePixelSelector. This data is NOT part of a user set, but must be written to non volatile memory by calling 'mvDefectivePixelDataSave' explicitly.
    """)
    mvDefectivePixelOffsetY = property(lib_mvIMPACT_acquire.mvDefectivePixelCorrectionControl_mvDefectivePixelOffsetY_get, doc=r"""
    An integer property. Returns the vertical offset of the defective pixel selected by mvDefectivePixelSelector.
    Returns the vertical offset of the defective pixel selected by mvDefectivePixelSelector. This data is NOT part of a user set, but must be written to non volatile memory by calling 'mvDefectivePixelDataSave' explicitly.
    """)
    mvDefectivePixelCount = property(lib_mvIMPACT_acquire.mvDefectivePixelCorrectionControl_mvDefectivePixelCount_get, doc=r"""
    An integer property. Contains the number of valid defective pixels. Increasing this value adds a new empty entry. Decreasing this value deletes the last entry.
    Contains the number of valid defective pixels. Increasing this value adds a new empty entry. Decreasing this value deletes the last entry.
    """)
    mvDefectivePixelDataLoad = property(lib_mvIMPACT_acquire.mvDefectivePixelCorrectionControl_mvDefectivePixelDataLoad_get, doc=r"""
    A method object. Loads the defective pixels from device non volatile memory.
    Loads the defective pixels from device non volatile memory.
    """)
    mvDefectivePixelDataSave = property(lib_mvIMPACT_acquire.mvDefectivePixelCorrectionControl_mvDefectivePixelDataSave_get, doc=r"""
    A method object. Saves the defective pixels to device non volatile memory.
    Saves the defective pixels to device non volatile memory.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_mvDefectivePixelCorrectionControl

# Register mvDefectivePixelCorrectionControl in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.mvDefectivePixelCorrectionControl_swigregister(mvDefectivePixelCorrectionControl)

class FileAccessControl(object):
    r"""
    Category that contains the File Access control features.
    A category that contains the File Access control features.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::GenICam::FileAccessControl** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.FileAccessControl_swiginit(self, lib_mvIMPACT_acquire.new_FileAccessControl(*args))
    fileSelector = property(lib_mvIMPACT_acquire.FileAccessControl_fileSelector_get, doc=r"""
    An enumerated integer property. Selects the target file in the device.
    Selects the target file in the device.

    The following string values might be valid for this feature:
    - **UserSetDefault** (Display string: 'User Set Default'): The default user set of the device.
    - **UserSet1** (Display string: 'User Set 1'): The first user set of the device.
    - **UserSet2** (Display string: 'User Set 2'): The second user set of the device.
    - **UserSet3** (Display string: 'User Set 3'): The third user set of the device.
    - **UserSet**#4# (Display string: 'User Set #4#'): The third user set of the device.
    - **LUTLuminance** (Display string: 'LUT Luminance'): The Luminance LUT of the camera.
    - **LUTRed** (Display string: 'LUT Red'): The Red LUT of the camera.
    - **LUTGreen** (Display string: 'LUT Green'): The Green LUT of the camera.
    - **LUTBlue** (Display string: 'LUT Blue'): The Blue LUT of the camera.
    - **DeviceFirmware** (Display string: 'Device Firmware')
    - **UserFile** (Display string: 'User File')
    - **mvFFCImage** (Display string: 'mv FFC Image')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    fileOperationSelector = property(lib_mvIMPACT_acquire.FileAccessControl_fileOperationSelector_get, doc=r"""
    An enumerated integer property. Selects the target operation for the selected file in the device.
    Selects the target operation for the selected file in the device. This Operation is executed when the FileOperationExecute feature is called.

    The following string values might be valid for this feature:
    - **Open** (Display string: 'Open'): Opens the file selected by FileSelector in the device. The access mode in which the file is opened is selected by FileOpenMode.
    - **Close** (Display string: 'Close'): Closes the file selected by FileSelector in the device.
    - **Read** (Display string: 'Read'): Reads FileAccessLength bytes from the device storage at the file relative offset FileAccessOffset into FileAccessBuffer.
    - **Write** (Display string: 'Write'): Writes FileAccessLength bytes taken from the FileAccessBuffer into the device storage at the file relative offset FileAccessOffset.
    - **Delete** (Display string: 'Delete'): Deletes the file selected by FileSelector in the device. Note that deleting a device file should not remove the associated FileSelector entry to allow future operation on this file.
    - **MvFlashWrite** (Display string: 'Mv Flash Write')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    fileOperationExecute = property(lib_mvIMPACT_acquire.FileAccessControl_fileOperationExecute_get, doc=r"""
    A method object. Executes the operation selected by FileOperationSelector on the selected file.
    Executes the operation selected by FileOperationSelector on the selected file.
    """)
    fileOpenMode = property(lib_mvIMPACT_acquire.FileAccessControl_fileOpenMode_get, doc=r"""
    An enumerated integer property. Selects the access mode in which a file is opened in the device.
    Selects the access mode in which a file is opened in the device.

    The following string values might be valid for this feature:
    - **Read** (Display string: 'Read'): This mode selects read-only open mode.
    - **Write** (Display string: 'Write'): This mode selects write-only open mode.
    - **ReadWrite** (Display string: 'Read Write'): This mode selects read and write open mode.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    fileAccessBuffer = property(lib_mvIMPACT_acquire.FileAccessControl_fileAccessBuffer_get, doc=r"""
    A string property. Defines the intermediate access buffer that allows the exchange of data between the device file storage and the application.
    Defines the intermediate access buffer that allows the exchange of data between the device file storage and the application.
    """)
    fileAccessOffset = property(lib_mvIMPACT_acquire.FileAccessControl_fileAccessOffset_get, doc=r"""
    An integer property. Controls the Offset of the mapping between the device file storage and the FileAccessBuffer.
    Controls the Offset of the mapping between the device file storage and the FileAccessBuffer.
    """)
    fileAccessLength = property(lib_mvIMPACT_acquire.FileAccessControl_fileAccessLength_get, doc=r"""
    An integer property. Controls the Length of the mapping between the device file storage and the FileAccessBuffer.
    Controls the Length of the mapping between the device file storage and the FileAccessBuffer.
    """)
    fileOperationStatus = property(lib_mvIMPACT_acquire.FileAccessControl_fileOperationStatus_get, doc=r"""
    An enumerated integer property. Represents the file operation execution status.
    Represents the file operation execution status.

    The following string values might be valid for this feature:
    - **Success** (Display string: 'Success'): File Operation was successful.
    - **Failure** (Display string: 'Failure'): File Operation failed.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    fileOperationResult = property(lib_mvIMPACT_acquire.FileAccessControl_fileOperationResult_get, doc=r"""
    An integer property. Represents the file operation result.
    Represents the file operation result. For Read or Write operations, the number of successfully read/written bytes is returned.
    """)
    fileSize = property(lib_mvIMPACT_acquire.FileAccessControl_fileSize_get, doc=r"""
    An integer property. Represents the size of the selected file in bytes.
    Represents the size of the selected file in bytes.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_FileAccessControl

# Register FileAccessControl in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.FileAccessControl_swigregister(FileAccessControl)

class SourceControl(object):
    r"""
    Category that contains the source control features.
    A category that contains the source control features.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::GenICam::SourceControl** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.SourceControl_swiginit(self, lib_mvIMPACT_acquire.new_SourceControl(*args))
    sourceCount = property(lib_mvIMPACT_acquire.SourceControl_sourceCount_get, doc=r"""
    An integer property. Controls or returns the number of sources supported by the device.
    Controls or returns the number of sources supported by the device.
    """)
    sourceSelector = property(lib_mvIMPACT_acquire.SourceControl_sourceSelector_get, doc=r"""
    An enumerated integer property. Selects the source to control.
    Selects the source to control.

    The following string values might be valid for this feature:
    - **Source0** (Display string: 'Source 0'): Selects the data source 0.
    - **Source1** (Display string: 'Source 1'): Selects the data source 1.
    - **Source2** (Display string: 'Source 2'): Selects the data source 2.
    - **Source**#3# (Display string: 'Source #3#'): Selects the data source #3#.
    - **All** (Display string: 'All'): Selects all the data sources.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    sourceIDValue = property(lib_mvIMPACT_acquire.SourceControl_sourceIDValue_get, doc=r"""
    An integer property. Returns a unique Identifier value that correspond to the selected Source.
    Returns a unique Identifier value that correspond to the selected Source.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_SourceControl

# Register SourceControl in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.SourceControl_swigregister(SourceControl)

class TransferControl(object):
    r"""
    Category for the data Transfer Control features.
    A category for the data Transfer Control features.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::GenICam::TransferControl** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.TransferControl_swiginit(self, lib_mvIMPACT_acquire.new_TransferControl(*args))
    transferSelector = property(lib_mvIMPACT_acquire.TransferControl_transferSelector_get, doc=r"""
    An enumerated integer property. Selects which stream transfers are currently controlled by the selected Transfer features.
    Selects which stream transfers are currently controlled by the selected Transfer features.

    The following string values might be valid for this feature:
    - **Stream0** (Display string: 'Stream 0'): The transfer features control the data stream 0.
    - **Stream1** (Display string: 'Stream 1'): The transfer features control the data stream 1.
    - **Stream2** (Display string: 'Stream 2'): The transfer features control the data stream 2.
    - **Stream**#3# (Display string: 'Stream #3#'): The transfer features control the data stream #3#.
    - **All** (Display string: 'All'): The transfer features control all the data streams simultaneously.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    transferControlMode = property(lib_mvIMPACT_acquire.TransferControl_transferControlMode_get, doc=r"""
    An enumerated integer property. Selects the control method for the transfers.
    Selects the control method for the transfers.

    The following string values might be valid for this feature:
    - **Basic** (Display string: 'Basic'): Basic
    - **Automatic** (Display string: 'Automatic'): Automatic
    - **UserControlled** (Display string: 'User Controlled'): User Controlled

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    transferOperationMode = property(lib_mvIMPACT_acquire.TransferControl_transferOperationMode_get, doc=r"""
    An enumerated integer property. Selects the operation mode of the transfer.
    Selects the operation mode of the transfer.

    The following string values might be valid for this feature:
    - **Continuous** (Display string: 'Continuous'): Continuous
    - **MultiBlock** (Display string: 'Multi Block'): Multi Block

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    transferBlockCount = property(lib_mvIMPACT_acquire.TransferControl_transferBlockCount_get, doc=r"""
    An integer property. Specifies the number of data Blocks that the device should stream before stopping.
    Specifies the number of data Blocks that the device should stream before stopping. This feature is only active if the TransferOperationMode is set to MultiBlock.
    """)
    transferBurstCount = property(lib_mvIMPACT_acquire.TransferControl_transferBurstCount_get, doc=r"""
    An integer property. Number of Block(s) to transfer for each TransferBurstStart trigger.
    Number of Block(s) to transfer for each TransferBurstStart trigger.
    """)
    transferQueueMaxBlockCount = property(lib_mvIMPACT_acquire.TransferControl_transferQueueMaxBlockCount_get, doc=r"""
    An integer property. Controls the maximum number of data blocks that can be stored in the block queue of the selected stream.
    Controls the maximum number of data blocks that can be stored in the block queue of the selected stream.
    """)
    transferQueueCurrentBlockCount = property(lib_mvIMPACT_acquire.TransferControl_transferQueueCurrentBlockCount_get, doc=r"""
    An integer property. Returns the number of Block(s) currently in the transfer queue.
    Returns the number of Block(s) currently in the transfer queue.
    """)
    transferQueueMode = property(lib_mvIMPACT_acquire.TransferControl_transferQueueMode_get, doc=r"""
    An enumerated integer property. Specifies the operation mode of the transfer queue.
    Specifies the operation mode of the transfer queue.

    The following string values might be valid for this feature:
    - **FirstInFirstOut** (Display string: 'First In First Out'): Blocks first In are transferred Out first.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    transferStart = property(lib_mvIMPACT_acquire.TransferControl_transferStart_get, doc=r"""
    A method object. Starts the streaming of data blocks out of the device.
    Starts the streaming of data blocks out of the device. This feature must be available when the TransferControlMode is set to 'UserControlled'. If the TransferStart feature is not writable (locked), the application should not start the transfer and should avoid using the feature until it becomes writable again.
    """)
    transferStop = property(lib_mvIMPACT_acquire.TransferControl_transferStop_get, doc=r"""
    A method object. Stops the streaming of data Block(s).
    Stops the streaming of data Block(s). The current block transmission will be completed. This feature must be available when the TransferControlMode is set to 'UserControlled'.
    """)
    transferAbort = property(lib_mvIMPACT_acquire.TransferControl_transferAbort_get, doc=r"""
    A method object. Aborts immediately the streaming of data block(s).
    Aborts immediately the streaming of data block(s). Aborting the transfer will result in the lost of the data that is present or currently entering in the block queue. However, the next new block received will be stored in the queue and transferred to the host when the streaming is restarted. If implemented, this feature should be available when the TransferControlMode is set to 'UserControlled'.
    """)
    transferPause = property(lib_mvIMPACT_acquire.TransferControl_transferPause_get, doc=r"""
    A method object. Pauses the streaming of data Block(s).
    Pauses the streaming of data Block(s). Pausing the streaming will immediately suspend the ongoing data transfer even if a block is partially transfered. The device will resume its transmission at the reception of a TransferResume command.
    """)
    transferResume = property(lib_mvIMPACT_acquire.TransferControl_transferResume_get, doc=r"""
    A method object. Resumes a data Blocks streaming that was previously paused by a TransferPause command.
    Resumes a data Blocks streaming that was previously paused by a TransferPause command.
    """)
    transferTriggerSelector = property(lib_mvIMPACT_acquire.TransferControl_transferTriggerSelector_get, doc=r"""
    An enumerated integer property. Selects the type of transfer trigger to configure.
    Selects the type of transfer trigger to configure.

    The following string values might be valid for this feature:
    - **TransferStart** (Display string: 'Transfer Start'): Selects a trigger to start the transfers.
    - **TransferStop** (Display string: 'Transfer Stop'): Selects a trigger to stop the transfers.
    - **TransferAbort** (Display string: 'Transfer Abort'): Selects a trigger to abort the transfers.
    - **TransferPause** (Display string: 'Transfer Pause'): Selects a trigger to pause the transfers.
    - **TransferResume** (Display string: 'Transfer Resume'): Selects a trigger to Resume the transfers.
    - **TransferActive** (Display string: 'Transfer Active'): Selects a trigger to Activate the transfers. This trigger type is used when TriggerActivation is set LevelHigh or levelLow.
    - **TransferBurstStart** (Display string: 'Transfer Burst Start'): Selects a trigger to start the transfer of a burst of frames specified by TransferBurstCount.
    - **TransferBurstStop** (Display string: 'Transfer Burst Stop'): Selects a trigger to end the transfer of a burst of frames.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    transferTriggerMode = property(lib_mvIMPACT_acquire.TransferControl_transferTriggerMode_get, doc=r"""
    An enumerated integer property. Controls if the selected trigger is active.
    Controls if the selected trigger is active.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off'): Disables the selected trigger.
    - **On** (Display string: 'On'): Enable the selected trigger.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    transferTriggerSource = property(lib_mvIMPACT_acquire.TransferControl_transferTriggerSource_get, doc=r"""
    An enumerated integer property. Specifies the signal to use as the trigger source for transfers.
    Specifies the signal to use as the trigger source for transfers.

    The following string values might be valid for this feature:
    - **Line0** (Display string: 'Line 0'): Specifies which physical line (or pin) and associated I/O control block to use as external source for the transfer control trigger signal.
    - **Line1** (Display string: 'Line 1'): Specifies which physical line (or pin) and associated I/O control block to use as external source for the transfer control trigger signal.
    - **Line2** (Display string: 'Line 2'): Specifies which physical line (or pin) and associated I/O control block to use as external source for the transfer control trigger signal.
    - **Line**#3# (Display string: 'Line #3#'): Specifies which physical line (or pin) and associated I/O control block to use as external source for the transfer control trigger signal.
    - **Counter0Start** (Display string: 'Counter 0 Start'): Specifies which of the Counter signal to use as internal source for the transfer control trigger signal.
    - **Counter1Start** (Display string: 'Counter 1 Start'): Specifies which of the Counter signal to use as internal source for the transfer control trigger signal.
    - **Counter2Start** (Display string: 'Counter 2 Start'): Specifies which of the Counter signal to use as internal source for the transfer control trigger signal.
    - **Counter**#3#Start (Display string: 'Counter #3# Start'): Specifies which of the Counter signal to use as internal source for the transfer control trigger signal.
    - **Counter0End** (Display string: 'Counter 0 End'): Specifies which of the Counter signal to use as internal source for the transfer control trigger signal.
    - **Counter1End** (Display string: 'Counter 1 End'): Specifies which of the Counter signal to use as internal source for the transfer control trigger signal.
    - **Counter2End** (Display string: 'Counter 2 End'): Specifies which of the Counter signal to use as internal source for the transfer control trigger signal.
    - **Counter**#3#End (Display string: 'Counter #3# End'): Specifies which of the Counter signal to use as internal source for the transfer control trigger signal.
    - **Timer0Start** (Display string: 'Timer 0 Start'): Specifies which Timer signal to use as internal source for the transfer control trigger signal.
    - **Timer1Start** (Display string: 'Timer 1 Start'): Specifies which Timer signal to use as internal source for the transfer control trigger signal.
    - **Timer2Start** (Display string: 'Timer 2 Start'): Specifies which Timer signal to use as internal source for the transfer control trigger signal.
    - **Timer**#3#Start (Display string: 'Timer #3# Start'): Specifies which Timer signal to use as internal source for the transfer control trigger signal.
    - **Timer0End** (Display string: 'Timer 0 End'): Specifies which Timer signal to use as internal source for the transfer control trigger signal.
    - **Timer1End** (Display string: 'Timer 1 End'): Specifies which Timer signal to use as internal source for the transfer control trigger signal.
    - **Timer2End** (Display string: 'Timer 2 End'): Specifies which Timer signal to use as internal source for the transfer control trigger signal.
    - **Timer**#3#End (Display string: 'Timer #3# End'): Specifies which Timer signal to use as internal source for the transfer control trigger signal.
    - **LogicBlock0** (Display string: 'Logic Block 0'): Specifies which Logic Block to use as internal source for the transfer control trigger signal.
    - **LogicBlock1** (Display string: 'Logic Block 1'): Specifies which Logic Block to use as internal source for the transfer control trigger signal.
    - **LogicBlock2** (Display string: 'Logic Block 2'): Specifies which Logic Block to use as internal source for the transfer control trigger signal.
    - **LogicBlock**#3# (Display string: 'Logic Block #3#'): Specifies which Logic Block to use as internal source for the transfer control trigger signal.
    - **SoftwareSignal0** (Display string: 'Software Signal 0'): Specifies which Software Signal to use as internal source for the transfer control trigger signal.
    - **SoftwareSignal1** (Display string: 'Software Signal 1'): Specifies which Software Signal to use as internal source for the transfer control trigger signal.
    - **SoftwareSignal2** (Display string: 'Software Signal 2'): Specifies which Software Signal to use as internal source for the transfer control trigger signal.
    - **SoftwareSignal**#3# (Display string: 'Software Signal #3#'): Specifies which Software Signal to use as internal source for the transfer control trigger signal.
    - **Action0** (Display string: 'Action 0'): Specifies which Action command to use as internal source for the transfer control trigger signal.
    - **Action1** (Display string: 'Action 1'): Specifies which Action command to use as internal source for the transfer control trigger signal.
    - **Action2** (Display string: 'Action 2'): Specifies which Action command to use as internal source for the transfer control trigger signal.
    - **Action**#3# (Display string: 'Action #3#'): Specifies which Action command to use as internal source for the transfer control trigger signal.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    transferTriggerActivation = property(lib_mvIMPACT_acquire.TransferControl_transferTriggerActivation_get, doc=r"""
    An enumerated integer property. Specifies the activation mode of the transfer control trigger.
    Specifies the activation mode of the transfer control trigger.

    The following string values might be valid for this feature:
    - **RisingEdge** (Display string: 'Rising Edge'): Specifies that the trigger is considered valid on the rising edge of the source signal.
    - **FallingEdge** (Display string: 'Falling Edge'): Specifies that the trigger is considered valid on the falling edge of the source signal.
    - **AnyEdge** (Display string: 'Any Edge'): Specifies that the trigger is considered valid on the falling or rising edge of the source signal.
    - **LevelHigh** (Display string: 'Level High'): Specifies that the trigger is considered valid as long as the level of the source signal is high. This can apply to TransferActive and TransferPause trigger.
    - **LevelLow** (Display string: 'Level Low'): Specifies that the trigger is considered valid as long as the level of the source signal is low. This can apply to TransferActive and TransferPause trigger.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    transferStatusSelector = property(lib_mvIMPACT_acquire.TransferControl_transferStatusSelector_get, doc=r"""
    An enumerated integer property. Selects which status of the transfer module to read.
    Selects which status of the transfer module to read.

    The following string values might be valid for this feature:
    - **Streaming** (Display string: 'Streaming'): Data blocks are transmitted when enough data is available.
    - **Paused** (Display string: 'Paused'): Data blocks transmission is suspended immediately.
    - **Stopping** (Display string: 'Stopping'): Data blocks transmission is stopping. The current block transmission will be completed and the transfer state will stop.
    - **Stopped** (Display string: 'Stopped'): Data blocks transmission is stopped.
    - **QueueOverflow** (Display string: 'Queue Overflow'): Data blocks queue is in overflow state.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    transferStatus = property(lib_mvIMPACT_acquire.TransferControl_transferStatus_get, doc=r"""
    A boolean property. Reads the status of the Transfer module signal selected by TransferStatusSelector.
    Reads the status of the Transfer module signal selected by TransferStatusSelector.
    """)
    transferComponentSelector = property(lib_mvIMPACT_acquire.TransferControl_transferComponentSelector_get, doc=r"""
    An enumerated integer property. Selects the color component for the control of the TransferStreamChannel feature.
    Selects the color component for the control of the TransferStreamChannel feature.

    The following string values might be valid for this feature:
    - **Red** (Display string: 'Red'): The TransferStreamChannel feature controls the index of the stream channel for the streaming of the red plane of the planar pixel formats.
    - **Green** (Display string: 'Green'): The TransferStreamChannel feature controls the index of the stream channel for the streaming of the green plane of the planar pixel formats.
    - **Blue** (Display string: 'Blue'): The TransferStreamChannel feature controls the index of the stream channel for the streaming of blue plane of the planar pixel formats.
    - **All** (Display string: 'All'): The TransferStreamChannel feature controls the index of the stream channel for the streaming of all the planes of the planar pixel formats simultaneously or non planar pixel formats.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    transferStreamChannel = property(lib_mvIMPACT_acquire.TransferControl_transferStreamChannel_get, doc=r"""
    An integer property. Selects the streaming channel that will be used to transfer the selected stream of data.
    Selects the streaming channel that will be used to transfer the selected stream of data. In general, this feature can be omitted and the default streaming channel will be used.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_TransferControl

# Register TransferControl in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.TransferControl_swigregister(TransferControl)

class Scan3dControl(object):
    r"""
    Category for control of 3D camera specific features.
    A category for control of 3D camera specific features.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::GenICam::Scan3dControl** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.Scan3dControl_swiginit(self, lib_mvIMPACT_acquire.new_Scan3dControl(*args))
    scan3dExtractionSelector = property(lib_mvIMPACT_acquire.Scan3dControl_scan3dExtractionSelector_get, doc=r"""
    An enumerated integer property. Selects the 3DExtraction processing module to control (if multiple ones are present).
    Selects the 3DExtraction processing module to control (if multiple ones are present).

    The following string values might be valid for this feature:
    - **Scan3dExtraction0** (Display string: 'Scan 3d Extraction 0'): Selects Scan3d Extraction module 0.
    - **Scan3dExtraction1** (Display string: 'Scan 3d Extraction 1'): Selects Scan3d Extraction module 1.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    scan3dExtractionSource = property(lib_mvIMPACT_acquire.Scan3dControl_scan3dExtractionSource_get, doc=r"""
    An enumerated integer property. Selects the sensor's data source region for 3D Extraction module.
    Selects the sensor's data source region for 3D Extraction module.

    The following string values might be valid for this feature:
    - **Region0** (Display string: 'Region 0'): Data come from Sensor's Region0.
    - **Region1** (Display string: 'Region 1'): Data come from Sensor's Region1.
    - **Region**#2# (Display string: 'Region #2#'): Data come from Sensor's Region#2#.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    scan3dExtractionMethod = property(lib_mvIMPACT_acquire.Scan3dControl_scan3dExtractionMethod_get, doc=r"""
    An enumerated integer property. Selects the method for extracting 3D from the input sensor data.
    Selects the method for extracting 3D from the input sensor data.

    The following string values might be valid for this feature:
    - **Default** (Display string: 'Default'): Default range extraction method for the device.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    scan3dDistanceUnit = property(lib_mvIMPACT_acquire.Scan3dControl_scan3dDistanceUnit_get, doc=r"""
    An enumerated integer property. Specifies the unit used when delivering (calibrated) distance data.
    Specifies the unit used when delivering (calibrated) distance data.

    The following string values might be valid for this feature:
    - **Millimeter** (Display string: 'Millimeter'): Distance values are in millimeter units (default).
    - **Meter** (Display string: 'Meter'): Distance values are in meter units.
    - **Inch** (Display string: 'Inch'): Distance values are in inch units.
    - **Pixel** (Display string: 'Pixel'): Distance values are given as a multiple of the size of a pixel.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    scan3dCoordinateSystem = property(lib_mvIMPACT_acquire.Scan3dControl_scan3dCoordinateSystem_get, doc=r"""
    An enumerated integer property. Specifies the Coordinate system to use for the device.
    Specifies the Coordinate system to use for the device.

    The following string values might be valid for this feature:
    - **Cartesian** (Display string: 'Cartesian'): Default value. 3-axis orthogonal, right-hand X-Y-Z.
    - **Spherical** (Display string: 'Spherical'): A Theta-Phi-Rho coordinate system.
    - **Cylindrical** (Display string: 'Cylindrical'): A Theta-Y-Rho coordinate system.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    scan3dOutputMode = property(lib_mvIMPACT_acquire.Scan3dControl_scan3dOutputMode_get, doc=r"""
    An enumerated integer property. Controls the Calibration and data organization of the device and  the coordinates transmitted.
    Controls the Calibration and data organization of the device and  the coordinates transmitted.

    The following string values might be valid for this feature:
    - **UncalibratedC** (Display string: 'Uncalibrated C'): Uncalibrated 2.5D Depth map. The distance data does not represent a physical unit and may be non-linear. The data is a 2.5D range map only.
    - **CalibratedABC_Grid** (Display string: 'Calibrated ABC Grid'): 3 Coordinates in grid organization. The full 3 coordinate data with the grid array organization from the sensor kept.
    - **CalibratedABC_PointCloud** (Display string: 'Calibrated ABC Point Cloud'): 3 Coordinates without organization. The full 3 coordinate data without any organization of data points. Typically only valid points transmitted giving varying image size.
    - **CalibratedAC** (Display string: 'Calibrated AC'): 2 Coordinates with fixed B sampling. The data is sent as a A and C coordinates (X,Z or Theta,Rho). The B (Y) axis uses the scale and offset parameters for the B axis.
    - **CalibratedAC_Linescan** (Display string: 'Calibrated AC Linescan'): 2 Coordinates with varying sampling. The data is sent as a A and C coordinates (X,Z or Theta,Rho). The B (Y) axis comes from the encoder chunk value.
    - **CalibratedC** (Display string: 'Calibrated C'): Calibrated 2.5D Depth map. The distance data is expressed in the chosen distance unit. The data is a 2.5D range map. No information on X-Y axes available.
    - **CalibratedC_Linescan** (Display string: 'Calibrated C Linescan'): Depth Map with varying B sampling. The distance data is expressed in the chosen distance unit. The data is a 2.5D range map. The B (Y) axis comes from the encoder chunk value.
    - **RectifiedC** (Display string: 'Rectified C'): Rectified 2.5D Depth map. The distance data has been rectified to a uniform sampling pattern in the X and Y direction. The data is a 2.5D range map only. If a complete 3D point cloud is rectified but transmitted as explicit coordinates it should be transmitted as one of the 'CalibratedABC' formats.
    - **RectifiedC_Linescan** (Display string: 'Rectified C Linescan'): Rectified 2.5D Depth map with varying B sampling. The data is sent as rectified 1D profiles using Coord3D_C pixels. The B (Y) axis comes from the encoder chunk value.
    - **DisparityC** (Display string: 'Disparity C'): Disparity 2.5D Depth map. The distance is inversely proportional to the pixel (disparity) value.
    - **DisparityC_Linescan** (Display string: 'Disparity C Linescan'): Disparity 2.5D Depth map with varying B sampling. The distance is inversely proportional to the pixel (disparity) value. The B (Y) axis comes from the encoder chunk value.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    scan3dCoordinateSystemReference = property(lib_mvIMPACT_acquire.Scan3dControl_scan3dCoordinateSystemReference_get, doc=r"""
    An enumerated integer property. Defines coordinate system reference location.
    Defines coordinate system reference location.

    The following string values might be valid for this feature:
    - **Anchor** (Display string: 'Anchor'): Default value. Original fixed reference. The coordinate system fixed relative the camera reference point marker is used.
    - **Transformed** (Display string: 'Transformed'): Transformed reference system. The transformed coordinate system is used according to the definition in the rotation and translation matrices.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    scan3dCoordinateSelector = property(lib_mvIMPACT_acquire.Scan3dControl_scan3dCoordinateSelector_get, doc=r"""
    An enumerated integer property. Selects the individual coordinates in the vectors for 3D information/transformation.
    Selects the individual coordinates in the vectors for 3D information/transformation.

    The following string values might be valid for this feature:
    - **CoordinateA** (Display string: 'Coordinate A'): The first (X or Theta) coordinate
    - **CoordinateB** (Display string: 'Coordinate B'): The second (Y or Phi) coordinate
    - **CoordinateC** (Display string: 'Coordinate C'): The third (Z or Rho) coordinate.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    scan3dCoordinateScale = property(lib_mvIMPACT_acquire.Scan3dControl_scan3dCoordinateScale_get, doc=r"""
    A floating point property. Scale factor when transforming a pixel from relative coordinates to world coordinates.
    Scale factor when transforming a pixel from relative coordinates to world coordinates.
    """)
    scan3dCoordinateOffset = property(lib_mvIMPACT_acquire.Scan3dControl_scan3dCoordinateOffset_get, doc=r"""
    A floating point property. Offset when transforming a pixel from relative coordinates to world coordinates.
    Offset when transforming a pixel from relative coordinates to world coordinates.
    """)
    scan3dInvalidDataFlag = property(lib_mvIMPACT_acquire.Scan3dControl_scan3dInvalidDataFlag_get, doc=r"""
    A boolean property. Enables the definition of a non-valid flag value in the data stream.
    Enables the definition of a non-valid flag value in the data stream. Note that the confidence output is an alternate recommended way to identify non-valid pixels. Using a Scan3dInvalidDataValue may give processing penalties due to special handling.
    """)
    scan3dInvalidDataValue = property(lib_mvIMPACT_acquire.Scan3dControl_scan3dInvalidDataValue_get, doc=r"""
    A floating point property. Value which identifies a non-valid pixel if Scan3dInvalidDataFlag is enabled.
    Value which identifies a non-valid pixel if Scan3dInvalidDataFlag is enabled.
    """)
    scan3dAxisMin = property(lib_mvIMPACT_acquire.Scan3dControl_scan3dAxisMin_get, doc=r"""
    A floating point property. Minimum valid transmitted coordinate value of the selected Axis.
    Minimum valid transmitted coordinate value of the selected Axis.
    """)
    scan3dAxisMax = property(lib_mvIMPACT_acquire.Scan3dControl_scan3dAxisMax_get, doc=r"""
    A floating point property. Maximum valid transmitted coordinate value of the selected Axis.
    Maximum valid transmitted coordinate value of the selected Axis.
    """)
    scan3dCoordinateTransformSelector = property(lib_mvIMPACT_acquire.Scan3dControl_scan3dCoordinateTransformSelector_get, doc=r"""
    An enumerated integer property. Sets the index to read/write a coordinate transform value.
    Sets the index to read/write a coordinate transform value.

    The following string values might be valid for this feature:
    - **RotationX** (Display string: 'Rotation X'): Rotation around X axis.
    - **RotationY** (Display string: 'Rotation Y'): Rotation around Y axis.
    - **RotationZ** (Display string: 'Rotation Z'): Rotation around Z axis.
    - **TranslationX** (Display string: 'Translation X'): Translation along X axis.
    - **TranslationY** (Display string: 'Translation Y'): Translation along Y axis.
    - **TranslationZ** (Display string: 'Translation Z'): Translation along Z axis.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    scan3dTransformValue = property(lib_mvIMPACT_acquire.Scan3dControl_scan3dTransformValue_get, doc=r"""
    A floating point property. Specifies the transform value selected.
    Specifies the transform value selected. For translations (Scan3dCoordinateTransformSelector = TranslationX/Y/Z) it is expressed in the distance unit of the system, for rotations (Scan3dCoordinateTransformSelector =RotationX/Y/Z) in degrees.
    """)
    scan3dCoordinateReferenceSelector = property(lib_mvIMPACT_acquire.Scan3dControl_scan3dCoordinateReferenceSelector_get, doc=r"""
    An enumerated integer property. Sets the index to read a coordinate system reference value defining the transform of a point from the current (Anchor or Transformed) system to the reference system.
    Sets the index to read a coordinate system reference value defining the transform of a point from the current (Anchor or Transformed) system to the reference system.

    The following string values might be valid for this feature:
    - **RotationX** (Display string: 'Rotation X'): Rotation around X axis.
    - **RotationY** (Display string: 'Rotation Y'): Rotation around Y axis.
    - **RotationZ** (Display string: 'Rotation Z'): Rotation around Z axis.
    - **TranslationX** (Display string: 'Translation X'): X axis translation.
    - **TranslationY** (Display string: 'Translation Y'): Y axis translation.
    - **TranslationZ** (Display string: 'Translation Z'): Z axis translation.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    scan3dCoordinateReferenceValue = property(lib_mvIMPACT_acquire.Scan3dControl_scan3dCoordinateReferenceValue_get, doc=r"""
    A floating point property. Returns the reference value selected.
    Returns the reference value selected. Reads the value of a rotation or translation value for the current (Anchor or Transformed) coordinate system transformation to the Reference system.
    """)
    scan3dFocalLength = property(lib_mvIMPACT_acquire.Scan3dControl_scan3dFocalLength_get, doc=r"""
    A floating point property. Returns the focal length of the camera in pixel.
    Returns the focal length of the camera in pixel. The focal length depends on the selected region. The value of this feature takes into account horizontal binning, decimation, or any other function changing the image resolution.
    """)
    scan3dBaseline = property(lib_mvIMPACT_acquire.Scan3dControl_scan3dBaseline_get, doc=r"""
    A floating point property. Returns the baseline as the physical distance of two cameras in a stereo camera setup.
    Returns the baseline as the physical distance of two cameras in a stereo camera setup. The value of this feature can be used for 3D reconstruction from disparity images. In this case, the unit of the 3D coordinates corresponds to the unit of the baseline.
    """)
    scan3dPrincipalPointU = property(lib_mvIMPACT_acquire.Scan3dControl_scan3dPrincipalPointU_get, doc=r"""
    A floating point property. Returns the value of the horizontal position of the principal point, relative to the region origin, i.e.
    Returns the value of the horizontal position of the principal point, relative to the region origin, i.e. OffsetX. The value of this feature takes into account horizontal binning, decimation, or any other function changing the image resolution.
    """)
    scan3dPrincipalPointV = property(lib_mvIMPACT_acquire.Scan3dControl_scan3dPrincipalPointV_get, doc=r"""
    A floating point property. Returns the value of the vertical position of the principal point, relative to the region origin, i.e.
    Returns the value of the vertical position of the principal point, relative to the region origin, i.e. OffsetY. The value of this feature takes into account vertical binning, decimation, or any other function changing the image resolution.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_Scan3dControl

# Register Scan3dControl in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.Scan3dControl_swigregister(Scan3dControl)

class LightControl(object):
    r"""
    Category containing the Lighting control features.
    A category containing the Lighting control features.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::GenICam::LightControl** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.LightControl_swiginit(self, lib_mvIMPACT_acquire.new_LightControl(*args))
    lightControllerSelector = property(lib_mvIMPACT_acquire.LightControl_lightControllerSelector_get, doc=r"""
    An enumerated integer property. Selects the Light Controller to configure.
    Selects the Light Controller to configure.

    The following string values might be valid for this feature:
    - **LightController0** (Display string: 'Light Controller 0'): Light Controller 0
    - **LightController1** (Display string: 'Light Controller 1'): Light Controller 1
    - **LightController2** (Display string: 'Light Controller 2'): Light Controller 2
    - **LightController**#3# (Display string: 'Light Controller #3#'): Light Controller #3#
    - **LightController3** (Display string: 'Light Controller 3'): Light Controller 3
    - **LightController4** (Display string: 'Light Controller 4'): Light Controller 4
    - **LightController5** (Display string: 'Light Controller 5'): Light Controller 5
    - **LightController6** (Display string: 'Light Controller 6'): Light Controller 6
    - **LightController7** (Display string: 'Light Controller 7'): Light Controller 7
    - **LightController8** (Display string: 'Light Controller 8'): Light Controller 8
    - **LightController9** (Display string: 'Light Controller 9'): Light Controller 9
    - **LightController10** (Display string: 'Light Controller 10'): Light Controller 10
    - **LightController11** (Display string: 'Light Controller 11'): Light Controller 11
    - **LightController12** (Display string: 'Light Controller 12'): Light Controller 12
    - **LightController13** (Display string: 'Light Controller 13'): Light Controller 13
    - **LightController14** (Display string: 'Light Controller 14'): Light Controller 14
    - **LightController15** (Display string: 'Light Controller 15'): Light Controller 15

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    lightControllerSource = property(lib_mvIMPACT_acquire.LightControl_lightControllerSource_get, doc=r"""
    An enumerated integer property. Selects the input source signal of the Light Controller.
    Selects the input source signal of the Light Controller.

    The following string values might be valid for this feature:
    - **Line0** (Display string: 'Line 0'): Line 0
    - **Line**#1# (Display string: 'Line #1#'): Line #1#
    - **Timer0** (Display string: 'Timer 0'): Timer 0
    - **Timer**#1# (Display string: 'Timer #1#'): Timer #1#
    - **Counter0** (Display string: 'Counter 0'): Counter 0
    - **Counter**#1# (Display string: 'Counter #1#'): Counter #1#
    - **UserOutput0** (Display string: 'User Output 0'): User Output 0
    - **UserOutput**#1# (Display string: 'User Output #1#'): User Output #1#
    - **Line1** (Display string: 'Line 1'): Line 1
    - **Line2** (Display string: 'Line 2'): Line 2
    - **Line3** (Display string: 'Line 3'): Line 3
    - **Line4** (Display string: 'Line 4'): Line 4
    - **Line5** (Display string: 'Line 5'): Line 5
    - **Line6** (Display string: 'Line 6'): Line 6
    - **Line7** (Display string: 'Line 7'): Line 7
    - **Line8** (Display string: 'Line 8'): Line 8
    - **Line9** (Display string: 'Line 9'): Line 9
    - **Line10** (Display string: 'Line 10'): Line 10
    - **Line11** (Display string: 'Line 11'): Line 11
    - **Line12** (Display string: 'Line 12'): Line 12
    - **Line13** (Display string: 'Line 13'): Line 13
    - **Line14** (Display string: 'Line 14'): Line 14
    - **Line15** (Display string: 'Line 15'): Line 15
    - **Timer1** (Display string: 'Timer 1'): Timer 1
    - **Timer2** (Display string: 'Timer 2'): Timer 2
    - **Timer3** (Display string: 'Timer 3'): Timer 3
    - **Timer4** (Display string: 'Timer 4'): Timer 4
    - **Timer5** (Display string: 'Timer 5'): Timer 5
    - **Timer6** (Display string: 'Timer 6'): Timer 6
    - **Timer7** (Display string: 'Timer 7'): Timer 7
    - **Timer8** (Display string: 'Timer 8'): Timer 8
    - **Timer9** (Display string: 'Timer 9'): Timer 9
    - **Timer10** (Display string: 'Timer 10'): Timer 10
    - **Timer11** (Display string: 'Timer 11'): Timer 11
    - **Timer12** (Display string: 'Timer 12'): Timer 12
    - **Timer13** (Display string: 'Timer 13'): Timer 13
    - **Timer14** (Display string: 'Timer 14'): Timer 14
    - **Timer15** (Display string: 'Timer 15'): Timer 15
    - **Counter1** (Display string: 'Counter 1'): Counter 1
    - **Counter2** (Display string: 'Counter 2'): Counter 2
    - **Counter3** (Display string: 'Counter 3'): Counter 3
    - **Counter4** (Display string: 'Counter 4'): Counter 4
    - **Counter5** (Display string: 'Counter 5'): Counter 5
    - **Counter6** (Display string: 'Counter 6'): Counter 6
    - **Counter7** (Display string: 'Counter 7'): Counter 7
    - **Counter8** (Display string: 'Counter 8'): Counter 8
    - **Counter9** (Display string: 'Counter 9'): Counter 9
    - **Counter10** (Display string: 'Counter 10'): Counter 10
    - **Counter11** (Display string: 'Counter 11'): Counter 11
    - **Counter12** (Display string: 'Counter 12'): Counter 12
    - **Counter13** (Display string: 'Counter 13'): Counter 13
    - **Counter14** (Display string: 'Counter 14'): Counter 14
    - **Counter15** (Display string: 'Counter 15'): Counter 15
    - **UserOutput1** (Display string: 'User Output 1'): User Output 1
    - **UserOutput2** (Display string: 'User Output 2'): User Output 2
    - **UserOutput3** (Display string: 'User Output 3'): User Output 3
    - **UserOutput4** (Display string: 'User Output 4'): User Output 4
    - **UserOutput5** (Display string: 'User Output 5'): User Output 5
    - **UserOutput6** (Display string: 'User Output 6'): User Output 6
    - **UserOutput7** (Display string: 'User Output 7'): User Output 7
    - **UserOutput8** (Display string: 'User Output 8'): User Output 8
    - **UserOutput9** (Display string: 'User Output 9'): User Output 9
    - **UserOutput10** (Display string: 'User Output 10'): User Output 10
    - **UserOutput11** (Display string: 'User Output 11'): User Output 11
    - **UserOutput12** (Display string: 'User Output 12'): User Output 12
    - **UserOutput13** (Display string: 'User Output 13'): User Output 13
    - **UserOutput14** (Display string: 'User Output 14'): User Output 14
    - **UserOutput15** (Display string: 'User Output 15'): User Output 15

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    lightCurrentRating = property(lib_mvIMPACT_acquire.LightControl_lightCurrentRating_get, doc=r"""
    A floating point property. Set the current rating of the lighting output.
    Set the current rating of the lighting output.
    """)
    lightVoltageRating = property(lib_mvIMPACT_acquire.LightControl_lightVoltageRating_get, doc=r"""
    A floating point property. Set the voltage rating of the lighting output.
    Set the voltage rating of the lighting output.
    """)
    lightBrightness = property(lib_mvIMPACT_acquire.LightControl_lightBrightness_get, doc=r"""
    A floating point property. Set the brightness of the lighting output in percent.
    Set the brightness of the lighting output in percent. Can be greater than 100% for short overdrive period.
    """)
    lightConnectionStatus = property(lib_mvIMPACT_acquire.LightControl_lightConnectionStatus_get, doc=r"""
    An enumerated integer property. Status of a light connected to the controller's output Line.
    Status of a light connected to the controller's output Line.

    The following string values might be valid for this feature:
    - **Sensing** (Display string: 'Sensing'): Sensing
    - **Ready** (Display string: 'Ready'): Ready
    - **NoConnect** (Display string: 'No Connect'): No Connect
    - **Error** (Display string: 'Error'): Error

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    lightCurrentMeasured = property(lib_mvIMPACT_acquire.LightControl_lightCurrentMeasured_get, doc=r"""
    A floating point property. The measured current applied to the lighting.
    The measured current applied to the lighting.
    """)
    lightVoltageMeasured = property(lib_mvIMPACT_acquire.LightControl_lightVoltageMeasured_get, doc=r"""
    A floating point property. The measured voltage applied to the lighting.
    The measured voltage applied to the lighting.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_LightControl

# Register LightControl in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.LightControl_swigregister(LightControl)

class ChunkDataControl(object):
    r"""
    Category that contains the Chunk Data control features.
    A category that contains the Chunk Data control features.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::GenICam::ChunkDataControl** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.ChunkDataControl_swiginit(self, lib_mvIMPACT_acquire.new_ChunkDataControl(*args))
    chunkModeActive = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkModeActive_get, doc=r"""
    A boolean property. Activates the inclusion of Chunk data in the transmitted payload.
    Activates the inclusion of Chunk data in the transmitted payload.
    """)
    chunkXMLEnable = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkXMLEnable_get, doc=r"""
    A boolean property. Activates the inclusion of the GenICam XML necessary to the chunk parser to decode all the Chunk data included in the transmitted payload.
    Activates the inclusion of the GenICam XML necessary to the chunk parser to decode all the Chunk data included in the transmitted payload.
    """)
    chunkSelector = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkSelector_get, doc=r"""
    An enumerated integer property. Selects which Chunk to enable or control.
    Selects which Chunk to enable or control.

    The following string values might be valid for this feature:
    - **Image** (Display string: 'Image'): Image
    - **OffsetX** (Display string: 'Offset X'): Offset X
    - **OffsetY** (Display string: 'Offset Y'): Offset Y
    - **Width** (Display string: 'Width'): Width
    - **Height** (Display string: 'Height'): Height
    - **PixelFormat** (Display string: 'Pixel Format'): Pixel Format
    - **PixelDynamicRangeMin** (Display string: 'Pixel Dynamic Range Min'): Pixel Dynamic Range Min
    - **PixelDynamicRangeMax** (Display string: 'Pixel Dynamic Range Max'): Pixel Dynamic Range Max
    - **BinningHorizontal** (Display string: 'Binning Horizontal'): Binning Horizontal
    - **BinningVertical** (Display string: 'Binning Vertical'): Binning Vertical
    - **DecimationHorizontal** (Display string: 'Decimation Horizontal'): Decimation Horizontal
    - **DecimationVertical** (Display string: 'Decimation Vertical'): Decimation Vertical
    - **ReverseX** (Display string: 'Reverse X'): Reverse X
    - **ReverseY** (Display string: 'Reverse Y'): Reverse Y
    - **Timestamp** (Display string: 'Timestamp'): Timestamp
    - **TimestampLatchValue** (Display string: 'Timestamp Latch Value'): Timestamp Latch Value
    - **LineStatusAll** (Display string: 'Line Status All'): Line Status All
    - **CounterValue** (Display string: 'Counter Value'): Counter Value
    - **TimerValue** (Display string: 'Timer Value'): Timer Value
    - **EncoderValue** (Display string: 'Encoder Value'): Encoder Value
    - **EncoderStatusValue** (Display string: 'Encoder Status Value'): Encoder Status Value
    - **ExposureTime** (Display string: 'Exposure Time'): Exposure Time
    - **Gain** (Display string: 'Gain'): Gain
    - **BlackLevel** (Display string: 'Black Level'): Black Level
    - **LinePitch** (Display string: 'Line Pitch'): Line Pitch
    - **FrameID** (Display string: 'Frame ID'): Frame ID
    - **SourceID** (Display string: 'Source ID'): Source ID
    - **SourceIDValue** (Display string: 'Source ID Value'): Source ID Value
    - **RegionID** (Display string: 'Region ID'): Region ID
    - **RegionIDValue** (Display string: 'Region ID Value'): Region ID Value
    - **ComponentID** (Display string: 'Component ID'): Component ID
    - **ComponentIDValue** (Display string: 'Component ID Value'): Component ID Value
    - **GroupIDValue** (Display string: 'Group ID Value'): Group ID Value
    - **TransferBlockID** (Display string: 'Transfer Block ID'): Transfer Block ID
    - **TransferStreamID** (Display string: 'Transfer Stream ID'): Transfer Stream ID
    - **TransferQueueCurrentBlockCount** (Display string: 'Transfer Queue Current Block Count'): Transfer Queue Current Block Count
    - **StreamChannelID** (Display string: 'Stream Channel ID'): Stream Channel ID
    - **SequencerSetActive** (Display string: 'Sequencer Set Active'): Sequencer Set Active
    - **Scan3dDistanceUnit** (Display string: 'Scan 3d Distance Unit'): Scan 3d Distance Unit
    - **Scan3dOutputMode** (Display string: 'Scan 3d Output Mode'): Scan 3d Output Mode
    - **Scan3dCoordinateSystem** (Display string: 'Scan 3d Coordinate System'): Scan 3d Coordinate System
    - **Scan3dCoordinateSystemReference** (Display string: 'Scan 3d Coordinate System Reference'): Scan 3d Coordinate System Reference
    - **Scan3dCoordinateScale** (Display string: 'Scan 3d Coordinate Scale'): Scan 3d Coordinate Scale
    - **Scan3dCoordinateOffset** (Display string: 'Scan 3d Coordinate Offset'): Scan 3d Coordinate Offset
    - **Scan3dInvalidDataFlag** (Display string: 'Scan 3d Invalid Data Flag'): Scan 3d Invalid Data Flag
    - **Scan3dInvalidDataValue** (Display string: 'Scan 3d Invalid Data Value'): Scan 3d Invalid Data Value
    - **Scan3dAxisMin** (Display string: 'Scan 3d Axis Min'): Scan 3d Axis Min
    - **Scan3dAxisMax** (Display string: 'Scan 3d Axis Max'): Scan 3d Axis Max
    - **Scan3dCoordinateTransformValue** (Display string: 'Scan 3d Coordinate Transform Value'): Scan 3d Coordinate Transform Value
    - **Scan3dCoordinateReferenceValue** (Display string: 'Scan 3d Coordinate Reference Value'): Scan 3d Coordinate Reference Value
    - **AdditionalInfo** (Display string: 'Additional Info')
    - **JPEG** (Display string: 'JPEG')
    - **mvCustomIdentifier** (Display string: 'mv Custom Identifier')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    chunkEnable = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkEnable_get, doc=r"""
    A boolean property. Enables the inclusion of the selected Chunk data in the payload of the image.
    Enables the inclusion of the selected Chunk data in the payload of the image.
    """)
    chunkRegionSelector = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkRegionSelector_get, doc=r"""
    An enumerated integer property. Selects which Region to retrieve data from.
    Selects which Region to retrieve data from.

    The following string values might be valid for this feature:
    - **Region0** (Display string: 'Region 0'): Image comes from the Region 0.
    - **Region1** (Display string: 'Region 1'): Image comes from the Region 1.
    - **Region2** (Display string: 'Region 2'): Image comes from the Region 2.
    - **Region**#3# (Display string: 'Region #3#'): Image comes from the Region #3#.
    - **Scan3dExtraction0** (Display string: 'Scan 3d Extraction 0'): Image comes from the Scan3dExtraction output Region 0.
    - **Scan3dExtraction1** (Display string: 'Scan 3d Extraction 1'): Image comes from the Scan3dExtraction output Region 1.
    - **Scan3dExtraction2** (Display string: 'Scan 3d Extraction 2'): Image comes from the Scan3dExtraction output Region 2.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    chunkRegionID = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkRegionID_get, doc=r"""
    An enumerated integer property. Returns the Identifier of Region that the image comes from.
    Returns the Identifier of Region that the image comes from.

    The following string values might be valid for this feature:
    - **Region0** (Display string: 'Region 0'): Image comes from the Region 0.
    - **Region1** (Display string: 'Region 1'): Image comes from the Region 1.
    - **Region2** (Display string: 'Region 2'): Image comes from the Region 2.
    - **Region**#3# (Display string: 'Region #3#'): Image comes from the Region #3#.
    - **Scan3dExtraction0** (Display string: 'Scan 3d Extraction 0'): Image comes from the Scan3dExtraction output Region 0.
    - **Scan3dExtraction1** (Display string: 'Scan 3d Extraction 1'): Image comes from the Scan3dExtraction output Region 1.
    - **Scan3dExtraction2** (Display string: 'Scan 3d Extraction 2'): Image comes from the Scan3dExtraction output Region 2.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    chunkRegionIDValue = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkRegionIDValue_get, doc=r"""
    An integer property. Returns the unique integer Identifier value of the Region that the image comes from.
    Returns the unique integer Identifier value of the Region that the image comes from.
    """)
    chunkComponentSelector = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkComponentSelector_get, doc=r"""
    An enumerated integer property. Selects the Component from which to retrieve data from.
    Selects the Component from which to retrieve data from.

    The following string values might be valid for this feature:
    - **Intensity** (Display string: 'Intensity'): The image data is the intensity component (visible).
    - **Infrared** (Display string: 'Infrared'): The image data is the infrared component.
    - **Ultraviolet** (Display string: 'Ultraviolet'): The image data is the ultraviolet component.
    - **Range** (Display string: 'Range'): The image data is the range component (distance or depth).
    - **Reflectance** (Display string: 'Reflectance'): The image data is the reflected intensity component (acquired with the Range).
    - **Disparity** (Display string: 'Disparity'): The image data is the disparity component.
    - **Confidence** (Display string: 'Confidence'): The image data is the confidence map component.
    - **Scatter** (Display string: 'Scatter'): The image data is the scatter component.
    - **Multispectral** (Display string: 'Multispectral'): The image data is the multispectral component.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    chunkComponentID = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkComponentID_get, doc=r"""
    An enumerated integer property. Returns the Identifier of the selected Component.
    Returns the Identifier of the selected Component. This can be used to identify the image component type of a multi-component payload.

    The following string values might be valid for this feature:
    - **Intensity** (Display string: 'Intensity'): The image data is the intensity component (visible).
    - **Infrared** (Display string: 'Infrared'): The image data is the infrared component.
    - **Ultraviolet** (Display string: 'Ultraviolet'): The image data is the ultraviolet component.
    - **Range** (Display string: 'Range'): The image data is the range component (distance or depth).
    - **Reflectance** (Display string: 'Reflectance'): The image data is the reflected intensity component (acquired with the Range).
    - **Disparity** (Display string: 'Disparity'): The image data is the disparity component.
    - **Confidence** (Display string: 'Confidence'): The image data is the confidence map component.
    - **Scatter** (Display string: 'Scatter'): The image data is the scatter component.
    - **Multispectral** (Display string: 'Multispectral'): The image data is the multispectral component.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    chunkComponentIDValue = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkComponentIDValue_get, doc=r"""
    An integer property. Returns a unique Identifier value that corresponds to the selected chunk Component.
    Returns a unique Identifier value that corresponds to the selected chunk Component.
    """)
    chunkGroupSelector = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkGroupSelector_get, doc=r"""
    An enumerated integer property. Selects the component Group from which to retrieve data from.
    Selects the component Group from which to retrieve data from.

    The following string values might be valid for this feature:
    - **Group0** (Display string: 'Group 0'): Selects Components group 0.
    - **Group1** (Display string: 'Group 1'): Selects Components group 1.
    - **Group2** (Display string: 'Group 2'): Selects Components group 2.
    - **Group**#3# (Display string: 'Group #3#'): Selects Components group #3#.
    - **Group3** (Display string: 'Group 3'): Selects Components group 3.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    chunkGroupID = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkGroupID_get, doc=r"""
    An enumerated integer property. Returns a unique Identifier corresponding to the selected Group of components.
    Returns a unique Identifier corresponding to the selected Group of components. This can be used to identify the component Group of a multi-group payload.

    The following string values might be valid for this feature:
    - **Group0** (Display string: 'Group 0'): Selects Components group 0.
    - **Group1** (Display string: 'Group 1'): Selects Components group 1.
    - **Group2** (Display string: 'Group 2'): Selects Components group 2.
    - **Group**#3# (Display string: 'Group #3#'): Selects Components group #3#.
    - **Group3** (Display string: 'Group 3'): Selects Components group 3.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    chunkImageComponent = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkImageComponent_get, doc=r"""
    An enumerated integer property. This feature is deprecated (See ChunkComponentID).
    Deprecated: 
    This feature is deprecated (See ChunkComponentID). It was representing the component of the payload image.

    The following string values might be valid for this feature:
    - **Intensity** (Display string: 'Intensity'): Intensity
    - **Infrared** (Display string: 'Infrared'): Infrared
    - **Ultraviolet** (Display string: 'Ultraviolet'): Ultraviolet
    - **Range** (Display string: 'Range'): Range
    - **Reflectance** (Display string: 'Reflectance'): Reflectance
    - **Disparity** (Display string: 'Disparity'): Disparity
    - **Confidence** (Display string: 'Confidence'): Confidence
    - **Scatter** (Display string: 'Scatter'): Scatter

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    chunkGroupIDValue = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkGroupIDValue_get, doc=r"""
    An integer property. Returns a unique Identifier value that corresponds to the Group of Components of the selected chunk Component.
    Returns a unique Identifier value that corresponds to the Group of Components of the selected chunk Component.
    """)
    chunkPartSelector = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkPartSelector_get, doc=r"""
    An integer property. This feature is deprecated (See ChunkComponentSelector).
    Deprecated: 
    This feature is deprecated (See ChunkComponentSelector). It was selecting the individual parts of a multi-component/multi-part buffer to access.
    """)
    chunkImage = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkImage_get, doc=r"""
    A string property. Returns the entire image data included in the payload.
    Returns the entire image data included in the payload.
    """)
    chunkOffsetX = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkOffsetX_get, doc=r"""
    An integer property. Returns the OffsetX of the image included in the payload.
    Returns the OffsetX of the image included in the payload.
    """)
    chunkOffsetY = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkOffsetY_get, doc=r"""
    An integer property. Returns the OffsetY of the image included in the payload.
    Returns the OffsetY of the image included in the payload.
    """)
    chunkWidth = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkWidth_get, doc=r"""
    An integer property. Returns the Width of the image included in the payload.
    Returns the Width of the image included in the payload.
    """)
    chunkHeight = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkHeight_get, doc=r"""
    An integer property. Returns the Height of the image included in the payload.
    Returns the Height of the image included in the payload.
    """)
    chunkPixelFormat = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkPixelFormat_get, doc=r"""
    An enumerated integer property. Returns the PixelFormat of the image included in the payload.
    Returns the PixelFormat of the image included in the payload.

    The following string values might be valid for this feature:
    - **Mono1p** (Display string: 'Mono1p'): Mono 1 bit packed.
    - **Mono2p** (Display string: 'Mono2p'): Mono 2 bit packed.
    - **Mono4p** (Display string: 'Mono4p'): Mono 4 bit packed.
    - **Mono8** (Display string: 'Mono8'): Mono 8 bit packed.
    - **Mono8s** (Display string: 'Mono8s'): Mono 1 bit signed.
    - **Mono10** (Display string: 'Mono10'): Mono 10 bit.
    - **Mono10p** (Display string: 'Mono10p'): Mono 10 bit packed.
    - **Mono12** (Display string: 'Mono12'): Mono 12 bit.
    - **Mono12p** (Display string: 'Mono12p'): Mono 12 bit packed.
    - **Mono14** (Display string: 'Mono14'): Mono 14 bit.
    - **Mono16** (Display string: 'Mono16'): Mono 16 bit.
    - **R8** (Display string: 'R8'): Red 8 bit.
    - **G8** (Display string: 'G8'): Green 8 bit.
    - **B8** (Display string: 'B8'): Blue 8 bit.
    - **RGB8** (Display string: 'RGB8'): Red, Green, Blue 8 bit
    - **RGB8_Planar** (Display string: 'RGB8_Planar'): Red, Green, Blue 8 bit planar.
    - **RGBa8** (Display string: 'RGBa8'): Red, Green, Blue 8 bit aligned on 8 bit
    - **RGB10** (Display string: 'RGB10'): Red, Green, Blue 10 bit.
    - **RGB10_Planar** (Display string: 'RGB10_Planar'): Red, Green, Blue 10 bit planar.
    - **RGB10p32** (Display string: 'RGB10p32'): Red, Green, Blue 10 bit packed in 32 bit pixel.
    - **RGB12** (Display string: 'RGB12'): Red, Green, Blue 12 bit.
    - **RGB12_Planar** (Display string: 'RGB12_Planar'): Red, Green, Blue 12 bit planar.
    - **RGB16** (Display string: 'RGB16'): Red, Green, Blue 16 bit.
    - **RGB16_Planar** (Display string: 'RGB16_Planar'): Red, Green, Blue 16 bit planar.
    - **RGB565p** (Display string: 'RGB565p'): Red, Green, Blue 16 bit packet in 5, 6, 5 bits.
    - **BGR10** (Display string: 'BGR10'): Blue, Green, Red, 10 bit.
    - **BGR12** (Display string: 'BGR12'): Blue, Green, Red, 12 bit.
    - **BGR16** (Display string: 'BGR16'): Blue, Green, Red, 16 bit.
    - **BGR565p** (Display string: 'BGR565p'): Blue, Green, Red, 16 bit packet in 5, 6, 5 bits.
    - **BGR8** (Display string: 'BGR8'): Blue, Green, Red, 8 bit.
    - **BGRa8** (Display string: 'BGRa8'): Blue, Green, Red, Alpha 8 bit.
    - **YUV422_8** (Display string: 'YUV422_8'): YUV 422 8 bit.
    - **YCbCr411_8** (Display string: 'YCbCr411_8'): YCrCb 411 8 bit.
    - **YCbCr422_8** (Display string: 'YCbCr422_8'): YCrCb 422 8 bit.
    - **YCbCr601_422_8** (Display string: 'YCbCr601_422_8'): YCrCb 601 422 8 bit.
    - **YCbCr709_422_8** (Display string: 'YCbCr709_422_8'): YCrCb 709 422 8 bit.
    - **YCbCr8** (Display string: 'YCbCr8'): YCbCr 8 bit.
    - **BayerBG8** (Display string: 'BayerBG8'): Bayer Blue Green 8 bit.
    - **BayerGB8** (Display string: 'BayerGB8'): Bayer Green Blue 8 bit.
    - **BayerGR8** (Display string: 'BayerGR8'): Bayer Green Red 8 bit.
    - **BayerRG8** (Display string: 'BayerRG8'): Bayer Red Green 8 bit.
    - **BayerBG10** (Display string: 'BayerBG10'): Bayer Blue Green 10 bit.
    - **BayerGB10** (Display string: 'BayerGB10'): Bayer Green Blue 10 bit.
    - **BayerGR10** (Display string: 'BayerGR10'): Bayer Green Red 10 bit.
    - **BayerRG10** (Display string: 'BayerRG10'): Bayer Red Green 10 bit.
    - **BayerBG12** (Display string: 'BayerBG12'): Bayer Blue Green 12 bit
    - **BayerGB12** (Display string: 'BayerGB12'): Bayer Green Blue 12 bit
    - **BayerGR12** (Display string: 'BayerGR12'): Bayer Green Red 12 bit.
    - **BayerRG12** (Display string: 'BayerRG12'): Bayer Red Green 12 bit.
    - **BayerBG16** (Display string: 'BayerBG16'): Bayer Blue Green 16 bit.
    - **BayerGB16** (Display string: 'BayerGB16'): Bayer Green Blue 16 bit.
    - **BayerGR16** (Display string: 'BayerGR16'): Bayer Green Red 16 bit.
    - **BayerRG16** (Display string: 'BayerRG16'): Bayer Red Green 16 bit.
    - **Coord3D_A8** (Display string: 'Coord3D_A8'): 3D coordinate, first component 8 bit.
    - **Coord3D_B8** (Display string: 'Coord3D_B8'): 3D coordinate, second component 8 bit.
    - **Coord3D_C8** (Display string: 'Coord3D_C8'): 3D coordinate, third component 8 bit.
    - **Coord3D_ABC8** (Display string: 'Coord3D_ABC8'): 3D coordinates, 3 components 8 bit.
    - **Coord3D_ABC8_Planar** (Display string: 'Coord3D_ABC8_Planar'): 3D coordinates, 3 components 8 bit planar.
    - **Coord3D_A16** (Display string: 'Coord3D_A16'): 3D coordinate, first component 16 bit.
    - **Coord3D_B16** (Display string: 'Coord3D_B16'): 3D coordinate, second component 16 bit.
    - **Coord3D_C16** (Display string: 'Coord3D_C16'): 3D coordinate, third component 16 bit.
    - **Coord3D_ABC16** (Display string: 'Coord3D_ABC16'): 3D coordinates, 3 components 16 bit.
    - **Coord3D_ABC16_Planar** (Display string: 'Coord3D_ABC16_Planar'): 3D coordinates, 3 components 16 bit planar.
    - **Coord3D_A32f** (Display string: 'Coord3D_A32f'): 3D coordinate, first component 32 bit float.
    - **Coord3D_B32f** (Display string: 'Coord3D_B32f'): 3D coordinate, second component 32 bit float.
    - **Coord3D_C32f** (Display string: 'Coord3D_C32f'): 3D coordinate, third component 32 bit float.
    - **Coord3D_ABC32f** (Display string: 'Coord3D_ABC32f'): 3D coordinates, 3 components 32 bit float.
    - **Coord3D_ABC32f_Planar** (Display string: 'Coord3D_ABC32f_Planar'): 3D coordinates, 3 components 32 bit float planar.
    - **Confidence1** (Display string: 'Confidence1'): Confidence data 1 bit.
    - **Confidence1p** (Display string: 'Confidence1p'): Confidence data 1 bit packed.
    - **Confidence8** (Display string: 'Confidence8'): Confidence data 8 bit.
    - **Confidence16** (Display string: 'Confidence16'): Confidence data 16 bit.
    - **Confidence32f** (Display string: 'Confidence32f'): Confidence data 32 bit float.
    - **Data8** (Display string: 'Data8'): Generic non-pixel data 8 bit.
    - **Data8s** (Display string: 'Data8s'): Generic non-pixel data 8 bit signed.
    - **Data16** (Display string: 'Data16'): Generic non-pixel data 16 bit.
    - **Data16s** (Display string: 'Data16s'): Generic non-pixel data 16 bit signed.
    - **Data32** (Display string: 'Data32'): Generic non-pixel data 32 bit.
    - **Data32s** (Display string: 'Data32s'): Generic non-pixel data 32 bit signed.
    - **Data32f** (Display string: 'Data32f'): Generic non-pixel data 32 bit floating point.
    - **Data64** (Display string: 'Data64'): Generic non-pixel data 64 bit.
    - **Data64s** (Display string: 'Data64s'): Generic non-pixel data 64 bit signed.
    - **Data64f** (Display string: 'Data64f'): Generic non-pixel data 64 bit floating point.
    - **Raw8** (Display string: 'Raw8'): Raw 8 bit.
    - **Raw16** (Display string: 'Raw16'): Raw 16 bit.
    - **Mono12Packed** (Display string: 'Mono12Packed'): Mono 12 bit packed (GigE Vision Specific).
    - **BayerGR10Packed** (Display string: 'BayerGR10Packed'): Bayer GR 10 bit packed (GigE Vision Specific).
    - **BayerRG10Packed** (Display string: 'BayerRG10Packed'): Bayer RG 10 bit packed (GigE Vision Specific).
    - **BayerGB10Packed** (Display string: 'BayerGB10Packed'): Bayer GB 10 bit packed (GigE Vision Specific).
    - **BayerBG10Packed** (Display string: 'BayerBG10Packed'): Bayer BG 10 bit packed (GigE Vision Specific).
    - **BayerGR12Packed** (Display string: 'BayerGR12Packed'): Bayer GR 12 bit packed (GigE Vision Specific).
    - **BayerRG12Packed** (Display string: 'BayerRG12Packed'): Bayer RG 12 bit packed (GigE Vision Specific).
    - **BayerGB12Packed** (Display string: 'BayerGB12Packed'): Bayer GB 12 bit packed (GigE Vision Specific).
    - **BayerBG12Packed** (Display string: 'BayerBG12Packed'): Bayer BG 12 bit packed (GigE Vision Specific).
    - **RGB10V1Packed** (Display string: 'RGB10V1Packed'): RGB 10 bit packed (GigE Vision Specific).
    - **RGB12V1Packed** (Display string: 'RGB12V1Packed'): RGB 12 bit packed (GigE Vision Specific).
    - **Mono8Signed** (Display string: 'Mono 8 Signed')
    - **Mono10Packed** (Display string: 'Mono 10 Packed')
    - **RGB8Packed** (Display string: 'RGB 8 Packed')
    - **BGR8Packed** (Display string: 'BGR 8 Packed')
    - **RGBA8Packed** (Display string: 'RGBA 8 Packed')
    - **BGRA8Packed** (Display string: 'BGRA 8 Packed')
    - **RGB10Packed** (Display string: 'RGB 10 Packed')
    - **BGR10Packed** (Display string: 'BGR 10 Packed')
    - **RGB12Packed** (Display string: 'RGB 12 Packed')
    - **BGR12Packed** (Display string: 'BGR 12 Packed')
    - **RGB16Packed** (Display string: 'RGB 16 Packed')
    - **RGB10V2Packed** (Display string: 'RGB 10 V 2 Packed')
    - **RGB565Packed** (Display string: 'RGB 565 Packed')
    - **BGR565Packed** (Display string: 'BGR 565 Packed')
    - **YUV411Packed** (Display string: 'YUV 411 Packed')
    - **YUV422Packed** (Display string: 'YUV 422 Packed')
    - **YUV444Packed** (Display string: 'YUV 444 Packed')
    - **YUYVPacked** (Display string: 'YUYV Packed')
    - **RGB8Planar** (Display string: 'RGB 8 Planar')
    - **RGB10Planar** (Display string: 'RGB 10 Planar')
    - **RGB12Planar** (Display string: 'RGB 12 Planar')
    - **RGB16Planar** (Display string: 'RGB 16 Planar')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    chunkPixelDynamicRangeMin = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkPixelDynamicRangeMin_get, doc=r"""
    An integer property. Returns the minimum value of dynamic range of the image included in the payload.
    Returns the minimum value of dynamic range of the image included in the payload.
    """)
    chunkPixelDynamicRangeMax = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkPixelDynamicRangeMax_get, doc=r"""
    An integer property. Returns the maximum value of dynamic range of the image included in the payload.
    Returns the maximum value of dynamic range of the image included in the payload.
    """)
    chunkBinningHorizontal = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkBinningHorizontal_get, doc=r"""
    An integer property. Number of horizontal photo-sensitive cells combined together.
    Number of horizontal photo-sensitive cells combined together.
    """)
    chunkBinningVertical = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkBinningVertical_get, doc=r"""
    An integer property. Number of vertical photo-sensitive cells combined together.
    Number of vertical photo-sensitive cells combined together.
    """)
    chunkDecimationHorizontal = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkDecimationHorizontal_get, doc=r"""
    An integer property. Horizontal sub-sampling of the image.
    Horizontal sub-sampling of the image.
    """)
    chunkDecimationVertical = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkDecimationVertical_get, doc=r"""
    An integer property. Vertical sub-sampling of the image.
    Vertical sub-sampling of the image.
    """)
    chunkReverseX = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkReverseX_get, doc=r"""
    A boolean property. Flip horizontal of the image sent by the device.
    Flip horizontal of the image sent by the device.
    """)
    chunkReverseY = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkReverseY_get, doc=r"""
    A boolean property. Flip vertically of the image sent by the device.
    Flip vertically of the image sent by the device.
    """)
    chunkTimestamp = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkTimestamp_get, doc=r"""
    An integer property. Returns the Timestamp of the image included in the payload at the time of the FrameStart internal event.
    Returns the Timestamp of the image included in the payload at the time of the FrameStart internal event.
    """)
    chunkTimestampLatchValue = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkTimestampLatchValue_get, doc=r"""
    An integer property. Returns the last Timestamp latched with the TimestampLatch command.
    Returns the last Timestamp latched with the TimestampLatch command.
    """)
    chunkLineStatusAll = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkLineStatusAll_get, doc=r"""
    An integer property. Returns the status of all the I/O lines at the time of the FrameStart internal event.
    Returns the status of all the I/O lines at the time of the FrameStart internal event.
    """)
    chunkCounterSelector = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkCounterSelector_get, doc=r"""
    An enumerated integer property. Selects which counter to retrieve data from.
    Selects which counter to retrieve data from.

    The following string values might be valid for this feature:
    - **Counter0** (Display string: 'Counter 0'): Selects the counter 0.
    - **Counter1** (Display string: 'Counter 1'): Selects the counter 1.
    - **Counter2** (Display string: 'Counter 2'): Selects the counter 2.
    - **Counter**#3# (Display string: 'Counter #3#'): Selects the counter #3#.
    - **Counter3** (Display string: 'Counter 3'): Selects the counter 3.
    - **Counter4** (Display string: 'Counter 4'): Selects the counter 4.
    - **Counter5** (Display string: 'Counter 5'): Selects the counter 5.
    - **Counter6** (Display string: 'Counter 6'): Selects the counter 6.
    - **Counter7** (Display string: 'Counter 7'): Selects the counter 7.
    - **Counter8** (Display string: 'Counter 8'): Selects the counter 8.
    - **Counter9** (Display string: 'Counter 9'): Selects the counter 9.
    - **Counter10** (Display string: 'Counter 10'): Selects the counter 10.
    - **Counter11** (Display string: 'Counter 11'): Selects the counter 11.
    - **Counter12** (Display string: 'Counter 12'): Selects the counter 12.
    - **Counter13** (Display string: 'Counter 13'): Selects the counter 13.
    - **Counter14** (Display string: 'Counter 14'): Selects the counter 14.
    - **Counter15** (Display string: 'Counter 15'): Selects the counter 15.
    - **Counter16** (Display string: 'Counter 16')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    chunkCounterValue = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkCounterValue_get, doc=r"""
    An integer property. Returns the value of the selected Chunk counter at the time of the FrameStart event.
    Returns the value of the selected Chunk counter at the time of the FrameStart event.
    """)
    chunkTimerSelector = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkTimerSelector_get, doc=r"""
    An enumerated integer property. Selects which Timer to retrieve data from.
    Selects which Timer to retrieve data from.

    The following string values might be valid for this feature:
    - **Timer0** (Display string: 'Timer 0'): Selects the first Timer.
    - **Timer1** (Display string: 'Timer 1'): Selects the first Timer.
    - **Timer2** (Display string: 'Timer 2'): Selects the second Timer.
    - **Timer**#3# (Display string: 'Timer #3#'): Selects the second Timer.
    - **Timer3** (Display string: 'Timer 3'): Selects the second Timer.
    - **Timer4** (Display string: 'Timer 4'): Selects the second Timer.
    - **Timer5** (Display string: 'Timer 5'): Selects the second Timer.
    - **Timer6** (Display string: 'Timer 6'): Selects the second Timer.
    - **Timer7** (Display string: 'Timer 7'): Selects the second Timer.
    - **Timer8** (Display string: 'Timer 8'): Selects the second Timer.
    - **Timer9** (Display string: 'Timer 9'): Selects the second Timer.
    - **Timer10** (Display string: 'Timer 10'): Selects the second Timer.
    - **Timer11** (Display string: 'Timer 11'): Selects the second Timer.
    - **Timer12** (Display string: 'Timer 12'): Selects the second Timer.
    - **Timer13** (Display string: 'Timer 13'): Selects the second Timer.
    - **Timer14** (Display string: 'Timer 14'): Selects the second Timer.
    - **Timer15** (Display string: 'Timer 15'): Selects the second Timer.
    - **Timer16** (Display string: 'Timer 16')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    chunkTimerValue = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkTimerValue_get, doc=r"""
    A floating point property. Returns the value of the selected Timer at the time of the FrameStart internal event.
    Returns the value of the selected Timer at the time of the FrameStart internal event.
    """)
    chunkScanLineSelector = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkScanLineSelector_get, doc=r"""
    An integer property. Index for vector representation of one chunk value per line in an image.
    Index for vector representation of one chunk value per line in an image.
    """)
    chunkEncoderSelector = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkEncoderSelector_get, doc=r"""
    An enumerated integer property. Selects which Encoder to retrieve data from.
    Selects which Encoder to retrieve data from.

    The following string values might be valid for this feature:
    - **Encoder0** (Display string: 'Encoder 0'): Selects the first Encoder.
    - **Encoder1** (Display string: 'Encoder 1'): Selects the first Encoder.
    - **Encoder2** (Display string: 'Encoder 2'): Selects the second Encoder.
    - **Encoder**#3# (Display string: 'Encoder #3#'): Selects the second Encoder.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    chunkEncoderValue = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkEncoderValue_get, doc=r"""
    An integer property. Returns the counter's value of the selected Encoder at the time of the FrameStart in area scan mode or the counter's value at the time of the LineStart selected by ChunkScanLineSelector in Linescan mode.
    Returns the counter's value of the selected Encoder at the time of the FrameStart in area scan mode or the counter's value at the time of the LineStart selected by ChunkScanLineSelector in Linescan mode.
    """)
    chunkEncoderStatus = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkEncoderStatus_get, doc=r"""
    An enumerated integer property. Returns the motion status of the selected encoder.
    Returns the motion status of the selected encoder.

    The following string values might be valid for this feature:
    - **EncoderUp** (Display string: 'Encoder Up'): The encoder counter last incremented.
    - **EncoderDown** (Display string: 'Encoder Down'): The encoder counter last decremented.
    - **EncoderIdle** (Display string: 'Encoder Idle'): The encoder is not active.
    - **EncoderStatic** (Display string: 'Encoder Static'): No motion within the EncoderTimeout time.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    chunkExposureTimeSelector = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkExposureTimeSelector_get, doc=r"""
    An enumerated integer property. Selects which exposure time is read by the ChunkExposureTime feature.
    Selects which exposure time is read by the ChunkExposureTime feature.

    The following string values might be valid for this feature:
    - **Common** (Display string: 'Common'): Selects the common ExposureTime.
    - **Red** (Display string: 'Red'): Selects the red common ExposureTime.
    - **Green** (Display string: 'Green'): Selects the green ExposureTime.
    - **Blue** (Display string: 'Blue'): Selects the blue ExposureTime.
    - **Cyan** (Display string: 'Cyan'): Selects the cyan common ExposureTime..
    - **Magenta** (Display string: 'Magenta'): Selects the magenta ExposureTime..
    - **Yellow** (Display string: 'Yellow'): Selects the yellow ExposureTime..
    - **Infrared** (Display string: 'Infrared'): Selects the infrared ExposureTime.
    - **Ultraviolet** (Display string: 'Ultraviolet'): Selects the ultraviolet ExposureTime.
    - **Stage1** (Display string: 'Stage 1'): Selects the first stage ExposureTime.
    - **Stage2** (Display string: 'Stage 2'): Selects the second stage ExposureTime.
    - **Stage**#3# (Display string: 'Stage #3#'): Selects the second stage ExposureTime.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    chunkExposureTime = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkExposureTime_get, doc=r"""
    A floating point property. Returns the exposure time used to capture the image.
    Returns the exposure time used to capture the image.
    """)
    chunkGainSelector = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkGainSelector_get, doc=r"""
    An enumerated integer property. Selects which Gain to return.
    Selects which Gain to return.

    The following string values might be valid for this feature:
    - **All** (Display string: 'All'): Gain will be applied to all channels or taps.
    - **Red** (Display string: 'Red'): Gain will be applied to the red channel.
    - **Green** (Display string: 'Green'): Gain will be applied to the green channel.
    - **Blue** (Display string: 'Blue'): Gain will be applied to the blue channel.
    - **Y** (Display string: 'Y'): Gain will be applied to Y channel.
    - **U** (Display string: 'U'): Gain will be applied to U channel.
    - **V** (Display string: 'V'): Gain will be applied to V channel.
    - **Tap1** (Display string: 'Tap 1'): Gain will be applied to Tap 1.
    - **Tap2** (Display string: 'Tap 2'): Gain will be applied to Tap 2.
    - **Tap**#3# (Display string: 'Tap #3#'): Gain will be applied to Tap #3#.
    - **AnalogAll** (Display string: 'Analog All'): Gain will be applied to all analog channels or taps.
    - **AnalogRed** (Display string: 'Analog Red'): Gain will be applied to the red analog channel.
    - **AnalogGreen** (Display string: 'Analog Green'): Gain will be applied to the green analog channel.
    - **AnalogBlue** (Display string: 'Analog Blue'): Gain will be applied to the blue analog channel.
    - **AnalogY** (Display string: 'Analog Y'): Gain will be applied to Y analog channel.
    - **AnalogU** (Display string: 'Analog U'): Gain will be applied to U analog channel.
    - **AnalogV** (Display string: 'Analog V'): Gain will be applied to V analog channel.
    - **AnalogTap1** (Display string: 'Analog Tap 1'): Analog gain will be applied to Tap 1.
    - **AnalogTap2** (Display string: 'Analog Tap 2'): Analog gain will be applied to Tap 2.
    - **AnalogTap**#3# (Display string: 'Analog Tap #3#'): Analog gain will be applied to Tap #3#.
    - **DigitalAll** (Display string: 'Digital All'): Gain will be applied to all digital channels or taps.
    - **DigitalRed** (Display string: 'Digital Red'): Gain will be applied to the red digital channel.
    - **DigitalGreen** (Display string: 'Digital Green'): Gain will be applied to the green digital channel.
    - **DigitalBlue** (Display string: 'Digital Blue'): Gain will be applied to the blue digital channel.
    - **DigitalY** (Display string: 'Digital Y'): Gain will be applied to Y digital channel.
    - **DigitalU** (Display string: 'Digital U'): Gain will be applied to U digital channel.
    - **DigitalV** (Display string: 'Digital V'): Gain will be applied to V digital channel.
    - **DigitalTap1** (Display string: 'Digital Tap 1'): Digital gain will be applied to Tap 1.
    - **DigitalTap2** (Display string: 'Digital Tap 2'): Digital gain will be applied to Tap 2.
    - **DigitalTap**#3# (Display string: 'Digital Tap #3#'): Digital gain will be applied to Tap #3#.
    - **Tap3** (Display string: 'Tap 3'): Gain will be applied to Tap 3.
    - **Tap4** (Display string: 'Tap 4'): Gain will be applied to Tap 4.
    - **Tap5** (Display string: 'Tap 5'): Gain will be applied to Tap 5.
    - **Tap6** (Display string: 'Tap 6'): Gain will be applied to Tap 6.
    - **Tap7** (Display string: 'Tap 7'): Gain will be applied to Tap 7.
    - **Tap8** (Display string: 'Tap 8'): Gain will be applied to Tap 8.
    - **Tap9** (Display string: 'Tap 9'): Gain will be applied to Tap 9.
    - **Tap10** (Display string: 'Tap 10'): Gain will be applied to Tap 10.
    - **Tap11** (Display string: 'Tap 11'): Gain will be applied to Tap 11.
    - **Tap12** (Display string: 'Tap 12'): Gain will be applied to Tap 12.
    - **Tap13** (Display string: 'Tap 13'): Gain will be applied to Tap 13.
    - **Tap14** (Display string: 'Tap 14'): Gain will be applied to Tap 14.
    - **Tap15** (Display string: 'Tap 15'): Gain will be applied to Tap 15.
    - **Tap16** (Display string: 'Tap 16')
    - **AnalogTap3** (Display string: 'Analog Tap 3'): Analog gain will be applied to Tap 3.
    - **AnalogTap4** (Display string: 'Analog Tap 4'): Analog gain will be applied to Tap 4.
    - **AnalogTap5** (Display string: 'Analog Tap 5'): Analog gain will be applied to Tap 5.
    - **AnalogTap6** (Display string: 'Analog Tap 6'): Analog gain will be applied to Tap 6.
    - **AnalogTap7** (Display string: 'Analog Tap 7'): Analog gain will be applied to Tap 7.
    - **AnalogTap8** (Display string: 'Analog Tap 8'): Analog gain will be applied to Tap 8.
    - **AnalogTap9** (Display string: 'Analog Tap 9'): Analog gain will be applied to Tap 9.
    - **AnalogTap10** (Display string: 'Analog Tap 10'): Analog gain will be applied to Tap 10.
    - **AnalogTap11** (Display string: 'Analog Tap 11'): Analog gain will be applied to Tap 11.
    - **AnalogTap12** (Display string: 'Analog Tap 12'): Analog gain will be applied to Tap 12.
    - **AnalogTap13** (Display string: 'Analog Tap 13'): Analog gain will be applied to Tap 13.
    - **AnalogTap14** (Display string: 'Analog Tap 14'): Analog gain will be applied to Tap 14.
    - **AnalogTap15** (Display string: 'Analog Tap 15'): Analog gain will be applied to Tap 15.
    - **AnalogTap16** (Display string: 'Analog Tap 16')
    - **DigitalTap3** (Display string: 'Digital Tap 3'): Digital gain will be applied to Tap 3.
    - **DigitalTap4** (Display string: 'Digital Tap 4'): Digital gain will be applied to Tap 4.
    - **DigitalTap5** (Display string: 'Digital Tap 5'): Digital gain will be applied to Tap 5.
    - **DigitalTap6** (Display string: 'Digital Tap 6'): Digital gain will be applied to Tap 6.
    - **DigitalTap7** (Display string: 'Digital Tap 7'): Digital gain will be applied to Tap 7.
    - **DigitalTap8** (Display string: 'Digital Tap 8'): Digital gain will be applied to Tap 8.
    - **DigitalTap9** (Display string: 'Digital Tap 9'): Digital gain will be applied to Tap 9.
    - **DigitalTap10** (Display string: 'Digital Tap 10'): Digital gain will be applied to Tap 10.
    - **DigitalTap11** (Display string: 'Digital Tap 11'): Digital gain will be applied to Tap 11.
    - **DigitalTap12** (Display string: 'Digital Tap 12'): Digital gain will be applied to Tap 12.
    - **DigitalTap13** (Display string: 'Digital Tap 13'): Digital gain will be applied to Tap 13.
    - **DigitalTap14** (Display string: 'Digital Tap 14'): Digital gain will be applied to Tap 14.
    - **DigitalTap15** (Display string: 'Digital Tap 15'): Digital gain will be applied to Tap 15.
    - **DigitalTap16** (Display string: 'Digital Tap 16')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    chunkGain = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkGain_get, doc=r"""
    A floating point property. Returns the gain used to capture the image.
    Returns the gain used to capture the image.
    """)
    chunkBlackLevelSelector = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkBlackLevelSelector_get, doc=r"""
    An enumerated integer property. Selects which Black Level to return.
    Selects which Black Level to return. Possible values are:

    The following string values might be valid for this feature:
    - **All** (Display string: 'All'): Black Level will be applied to all channels or taps.
    - **Red** (Display string: 'Red'): Black Level will be applied to the red channel.
    - **Green** (Display string: 'Green'): Black Level will be applied to the green channel.
    - **Blue** (Display string: 'Blue'): Black Level will be applied to the blue channel.
    - **Y** (Display string: 'Y'): Black Level will be applied to Y channel.
    - **U** (Display string: 'U'): Black Level will be applied to U channel.
    - **V** (Display string: 'V'): Black Level will be applied to V channel.
    - **Tap1** (Display string: 'Tap 1'): Black Level will be applied to Tap 1.
    - **Tap2** (Display string: 'Tap 2'): Black Level will be applied to Tap 2.
    - **Tap**#3# (Display string: 'Tap #3#'): Black Level will be applied to Tap #3#.
    - **Tap3** (Display string: 'Tap 3'): Black Level will be applied to Tap 3.
    - **Tap4** (Display string: 'Tap 4'): Black Level will be applied to Tap 4.
    - **Tap5** (Display string: 'Tap 5'): Black Level will be applied to Tap 5.
    - **Tap6** (Display string: 'Tap 6'): Black Level will be applied to Tap 6.
    - **Tap7** (Display string: 'Tap 7'): Black Level will be applied to Tap 7.
    - **Tap8** (Display string: 'Tap 8'): Black Level will be applied to Tap 8.
    - **Tap9** (Display string: 'Tap 9'): Black Level will be applied to Tap 9.
    - **Tap10** (Display string: 'Tap 10'): Black Level will be applied to Tap 10.
    - **Tap11** (Display string: 'Tap 11'): Black Level will be applied to Tap 11.
    - **Tap12** (Display string: 'Tap 12'): Black Level will be applied to Tap 12.
    - **Tap13** (Display string: 'Tap 13'): Black Level will be applied to Tap 13.
    - **Tap14** (Display string: 'Tap 14'): Black Level will be applied to Tap 14.
    - **Tap15** (Display string: 'Tap 15'): Black Level will be applied to Tap 15.
    - **Tap16** (Display string: 'Tap 16')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    chunkBlackLevel = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkBlackLevel_get, doc=r"""
    A floating point property. Returns the black level used to capture the image included in the payload.
    Returns the black level used to capture the image included in the payload.
    """)
    chunkLinePitch = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkLinePitch_get, doc=r"""
    An integer property. Returns the LinePitch of the image included in the payload.
    Returns the LinePitch of the image included in the payload.
    """)
    chunkFrameID = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkFrameID_get, doc=r"""
    An integer property. Returns the unique Identifier of the frame (or image) included in the payload.
    Returns the unique Identifier of the frame (or image) included in the payload.
    """)
    chunkSourceSelector = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkSourceSelector_get, doc=r"""
    An enumerated integer property. Selects which Source to retrieve data from.
    Selects which Source to retrieve data from.

    The following string values might be valid for this feature:
    - **Source0** (Display string: 'Source 0'): Image comes from the Source 0.
    - **Source1** (Display string: 'Source 1'): Image comes from the Source 1.
    - **Source2** (Display string: 'Source 2'): Image comes from the Source 2.
    - **Source**#3# (Display string: 'Source #3#'): Image comes from the Source #3#.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    chunkSourceID = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkSourceID_get, doc=r"""
    An enumerated integer property. Returns the Identifier of Source that the image comes from.
    Returns the Identifier of Source that the image comes from.

    The following string values might be valid for this feature:
    - **Source0** (Display string: 'Source 0'): Image comes from the Source 0.
    - **Source1** (Display string: 'Source 1'): Image comes from the Source 1.
    - **Source2** (Display string: 'Source 2'): Image comes from the Source 2.
    - **Source**#3# (Display string: 'Source #3#'): Image comes from the Source #3#.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    chunkSourceIDValue = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkSourceIDValue_get, doc=r"""
    An integer property. Returns the unique integer Identifier value of the Source that the image comes from.
    Returns the unique integer Identifier value of the Source that the image comes from.
    """)
    chunkTransferBlockID = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkTransferBlockID_get, doc=r"""
    An integer property. Returns the unique identifier of the transfer block used to transport the payload.
    Returns the unique identifier of the transfer block used to transport the payload.
    """)
    chunkTransferStreamID = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkTransferStreamID_get, doc=r"""
    An enumerated integer property. Returns identifier of the stream that generated this block.
    Returns identifier of the stream that generated this block.

    The following string values might be valid for this feature:
    - **Stream0** (Display string: 'Stream 0'): Data comes from Stream0.
    - **Stream1** (Display string: 'Stream 1'): Data comes from Stream1.
    - **Stream2** (Display string: 'Stream 2'): Data comes from Stream2.
    - **Stream3** (Display string: 'Stream 3'): Data comes from Stream3.
    - **Stream**#4# (Display string: 'Stream #4#'): Data comes from Stream#4#.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    chunkTransferQueueCurrentBlockCount = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkTransferQueueCurrentBlockCount_get, doc=r"""
    An integer property. Returns the current number of blocks in the transfer queue.
    Returns the current number of blocks in the transfer queue.
    """)
    chunkStreamChannelID = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkStreamChannelID_get, doc=r"""
    An integer property. Returns identifier of the stream channel used to carry the block.
    Returns identifier of the stream channel used to carry the block.
    """)
    chunkSequencerSetActive = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkSequencerSetActive_get, doc=r"""
    An integer property. Return the index of the active set of the running sequencer included in the payload.
    Return the index of the active set of the running sequencer included in the payload.
    """)
    chunkScan3dDistanceUnit = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkScan3dDistanceUnit_get, doc=r"""
    An enumerated integer property. Returns the Distance Unit of the payload image.
    Returns the Distance Unit of the payload image.

    The following string values might be valid for this feature:
    - **Millimeter** (Display string: 'Millimeter'): Default value. Distance values are in millimeter units.
    - **Inch** (Display string: 'Inch'): Distance values are in inch units.
    - **Pixel** (Display string: 'Pixel'): Distance values are given as a multiple of the size of a pixel.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    chunkScan3dOutputMode = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkScan3dOutputMode_get, doc=r"""
    An enumerated integer property. Returns the Calibrated Mode of the payload image.
    Returns the Calibrated Mode of the payload image.

    The following string values might be valid for this feature:
    - **UncalibratedC** (Display string: 'Uncalibrated C'): Uncalibrated 2.5D Depth map. The distance data does not represent a physical unit and may be non-linear. The data is a 2.5D range map only.
    - **CalibratedABC_Grid** (Display string: 'Calibrated ABC Grid'): 3 Coordinates in grid organization. The full 3 coordinate data with the grid array organization from the sensor kept.
    - **CalibratedABC_PointCloud** (Display string: 'Calibrated ABC Point Cloud'): 3 Coordinates without organization. The full 3 coordinate data without any organization of data points. Typically only valid points transmitted giving varying image size.
    - **CalibratedAC** (Display string: 'Calibrated AC'): 2 Coordinates with fixed B sampling. The data is sent as a A and C coordinates (X,Z or Theta,Rho). The B (Y) axis uses the scale and offset parameters for the B axis.
    - **CalibratedAC_Linescan** (Display string: 'Calibrated AC Linescan'): 2 Coordinates with varying sampling. The data is sent as a A and C coordinates (X,Z or Theta,Rho). The B (Y) axis comes from the encoder chunk value.
    - **CalibratedC** (Display string: 'Calibrated C'): Calibrated 2.5D Depth map. The distance data is expressed in the chosen distance unit. The data is a 2.5D range map. No information on X-Y axes available.
    - **CalibratedC_Linescan** (Display string: 'Calibrated C Linescan'): Depth Map with varying B sampling. The distance data is expressed in the chosen distance unit. The data is a 2.5D range map. The B (Y) axis comes from the encoder chunk value.
    - **RectifiedC** (Display string: 'Rectified C'): Rectified 2.5D Depth map. The distance data has been rectified to a uniform sampling pattern in the X and Y direction. The data is a 2.5D range map only. If a complete 3D point cloud is rectified but transmitted as explicit coordinates it should be transmitted as one of the 'CalibratedABC' formats.
    - **RectifiedC_Linescan** (Display string: 'Rectified C Linescan'): Rectified 2.5D Depth map with varying B sampling. The data is sent as rectified 1D profiles using Coord3D_C pixels. The B (Y) axis comes from the encoder chunk value.
    - **DisparityC** (Display string: 'Disparity C'): Disparity 2.5D Depth map. The distance is inversely proportional to the pixel (disparity) value.
    - **DisparityC_Linescan** (Display string: 'Disparity C Linescan'): Disparity 2.5D Depth map with varying B sampling. The distance is inversely proportional to the pixel (disparity) value. The B (Y) axis comes from the encoder chunk value.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    chunkScan3dCoordinateSystem = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkScan3dCoordinateSystem_get, doc=r"""
    An enumerated integer property. Returns the Coordinate System of the image included in the payload.
    Returns the Coordinate System of the image included in the payload.

    The following string values might be valid for this feature:
    - **Cartesian** (Display string: 'Cartesian'): Default value. 3-axis orthogonal, right-hand X-Y-Z.
    - **Spherical** (Display string: 'Spherical'): A Theta-Phi-Rho coordinate system.
    - **Cylindrical** (Display string: 'Cylindrical'): A Theta-Y-Rho coordinate system.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    chunkScan3dCoordinateSystemReference = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkScan3dCoordinateSystemReference_get, doc=r"""
    An enumerated integer property. Returns the Coordinate System Position of the image included in the payload.
    Returns the Coordinate System Position of the image included in the payload.

    The following string values might be valid for this feature:
    - **Anchor** (Display string: 'Anchor'): Default value. Original fixed reference. The coordinate system fixed relative the camera reference point marker is used.
    - **Transformed** (Display string: 'Transformed'): Transformed reference system. The transformed coordinate system is used according to the definition in the rotation and translation matrices.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    chunkScan3dCoordinateSelector = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkScan3dCoordinateSelector_get, doc=r"""
    An enumerated integer property. Selects which Coordinate to retrieve data from.
    Selects which Coordinate to retrieve data from.

    The following string values might be valid for this feature:
    - **CoordinateA** (Display string: 'Coordinate A'): The first (X or Theta) coordinate
    - **CoordinateB** (Display string: 'Coordinate B'): The second (Y or Phi) coordinate
    - **CoordinateC** (Display string: 'Coordinate C'): The third (Z or Rho) coordinate.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    chunkScan3dCoordinateScale = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkScan3dCoordinateScale_get, doc=r"""
    A floating point property. Returns the Scale for the selected coordinate axis of the image included in the payload.
    Returns the Scale for the selected coordinate axis of the image included in the payload.
    """)
    chunkScan3dCoordinateOffset = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkScan3dCoordinateOffset_get, doc=r"""
    A floating point property. Returns the Offset for the selected coordinate axis of the image included in the payload.
    Returns the Offset for the selected coordinate axis of the image included in the payload.
    """)
    chunkScan3dInvalidDataFlag = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkScan3dInvalidDataFlag_get, doc=r"""
    A boolean property. Returns if a specific non-valid data flag is used in the data stream.
    Returns if a specific non-valid data flag is used in the data stream.
    """)
    chunkScan3dInvalidDataValue = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkScan3dInvalidDataValue_get, doc=r"""
    A floating point property. Returns the Invalid Data Value used for the image included in the payload.
    Returns the Invalid Data Value used for the image included in the payload.
    """)
    chunkScan3dAxisMin = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkScan3dAxisMin_get, doc=r"""
    A floating point property. Returns the Minimum Axis value for the selected coordinate axis of the image included in the payload.
    Returns the Minimum Axis value for the selected coordinate axis of the image included in the payload.
    """)
    chunkScan3dAxisMax = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkScan3dAxisMax_get, doc=r"""
    A floating point property. Returns the Maximum Axis value for the selected coordinate axis of the image included in the payload.
    Returns the Maximum Axis value for the selected coordinate axis of the image included in the payload.
    """)
    chunkScan3dCoordinateTransformSelector = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkScan3dCoordinateTransformSelector_get, doc=r"""
    An enumerated integer property. Selector for transform values.
    Selector for transform values.

    The following string values might be valid for this feature:
    - **RotationX** (Display string: 'Rotation X'): Rotation around X axis.
    - **RotationY** (Display string: 'Rotation Y'): Rotation around Y axis.
    - **RotationZ** (Display string: 'Rotation Z'): Rotation around Z axis.
    - **TranslationX** (Display string: 'Translation X'): Translation along X axis.
    - **TranslationY** (Display string: 'Translation Y'): Translation along Y axis.
    - **TranslationZ** (Display string: 'Translation Z'): Translation along Z axis.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    chunkScan3dTransformValue = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkScan3dTransformValue_get, doc=r"""
    A floating point property. Returns the transform value.
    Returns the transform value.
    """)
    chunkScan3dCoordinateReferenceSelector = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkScan3dCoordinateReferenceSelector_get, doc=r"""
    An enumerated integer property. Selector to read a coordinate system reference value defining the transform of a point from one system to the other.
    Selector to read a coordinate system reference value defining the transform of a point from one system to the other.

    The following string values might be valid for this feature:
    - **RotationX** (Display string: 'Rotation X'): Rotation around X axis.
    - **RotationY** (Display string: 'Rotation Y'): Rotation around Y axis.
    - **RotationZ** (Display string: 'Rotation Z'): Rotation around Z axis.
    - **TranslationX** (Display string: 'Translation X'): X axis translation.
    - **TranslationY** (Display string: 'Translation Y'): Y axis translation.
    - **TranslationZ** (Display string: 'Translation Z'): Z axis translation.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    chunkScan3dCoordinateReferenceValue = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkScan3dCoordinateReferenceValue_get, doc=r"""
    A floating point property. Returns the value of a position or pose coordinate for the anchor or transformed coordinate systems relative to the reference point.
    Returns the value of a position or pose coordinate for the anchor or transformed coordinate systems relative to the reference point.
    """)
    chunkScan3dFocalLength = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkScan3dFocalLength_get, doc=r"""
    A floating point property. Returns the focal length of the camera in pixel.
    Returns the focal length of the camera in pixel. The focal length depends on the selected region. The value of this feature takes into account horizontal binning, decimation, or any other function changing the image resolution.
    """)
    chunkScan3dBaseline = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkScan3dBaseline_get, doc=r"""
    A floating point property. Returns the baseline as the physical distance of two cameras in a stereo camera setup.
    Returns the baseline as the physical distance of two cameras in a stereo camera setup. The value of this feature can be used for 3D reconstruction from disparity images. In this case, the unit of the 3D coordinates corresponds to the unit of the baseline.
    """)
    chunkScan3dPrincipalPointU = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkScan3dPrincipalPointU_get, doc=r"""
    A floating point property. Returns the value of this feature gives the horizontal position of the principal point, relative to the region origin, i.e.
    Returns the value of this feature gives the horizontal position of the principal point, relative to the region origin, i.e. OffsetX. The value of this feature takes into account horizontal binning, decimation, or any other function changing the image resolution.
    """)
    chunkScan3dPrincipalPointV = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkScan3dPrincipalPointV_get, doc=r"""
    A floating point property. Returns the value of this feature gives the vertical position of the principal point, relative to the region origin, i.e.
    Returns the value of this feature gives the vertical position of the principal point, relative to the region origin, i.e. OffsetY. The value of this feature takes into account vertical binning, decimation, or any other function changing the image resolution.
    """)
    mvChunkJPEG = property(lib_mvIMPACT_acquire.ChunkDataControl_mvChunkJPEG_get, doc=r"""
    A string property. Provides access to a JPEG image transmitted as part of the chunk data.
    Provides access to a JPEG image transmitted as part of the chunk data.
    """)
    chunkmvCustomIdentifier = property(lib_mvIMPACT_acquire.ChunkDataControl_chunkmvCustomIdentifier_get, doc=r"""
    An integer property. Contains a custom identifier previously specified by the user.
    Contains a custom identifier previously specified by the user.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_ChunkDataControl

# Register ChunkDataControl in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.ChunkDataControl_swigregister(ChunkDataControl)

class TestControl(object):
    r"""
    Category for Test Control features.
    A category for Test Control features.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::GenICam::TestControl** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.TestControl_swiginit(self, lib_mvIMPACT_acquire.new_TestControl(*args))
    testPendingAck = property(lib_mvIMPACT_acquire.TestControl_testPendingAck_get, doc=r"""
    An integer property. Tests the device's pending acknowledge feature.
    Tests the device's pending acknowledge feature. When this feature is written, the device waits a time period corresponding to the value of TestPendingAck before acknowledging the write.
    """)
    testEventGenerate = property(lib_mvIMPACT_acquire.TestControl_testEventGenerate_get, doc=r"""
    A method object. Generates a Test Event.
    Generates a Test Event.
    """)
    testPayloadFormatMode = property(lib_mvIMPACT_acquire.TestControl_testPayloadFormatMode_get, doc=r"""
    An enumerated integer property. This feature allows setting a device in test mode and to output a specific payload format for validation of data streaming.
    This feature allows setting a device in test mode and to output a specific payload format for validation of data streaming. This feature is intended solely for test purposes. The data can be real acquired data or any test pattern.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off'): The test mode is disabled. This feature has no effect and the device is streaming data normally according to its configuration. This option has to be the default after each boot of the device.
    - **MultiPart** (Display string: 'Multi Part'): The device streams data using multi-part payload format with at least one part in each payload. This option must be present if and only if the device supports the multi-part payload format. If the underlying transport layer negotiation has failed to allow the device to enter multi-part mode, it must not be possible to enable this test mode.
    - **GenDC** (Display string: 'Gen DC'): The device streams data using GenDC payload format with at least one component in each payload. This option must be present if the device supports the GenDC payload format. If the underlying transport layer negotiation has failed to allow the device to enter GenDC mode, it must not be possible to enable this test mode.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_TestControl

# Register TestControl in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.TestControl_swigregister(TestControl)

class TransportLayerControl(object):
    r"""
    Category that contains the transport Layer control features.
    A category that contains the transport Layer control features.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::GenICam::TransportLayerControl** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.TransportLayerControl_swiginit(self, lib_mvIMPACT_acquire.new_TransportLayerControl(*args))
    payloadSize = property(lib_mvIMPACT_acquire.TransportLayerControl_payloadSize_get, doc=r"""
    An integer property. Provides the number of bytes transferred for each data buffer or chunk on the stream channel.
    Provides the number of bytes transferred for each data buffer or chunk on the stream channel. This includes any end-of-line, end-of-frame statistics or other stamp data. This is the total size of data payload for a data block.
    """)
    genDCStreamingMode = property(lib_mvIMPACT_acquire.TransportLayerControl_genDCStreamingMode_get, doc=r"""
    An enumerated integer property. Controls the device's streaming format.
    Controls the device's streaming format.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off'): The device will only stream data in its native format.
    - **On** (Display string: 'On'): The device will stream all its data in the generic GenDC format.
    - **Automatic** (Display string: 'Automatic'): The device will automatically choose in which format it streams its data.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    genDCStreamingStatus = property(lib_mvIMPACT_acquire.TransportLayerControl_genDCStreamingStatus_get, doc=r"""
    An enumerated integer property. Returns whether the current device data streaming format is GenDC.
    Returns whether the current device data streaming format is GenDC. This value is conditioned by the GenDCStreamingMode.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off'): The device will only stream data in its native format.
    - **On** (Display string: 'On'): The device will stream all its data in the generic GenDC format.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    genDCDescriptor = property(lib_mvIMPACT_acquire.TransportLayerControl_genDCDescriptor_get, doc=r"""
    A string property. Returns a preliminary GenDC Descriptor that can be used as reference for the data to be streamed out by the device in its current configuration.
    Returns a preliminary GenDC Descriptor that can be used as reference for the data to be streamed out by the device in its current configuration. This information can be used to set up the receiver in advance to be ready for the data Containers to come.
    """)
    genDCFlowMappingTable = property(lib_mvIMPACT_acquire.TransportLayerControl_genDCFlowMappingTable_get, doc=r"""
    A string property. Returns the GenDC Container data Flow mapping table that will be used to transport the GenDC Container.
    Returns the GenDC Container data Flow mapping table that will be used to transport the GenDC Container.
    """)
    mvU3VPHYErrorCount = property(lib_mvIMPACT_acquire.TransportLayerControl_mvU3VPHYErrorCount_get, doc=r"""
    An integer property. Counts the number of errors on the PHY interface.
    Counts the number of errors on the PHY interface.
    """)
    mvU3VLNKErrorCount = property(lib_mvIMPACT_acquire.TransportLayerControl_mvU3VLNKErrorCount_get, doc=r"""
    An integer property. Counts the number of errors on the USB3 link.
    Counts the number of errors on the USB3 link.
    """)
    mvU3VEndpointSelector = property(lib_mvIMPACT_acquire.TransportLayerControl_mvU3VEndpointSelector_get, doc=r"""
    An enumerated integer property. Selects the endpoint for the event counters.
    Selects the endpoint for the event counters.

    The following string values might be valid for this feature:
    - **mvControl** (Display string: 'mv Control'): The control endpoint of the camera.
    - **mvEvent** (Display string: 'mv Event'): The event endpoint of the camera.
    - **mvStreaming** (Display string: 'mv Streaming'): The streaming endpoint of the camera.
    - **mvDebug** (Display string: 'mv Debug'): The debug endpoint of the camera.
    - **mvAll** (Display string: 'mv All'): Sums up data from all endpoints.
    - **mvReserved** (Display string: 'mv Reserved'): Reserved.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvU3VEndpointResetEventCount = property(lib_mvIMPACT_acquire.TransportLayerControl_mvU3VEndpointResetEventCount_get, doc=r"""
    An integer property. Counts the number of reset events received on all endpoints.
    Counts the number of reset events received on all endpoints.
    """)
    mvU3VEndpointRetryEventCount = property(lib_mvIMPACT_acquire.TransportLayerControl_mvU3VEndpointRetryEventCount_get, doc=r"""
    An integer property. Counts the number of retry events received on all endpoints.
    Counts the number of retry events received on all endpoints.
    """)
    mvU3VErrorCounterReset = property(lib_mvIMPACT_acquire.TransportLayerControl_mvU3VErrorCounterReset_get, doc=r"""
    A method object. Resets the 'mvU3VPHYErrorCount' and 'mvU3VLNKErrorCount' registers.
    Resets the 'mvU3VPHYErrorCount' and 'mvU3VLNKErrorCount' registers.
    """)
    mvU3VSpreadSpectrumClockingSupportDisable = property(lib_mvIMPACT_acquire.TransportLayerControl_mvU3VSpreadSpectrumClockingSupportDisable_get, doc=r"""
    A method object. Disable the spread spectrum clocking support.
    Disable the spread spectrum clocking support.
    """)
    deviceTapGeometry = property(lib_mvIMPACT_acquire.TransportLayerControl_deviceTapGeometry_get, doc=r"""
    An enumerated integer property. This device tap geometry feature describes the geometrical properties characterizing the taps of a camera as presented at the output of the device.
    This device tap geometry feature describes the geometrical properties characterizing the taps of a camera as presented at the output of the device.

    The following string values might be valid for this feature:
    - **Geometry_1X_1Y** (Display string: 'Geometry_1X_1Y'): Geometry_1X_1Y
    - **Geometry_1X2_1Y** (Display string: 'Geometry_1X2_1Y'): Geometry_1X2_1Y
    - **Geometry_1X2_1Y2** (Display string: 'Geometry_1X2_1Y2'): Geometry_1X2_1Y2
    - **Geometry_2X_1Y** (Display string: 'Geometry_2X_1Y'): Geometry_2X_1Y
    - **Geometry_2X_1Y2** (Display string: 'Geometry_2X_1Y2'): Geometry_2X_1Y2
    - **Geometry_2XE_1Y** (Display string: 'Geometry_2XE_1Y'): Geometry_2XE_1Y
    - **Geometry_2XE_1Y2** (Display string: 'Geometry_2XE_1Y2'): Geometry_2XE_1Y2
    - **Geometry_2XM_1Y** (Display string: 'Geometry_2XM_1Y'): Geometry_2XM_1Y
    - **Geometry_2XM_1Y2** (Display string: 'Geometry_2XM_1Y2'): Geometry_2XM_1Y2
    - **Geometry_1X_1Y2** (Display string: 'Geometry_1X_1Y2'): Geometry_1X_1Y2
    - **Geometry_1X_2YE** (Display string: 'Geometry_1X_2YE'): Geometry_1X_2YE
    - **Geometry_1X3_1Y** (Display string: 'Geometry_1X3_1Y'): Geometry_1X3_1Y
    - **Geometry_3X_1Y** (Display string: 'Geometry_3X_1Y'): Geometry_3X_1Y
    - **Geometry_1X** (Display string: 'Geometry_1X'): Geometry_1X
    - **Geometry_1X2** (Display string: 'Geometry_1X2'): Geometry_1X2
    - **Geometry_2X** (Display string: 'Geometry_2X'): Geometry_2X
    - **Geometry_2XE** (Display string: 'Geometry_2XE'): Geometry_2XE
    - **Geometry_2XM** (Display string: 'Geometry_2XM'): Geometry_2XM
    - **Geometry_1X3** (Display string: 'Geometry_1X3'): Geometry_1X3
    - **Geometry_3X** (Display string: 'Geometry_3X'): Geometry_3X
    - **Geometry_1X4_1Y** (Display string: 'Geometry_1X4_1Y'): Geometry_1X4_1Y
    - **Geometry_4X_1Y** (Display string: 'Geometry_4X_1Y'): Geometry_4X_1Y
    - **Geometry_2X2_1Y** (Display string: 'Geometry_2X2_1Y'): Geometry_2X2_1Y
    - **Geometry_2X2E_1Y** (Display string: 'Geometry_2X2E_1Y'): Geometry_2X2E_1Y
    - **Geometry_2X2M_1Y** (Display string: 'Geometry_2X2M_1Y'): Geometry_2X2M_1Y
    - **Geometry_1X2_2YE** (Display string: 'Geometry_1X2_2YE'): Geometry_1X2_2YE
    - **Geometry_2X_2YE** (Display string: 'Geometry_2X_2YE'): Geometry_2X_2YE
    - **Geometry_2XE_2YE** (Display string: 'Geometry_2XE_2YE'): Geometry_2XE_2YE
    - **Geometry_2XM_2YE** (Display string: 'Geometry_2XM_2YE'): Geometry_2XM_2YE
    - **Geometry_1X4** (Display string: 'Geometry_1X4'): Geometry_1X4
    - **Geometry_4X** (Display string: 'Geometry_4X'): Geometry_4X
    - **Geometry_2X2** (Display string: 'Geometry_2X2'): Geometry_2X2
    - **Geometry_2X2E** (Display string: 'Geometry_2X2E'): Geometry_2X2E
    - **Geometry_2X2M** (Display string: 'Geometry_2X2M'): Geometry_2X2M
    - **Geometry_1X8_1Y** (Display string: 'Geometry_1X8_1Y'): Geometry_1X8_1Y
    - **Geometry_8X_1Y** (Display string: 'Geometry_8X_1Y'): Geometry_8X_1Y
    - **Geometry_4X2_1Y** (Display string: 'Geometry_4X2_1Y'): Geometry_4X2_1Y
    - **Geometry_2X2E_2YE** (Display string: 'Geometry_2X2E_2YE'): Geometry_2X2E_2YE
    - **Geometry_1X8** (Display string: 'Geometry_1X8'): Geometry_1X8
    - **Geometry_8X** (Display string: 'Geometry_8X'): Geometry_8X
    - **Geometry_4X2** (Display string: 'Geometry_4X2'): Geometry_4X2
    - **Geometry_4X2E** (Display string: 'Geometry_4X2E'): Geometry_4X2E
    - **Geometry_4X2E_1Y** (Display string: 'Geometry_4X2E_1Y'): Geometry_4X2E_1Y
    - **Geometry_1X10_1Y** (Display string: 'Geometry_1X10_1Y'): Geometry_1X10_1Y
    - **Geometry_10X_1Y** (Display string: 'Geometry_10X_1Y'): Geometry_10X_1Y
    - **Geometry_1X10** (Display string: 'Geometry_1X10'): Geometry_1X10
    - **Geometry_10X** (Display string: 'Geometry_10X'): Geometry_10X

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    ptpEnable = property(lib_mvIMPACT_acquire.TransportLayerControl_ptpEnable_get, doc=r"""
    A boolean property. Enables the Precision Time Protocol (PTP).
    Enables the Precision Time Protocol (PTP).
    """)
    ptpClockAccuracy = property(lib_mvIMPACT_acquire.TransportLayerControl_ptpClockAccuracy_get, doc=r"""
    An enumerated integer property. Indicates the expected accuracy of the device PTP clock when it is the grandmaster, or in the event it becomes the grandmaster.
    Indicates the expected accuracy of the device PTP clock when it is the grandmaster, or in the event it becomes the grandmaster.

    The following string values might be valid for this feature:
    - **Within25ns** (Display string: 'Within 25ns'): Within 25ns
    - **Within100ns** (Display string: 'Within 100ns'): Within 100ns
    - **Within250ns** (Display string: 'Within 250ns'): Within 250ns
    - **Within1us** (Display string: 'Within 1us'): Within 1us
    - **Within2p5us** (Display string: 'Within 2p 5us'): Within 2p 5us
    - **Within10us** (Display string: 'Within 10us'): Within 10us
    - **Within25us** (Display string: 'Within 25us'): Within 25us
    - **Within100us** (Display string: 'Within 100us'): Within 100us
    - **Within250us** (Display string: 'Within 250us'): Within 250us
    - **Within1ms** (Display string: 'Within 1ms'): Within 1ms
    - **Within2p5ms** (Display string: 'Within 2p 5ms'): Within 2p 5ms
    - **Within10ms** (Display string: 'Within 10ms'): Within 10ms
    - **Within25ms** (Display string: 'Within 25ms'): Within 25ms
    - **Within100ms** (Display string: 'Within 100ms'): Within 100ms
    - **Within250ms** (Display string: 'Within 250ms'): Within 250ms
    - **Within1s** (Display string: 'Within 1s'): Within 1s
    - **Within10s** (Display string: 'Within 10s'): Within 10s
    - **GreaterThan10s** (Display string: 'Greater Than 10s'): Greater Than 10s
    - **AlternatePTPProfile** (Display string: 'Alternate PTP Profile'): Alternate PTP Profile
    - **Unknown** (Display string: 'Unknown'): Unknown
    - **Reserved** (Display string: 'Reserved'): Reserved

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    ptpDataSetLatch = property(lib_mvIMPACT_acquire.TransportLayerControl_ptpDataSetLatch_get, doc=r"""
    A method object. Latches the current values from the device's PTP clock data set.
    Latches the current values from the device's PTP clock data set.
    """)
    ptpStatus = property(lib_mvIMPACT_acquire.TransportLayerControl_ptpStatus_get, doc=r"""
    An enumerated integer property. Returns the latched state of the PTP clock.
    Returns the latched state of the PTP clock.

    The following string values might be valid for this feature:
    - **Initializing** (Display string: 'Initializing'): Initializing
    - **Faulty** (Display string: 'Faulty'): Faulty
    - **Disabled** (Display string: 'Disabled'): Disabled
    - **Listening** (Display string: 'Listening'): Listening
    - **PreMaster** (Display string: 'Pre Master'): Pre Master
    - **Master** (Display string: 'Master'): Master
    - **Passive** (Display string: 'Passive'): Passive
    - **Uncalibrated** (Display string: 'Uncalibrated'): Uncalibrated
    - **Slave** (Display string: 'Slave'): Slave

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    ptpServoStatus = property(lib_mvIMPACT_acquire.TransportLayerControl_ptpServoStatus_get, doc=r"""
    An enumerated integer property. Returns the latched state of the clock servo.
    Returns the latched state of the clock servo. When the servo is in a locked state, the value returned is 'Locked'. When the servo is in a non-locked state, a device-specific value can be returned to give specific information. If no device-specific value is available to describe the current state of the clock servo, the value should be 'Unknown'.

    The following string values might be valid for this feature:
    - **Unknown** (Display string: 'Unknown'): Unknown
    - **Locked** (Display string: 'Locked'): Locked
    - **Device-Specific** (Display string: 'Device - Specific'): Device - Specific

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    ptpOffsetFromMaster = property(lib_mvIMPACT_acquire.TransportLayerControl_ptpOffsetFromMaster_get, doc=r"""
    An integer property. Returns the latched offset from the PTP master clock in nanoseconds.
    Returns the latched offset from the PTP master clock in nanoseconds.
    """)
    ptpClockID = property(lib_mvIMPACT_acquire.TransportLayerControl_ptpClockID_get, doc=r"""
    An integer property. Returns the latched clock ID of the PTP device.
    Returns the latched clock ID of the PTP device.
    """)
    ptpParentClockID = property(lib_mvIMPACT_acquire.TransportLayerControl_ptpParentClockID_get, doc=r"""
    An integer property. Returns the latched parent clock ID of the PTP device.
    Returns the latched parent clock ID of the PTP device. The parent clock ID is the clock ID of the current master clock.
    """)
    ptpGrandmasterClockID = property(lib_mvIMPACT_acquire.TransportLayerControl_ptpGrandmasterClockID_get, doc=r"""
    An integer property. Returns the latched grandmaster clock ID of the PTP device.
    Returns the latched grandmaster clock ID of the PTP device. The grandmaster clock ID is the clock ID of the current grandmaster clock.
    """)
    gevVersionMajor = property(lib_mvIMPACT_acquire.TransportLayerControl_gevVersionMajor_get, doc=r"""
    An integer property. This feature is deprecated (See DeviceTLVersionMajor).
    Deprecated: 
    This feature is deprecated (See DeviceTLVersionMajor). It was representing the major version of the specification.
    """)
    gevVersionMinor = property(lib_mvIMPACT_acquire.TransportLayerControl_gevVersionMinor_get, doc=r"""
    An integer property. This feature is deprecated (See DeviceTLVersionMinor).
    Deprecated: 
    This feature is deprecated (See DeviceTLVersionMinor). It was representing the minor version of the specification.
    """)
    gevDeviceModeIsBigEndian = property(lib_mvIMPACT_acquire.TransportLayerControl_gevDeviceModeIsBigEndian_get, doc=r"""
    A boolean property. This feature is deprecated (See DeviceRegistersEndianness).
    Deprecated: 
    This feature is deprecated (See DeviceRegistersEndianness). It was representing the Endianness of the device registers.
    """)
    gevDeviceClass = property(lib_mvIMPACT_acquire.TransportLayerControl_gevDeviceClass_get, doc=r"""
    An enumerated integer property. This feature is deprecated (See DeviceType).
    Deprecated: 
    This feature is deprecated (See DeviceType). It was representing the class of the device.

    The following string values might be valid for this feature:
    - **Transmitter** (Display string: 'Transmitter'): Transmitter
    - **Receiver** (Display string: 'Receiver'): Receiver
    - **Transceiver** (Display string: 'Transceiver'): Transceiver
    - **Peripheral** (Display string: 'Peripheral'): Peripheral

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    gevDeviceModeCharacterSet = property(lib_mvIMPACT_acquire.TransportLayerControl_gevDeviceModeCharacterSet_get, doc=r"""
    An enumerated integer property. This feature is deprecated (See DeviceCharacterSet).
    Deprecated: 
    This feature is deprecated (See DeviceCharacterSet). It was representing the character set used by all the strings of the device.

    The following string values might be valid for this feature:
    - **UTF8** (Display string: 'UTF 8'): UTF 8

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    gevPhysicalLinkConfiguration = property(lib_mvIMPACT_acquire.TransportLayerControl_gevPhysicalLinkConfiguration_get, doc=r"""
    An enumerated integer property. Controls the principal physical link configuration to use on next restart/power-up of the device.
    Controls the principal physical link configuration to use on next restart/power-up of the device.

    The following string values might be valid for this feature:
    - **SingleLink** (Display string: 'Single Link'): Single Link
    - **MultiLink** (Display string: 'Multi Link'): Multi Link
    - **StaticLAG** (Display string: 'Static LAG'): Static LAG
    - **DynamicLAG** (Display string: 'Dynamic LAG'): Dynamic LAG

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    gevCurrentPhysicalLinkConfiguration = property(lib_mvIMPACT_acquire.TransportLayerControl_gevCurrentPhysicalLinkConfiguration_get, doc=r"""
    An enumerated integer property. Indicates the current physical link configuration of the device.
    Indicates the current physical link configuration of the device.

    The following string values might be valid for this feature:
    - **SingleLink** (Display string: 'Single Link'): Single Link
    - **MultiLink** (Display string: 'Multi Link'): Multi Link
    - **StaticLAG** (Display string: 'Static LAG'): Static LAG
    - **DynamicLAG** (Display string: 'Dynamic LAG'): Dynamic LAG

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    gevActiveLinkCount = property(lib_mvIMPACT_acquire.TransportLayerControl_gevActiveLinkCount_get, doc=r"""
    An integer property. Indicates the current number of active logical links.
    Indicates the current number of active logical links.
    """)
    gevSupportedOptionSelector = property(lib_mvIMPACT_acquire.TransportLayerControl_gevSupportedOptionSelector_get, doc=r"""
    An enumerated integer property. Selects the GEV option to interrogate for existing support.
    Selects the GEV option to interrogate for existing support.

    The following string values might be valid for this feature:
    - **SingleLink** (Display string: 'Single Link'): Single Link
    - **MultiLink** (Display string: 'Multi Link'): Multi Link
    - **StaticLAG** (Display string: 'Static LAG'): Static LAG
    - **DynamicLAG** (Display string: 'Dynamic LAG'): Dynamic LAG
    - **PAUSEFrameReception** (Display string: 'PAUSE Frame Reception'): PAUSE Frame Reception
    - **PAUSEFrameGeneration** (Display string: 'PAUSE Frame Generation'): PAUSE Frame Generation
    - **IPConfigurationLLA** (Display string: 'IP Configuration LLA'): IP Configuration LLA
    - **IPConfigurationDHCP** (Display string: 'IP Configuration DHCP'): IP Configuration DHCP
    - **IPConfigurationPersistentIP** (Display string: 'IP Configuration Persistent IP'): IP Configuration Persistent IP
    - **StreamChannelSourceSocket** (Display string: 'Stream Channel Source Socket'): Stream Channel Source Socket
    - **StandardIDMode** (Display string: 'Standard ID Mode'): Standard ID Mode
    - **MessageChannelSourceSocket** (Display string: 'Message Channel Source Socket'): Message Channel Source Socket
    - **CommandsConcatenation** (Display string: 'Commands Concatenation'): Commands Concatenation
    - **WriteMem** (Display string: 'Write Mem'): Write Mem
    - **PacketResend** (Display string: 'Packet Resend'): Packet Resend
    - **Event** (Display string: 'Event'): Event
    - **EventData** (Display string: 'Event Data'): Event Data
    - **PendingAck** (Display string: 'Pending Ack'): Pending Ack
    - **IEEE1588** (Display string: 'IEEE 1588'): IEEE 1588
    - **Ptp** (Display string: 'Ptp'): Ptp
    - **Action** (Display string: 'Action'): Action
    - **UnconditionalAction** (Display string: 'Unconditional Action'): Unconditional Action
    - **ScheduledAction** (Display string: 'Scheduled Action'): Scheduled Action
    - **PrimaryApplicationSwitchover** (Display string: 'Primary Application Switchover'): Primary Application Switchover
    - **ExtendedStatusCodes** (Display string: 'Extended Status Codes'): Extended Status Codes
    - **ExtendedStatusCodesVersion2_0** (Display string: 'Extended Status Codes Version 2 0'): Extended Status Codes Version 2 0
    - **DiscoveryAckDelay** (Display string: 'Discovery Ack Delay'): Discovery Ack Delay
    - **DiscoveryAckDelayWritable** (Display string: 'Discovery Ack Delay Writable'): Discovery Ack Delay Writable
    - **TestData** (Display string: 'Test Data'): Test Data
    - **ManifestTable** (Display string: 'Manifest Table'): Manifest Table
    - **CCPApplicationSocket** (Display string: 'CCP Application Socket'): CCP Application Socket
    - **LinkSpeed** (Display string: 'Link Speed'): Link Speed
    - **HeartbeatDisable** (Display string: 'Heartbeat Disable'): Heartbeat Disable
    - **SerialNumber** (Display string: 'Serial Number'): Serial Number
    - **UserDefinedName** (Display string: 'User Defined Name'): User Defined Name
    - **StreamChannel0BigAndLittleEndian** (Display string: 'Stream Channel 0 Big And Little Endian'): Stream Channel 0 Big And Little Endian
    - **StreamChannel0IPReassembly** (Display string: 'Stream Channel 0 IP Reassembly'): Stream Channel 0 IP Reassembly
    - **StreamChannel0MultiZone** (Display string: 'Stream Channel 0 Multi Zone'): Stream Channel 0 Multi Zone
    - **StreamChannel0PacketResendDestination** (Display string: 'Stream Channel 0 Packet Resend Destination'): Stream Channel 0 Packet Resend Destination
    - **StreamChannel0AllInTransmission** (Display string: 'Stream Channel 0 All In Transmission'): Stream Channel 0 All In Transmission
    - **StreamChannel0UnconditionalStreaming** (Display string: 'Stream Channel 0 Unconditional Streaming'): Stream Channel 0 Unconditional Streaming
    - **StreamChannel0ExtendedChunkData** (Display string: 'Stream Channel 0 Extended Chunk Data'): Stream Channel 0 Extended Chunk Data
    - **StreamChannel1BigAndLittleEndian** (Display string: 'Stream Channel 1 Big And Little Endian'): Stream Channel 1 Big And Little Endian
    - **StreamChannel1IPReassembly** (Display string: 'Stream Channel 1 IP Reassembly'): Stream Channel 1 IP Reassembly
    - **StreamChannel1MultiZone** (Display string: 'Stream Channel 1 Multi Zone'): Stream Channel 1 Multi Zone
    - **StreamChannel1PacketResendDestination** (Display string: 'Stream Channel 1 Packet Resend Destination'): Stream Channel 1 Packet Resend Destination
    - **StreamChannel1AllInTransmission** (Display string: 'Stream Channel 1 All In Transmission'): Stream Channel 1 All In Transmission
    - **StreamChannel1UnconditionalStreaming** (Display string: 'Stream Channel 1 Unconditional Streaming'): Stream Channel 1 Unconditional Streaming
    - **StreamChannel1ExtendedChunkData** (Display string: 'Stream Channel 1 Extended Chunk Data'): Stream Channel 1 Extended Chunk Data
    - **StreamChannel2BigAndLittleEndian** (Display string: 'Stream Channel 2 Big And Little Endian'): Stream Channel 2 Big And Little Endian
    - **StreamChannel2IPReassembly** (Display string: 'Stream Channel 2 IP Reassembly'): Stream Channel 2 IP Reassembly
    - **StreamChannel2MultiZone** (Display string: 'Stream Channel 2 Multi Zone'): Stream Channel 2 Multi Zone
    - **StreamChannel2PacketResendDestination** (Display string: 'Stream Channel 2 Packet Resend Destination'): Stream Channel 2 Packet Resend Destination
    - **StreamChannel2AllInTransmission** (Display string: 'Stream Channel 2 All In Transmission'): Stream Channel 2 All In Transmission
    - **StreamChannel2UnconditionalStreaming** (Display string: 'Stream Channel 2 Unconditional Streaming'): Stream Channel 2 Unconditional Streaming
    - **StreamChannel2ExtendedChunkData** (Display string: 'Stream Channel 2 Extended Chunk Data'): Stream Channel 2 Extended Chunk Data
    - **StreamChannel**#3#ExtendedChunkData (Display string: 'Stream Channel #3# Extended Chunk Data'): Stream Channel #3# Extended Chunk Data

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    gevSupportedOption = property(lib_mvIMPACT_acquire.TransportLayerControl_gevSupportedOption_get, doc=r"""
    A boolean property. Returns if the selected GEV option is supported.
    Returns if the selected GEV option is supported.
    """)
    gevInterfaceSelector = property(lib_mvIMPACT_acquire.TransportLayerControl_gevInterfaceSelector_get, doc=r"""
    An integer property. Selects which logical link to control.
    Selects which logical link to control.
    """)
    gevLinkSpeed = property(lib_mvIMPACT_acquire.TransportLayerControl_gevLinkSpeed_get, doc=r"""
    An integer property. This feature is deprecated (See DeviceLinkSpeed).
    Deprecated: 
    This feature is deprecated (See DeviceLinkSpeed). It was representing the speed of transmission negotiated by the given logical link.
    """)
    gevMACAddress = property(lib_mvIMPACT_acquire.TransportLayerControl_gevMACAddress_get, doc=r"""
    An integer property. MAC address of the logical link.
    MAC address of the logical link.
    """)
    gevPAUSEFrameReception = property(lib_mvIMPACT_acquire.TransportLayerControl_gevPAUSEFrameReception_get, doc=r"""
    A boolean property. Controls whether incoming PAUSE Frames are handled on the given logical link.
    Controls whether incoming PAUSE Frames are handled on the given logical link.
    """)
    gevPAUSEFrameTransmission = property(lib_mvIMPACT_acquire.TransportLayerControl_gevPAUSEFrameTransmission_get, doc=r"""
    A boolean property. Controls whether PAUSE Frames can be generated on the given logical link.
    Controls whether PAUSE Frames can be generated on the given logical link.
    """)
    gevCurrentIPConfigurationLLA = property(lib_mvIMPACT_acquire.TransportLayerControl_gevCurrentIPConfigurationLLA_get, doc=r"""
    A boolean property. Controls whether the Link Local Address IP configuration scheme is activated on the given logical link.
    Controls whether the Link Local Address IP configuration scheme is activated on the given logical link.
    """)
    gevCurrentIPConfigurationDHCP = property(lib_mvIMPACT_acquire.TransportLayerControl_gevCurrentIPConfigurationDHCP_get, doc=r"""
    A boolean property. Controls whether the DHCP IP configuration scheme is activated on the given logical link.
    Controls whether the DHCP IP configuration scheme is activated on the given logical link.
    """)
    gevCurrentIPConfigurationPersistentIP = property(lib_mvIMPACT_acquire.TransportLayerControl_gevCurrentIPConfigurationPersistentIP_get, doc=r"""
    A boolean property. Controls whether the PersistentIP configuration scheme is activated on the given logical link.
    Controls whether the PersistentIP configuration scheme is activated on the given logical link.
    """)
    gevCurrentIPAddress = property(lib_mvIMPACT_acquire.TransportLayerControl_gevCurrentIPAddress_get, doc=r"""
    An integer property. Reports the IP address for the given logical link.
    Reports the IP address for the given logical link.
    """)
    gevCurrentSubnetMask = property(lib_mvIMPACT_acquire.TransportLayerControl_gevCurrentSubnetMask_get, doc=r"""
    An integer property. Reports the subnet mask of the given logical link.
    Reports the subnet mask of the given logical link.
    """)
    gevCurrentDefaultGateway = property(lib_mvIMPACT_acquire.TransportLayerControl_gevCurrentDefaultGateway_get, doc=r"""
    An integer property. Reports the default gateway IP address of the given logical link.
    Reports the default gateway IP address of the given logical link.
    """)
    gevIPConfigurationStatus = property(lib_mvIMPACT_acquire.TransportLayerControl_gevIPConfigurationStatus_get, doc=r"""
    An enumerated integer property. Reports the current IP configuration status.
    Reports the current IP configuration status.

    The following string values might be valid for this feature:
    - **None** (Display string: 'None'): None
    - **PersistentIP** (Display string: 'Persistent IP'): Persistent IP
    - **DHCP** (Display string: 'DHCP'): DHCP
    - **LLA** (Display string: 'LLA'): LLA
    - **ForceIP** (Display string: 'Force IP'): Force IP

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    gevFirstURL = property(lib_mvIMPACT_acquire.TransportLayerControl_gevFirstURL_get, doc=r"""
    A string property. Indicates the first URL to the GenICam XML device description file.
    Indicates the first URL to the GenICam XML device description file. The First URL is used as the first choice by the application to retrieve the GenICam XML device description file.
    """)
    gevSecondURL = property(lib_mvIMPACT_acquire.TransportLayerControl_gevSecondURL_get, doc=r"""
    A string property. Indicates the second URL to the GenICam XML device description file.
    Indicates the second URL to the GenICam XML device description file. This URL is an alternative if the application was unsuccessful to retrieve the device description file using the first URL.
    """)
    gevNumberOfInterfaces = property(lib_mvIMPACT_acquire.TransportLayerControl_gevNumberOfInterfaces_get, doc=r"""
    An integer property. This feature is deprecated (See DeviceLinkSelector).
    Deprecated: 
    This feature is deprecated (See DeviceLinkSelector). It was representing the number of logical links supported by this device.
    """)
    gevPersistentIPAddress = property(lib_mvIMPACT_acquire.TransportLayerControl_gevPersistentIPAddress_get, doc=r"""
    An integer property. Controls the Persistent IP address for this logical link.
    Controls the Persistent IP address for this logical link. It is only used when the device boots with the Persistent IP configuration scheme.
    """)
    gevPersistentSubnetMask = property(lib_mvIMPACT_acquire.TransportLayerControl_gevPersistentSubnetMask_get, doc=r"""
    An integer property. Controls the Persistent subnet mask associated with the Persistent IP address on this logical link.
    Controls the Persistent subnet mask associated with the Persistent IP address on this logical link. It is only used when the device boots with the Persistent IP configuration scheme.
    """)
    gevPersistentDefaultGateway = property(lib_mvIMPACT_acquire.TransportLayerControl_gevPersistentDefaultGateway_get, doc=r"""
    An integer property. Controls the persistent default gateway for this logical link.
    Controls the persistent default gateway for this logical link. It is only used when the device boots with the Persistent IP configuration scheme.
    """)
    gevMessageChannelCount = property(lib_mvIMPACT_acquire.TransportLayerControl_gevMessageChannelCount_get, doc=r"""
    An integer property. This feature is deprecated (See DeviceEventChannelCount).
    Deprecated: 
    This feature is deprecated (See DeviceEventChannelCount). It was representing the number of message channels supported by this device.
    """)
    gevStreamChannelCount = property(lib_mvIMPACT_acquire.TransportLayerControl_gevStreamChannelCount_get, doc=r"""
    An integer property. This feature is deprecated (See DeviceStreamChannelCount).
    Deprecated: 
    This feature is deprecated (See DeviceStreamChannelCount). It was representing the number of stream channels supported by this device.
    """)
    gevHeartbeatTimeout = property(lib_mvIMPACT_acquire.TransportLayerControl_gevHeartbeatTimeout_get, doc=r"""
    An integer property. This feature is deprecated (See DeviceLinkHeartbeatTimeout).
    Deprecated: 
    This feature is deprecated (See DeviceLinkHeartbeatTimeout). It was controlling the current heartbeat timeout in milliseconds.
    """)
    gevTimestampTickFrequency = property(lib_mvIMPACT_acquire.TransportLayerControl_gevTimestampTickFrequency_get, doc=r"""
    An integer property. This feature is deprecated (See the increment of the TimestampLatchValue feature).
    Deprecated: 
    This feature is deprecated (See the increment of the TimestampLatchValue feature). It was used to indicate the number of timestamp ticks in 1 second (frequency in Hz). If PTP is used, this feature must return 1,000,000,000 (1 GHz).
    """)
    gevTimestampControlLatch = property(lib_mvIMPACT_acquire.TransportLayerControl_gevTimestampControlLatch_get, doc=r"""
    A method object. This feature is deprecated (See TimestampLatch).
    Deprecated: 
    This feature is deprecated (See TimestampLatch). It was used to latche the current timestamp counter into GevTimestampValue.
    """)
    gevTimestampControlReset = property(lib_mvIMPACT_acquire.TransportLayerControl_gevTimestampControlReset_get, doc=r"""
    A method object. This feature is deprecated (See TimestampReset).
    Deprecated: 
    This feature is deprecated (See TimestampReset). It was used to reset the timestamp counter to 0. This feature is not available or as no effect when  PTP is used.
    """)
    gevTimestampValue = property(lib_mvIMPACT_acquire.TransportLayerControl_gevTimestampValue_get, doc=r"""
    An integer property. This feature is deprecated (See TimestampLatchValue).
    Deprecated: 
    This feature is deprecated (See TimestampLatchValue). It was used to return the latched 64-bit value of the timestamp counter.
    """)
    gevDiscoveryAckDelay = property(lib_mvIMPACT_acquire.TransportLayerControl_gevDiscoveryAckDelay_get, doc=r"""
    An integer property. Indicates the maximum randomized delay the device will wait to acknowledge a discovery command.
    Indicates the maximum randomized delay the device will wait to acknowledge a discovery command.
    """)
    gevIEEE1588 = property(lib_mvIMPACT_acquire.TransportLayerControl_gevIEEE1588_get, doc=r"""
    A boolean property. This feature is deprecated (See PtpEnable).
    Deprecated: 
    This feature is deprecated (See PtpEnable). It was used to enable the IEEE 1588 Precision Time Protocol to control the timestamp register.
    """)
    gevIEEE1588ClockAccuracy = property(lib_mvIMPACT_acquire.TransportLayerControl_gevIEEE1588ClockAccuracy_get, doc=r"""
    An enumerated integer property. This feature is deprecated (See PtpClockAccurarcy).
    Deprecated: 
    This feature is deprecated (See PtpClockAccurarcy). It was used to indicate the expected accuracy of the device clock when it is the grandmaster, or in the event it becomes the grandmaster.

    The following string values might be valid for this feature:
    - **Within25ns** (Display string: 'Within 25ns'): Within 25ns
    - **Within100ns** (Display string: 'Within 100ns'): Within 100ns
    - **Within250ns** (Display string: 'Within 250ns'): Within 250ns
    - **Within1us** (Display string: 'Within 1us'): Within 1us
    - **Within2p5u** (Display string: 'Within 2p 5u'): Within 2p 5u
    - **Within10us** (Display string: 'Within 10us'): Within 10us
    - **Within25us** (Display string: 'Within 25us'): Within 25us
    - **Within100us** (Display string: 'Within 100us'): Within 100us
    - **Within250us** (Display string: 'Within 250us'): Within 250us
    - **Within1ms** (Display string: 'Within 1ms'): Within 1ms
    - **Within2p5ms** (Display string: 'Within 2p 5ms'): Within 2p 5ms
    - **Within10ms** (Display string: 'Within 10ms'): Within 10ms
    - **Within25ms** (Display string: 'Within 25ms'): Within 25ms
    - **Within100ms** (Display string: 'Within 100ms'): Within 100ms
    - **Within250ms** (Display string: 'Within 250ms'): Within 250ms
    - **Within1s** (Display string: 'Within 1s'): Within 1s
    - **Within10s** (Display string: 'Within 10s'): Within 10s
    - **GreaterThan10s** (Display string: 'Greater Than 10s'): Greater Than 10s
    - **AlternatePTPProfile** (Display string: 'Alternate PTP Profile'): Alternate PTP Profile
    - **Unknown** (Display string: 'Unknown'): Unknown
    - **Reserved** (Display string: 'Reserved'): Reserved

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    gevIEEE1588Status = property(lib_mvIMPACT_acquire.TransportLayerControl_gevIEEE1588Status_get, doc=r"""
    An enumerated integer property. This feature is deprecated (See PtpStatus).
    Deprecated: 
    This feature is deprecated (See PtpStatus). It was used to Provide the status of the IEEE 1588 clock.

    The following string values might be valid for this feature:
    - **Initializing** (Display string: 'Initializing'): Initializing
    - **Faulty** (Display string: 'Faulty'): Faulty
    - **Disabled** (Display string: 'Disabled'): Disabled
    - **Listening** (Display string: 'Listening'): Listening
    - **PreMaster** (Display string: 'Pre Master'): Pre Master
    - **Master** (Display string: 'Master'): Master
    - **Passive** (Display string: 'Passive'): Passive
    - **Uncalibrated** (Display string: 'Uncalibrated'): Uncalibrated
    - **Slave** (Display string: 'Slave'): Slave

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    gevGVCPExtendedStatusCodesSelector = property(lib_mvIMPACT_acquire.TransportLayerControl_gevGVCPExtendedStatusCodesSelector_get, doc=r"""
    An enumerated integer property. Selects the GigE Vision version to control extended status codes for.
    Selects the GigE Vision version to control extended status codes for.

    The following string values might be valid for this feature:
    - **Version1_1** (Display string: 'Version 1 1'): Version 1 1
    - **Version2_0** (Display string: 'Version 2 0'): Version 2 0

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    gevGVCPExtendedStatusCodes = property(lib_mvIMPACT_acquire.TransportLayerControl_gevGVCPExtendedStatusCodes_get, doc=r"""
    A boolean property. Enables the generation of extended status codes.
    Enables the generation of extended status codes.
    """)
    gevGVCPPendingAck = property(lib_mvIMPACT_acquire.TransportLayerControl_gevGVCPPendingAck_get, doc=r"""
    A boolean property. Enables the generation of PENDING_ACK.
    Enables the generation of PENDING_ACK.
    """)
    gevGVCPHeartbeatDisable = property(lib_mvIMPACT_acquire.TransportLayerControl_gevGVCPHeartbeatDisable_get, doc=r"""
    A boolean property. This feature is deprecated (See DeviceLinkHeartbeatMode).
    Deprecated: 
    This feature is deprecated (See DeviceLinkHeartbeatMode). It was used to disable the GVCP heartbeat.
    """)
    gevGVCPPendingTimeout = property(lib_mvIMPACT_acquire.TransportLayerControl_gevGVCPPendingTimeout_get, doc=r"""
    An integer property. This feature is deprecated (See DeviceLinkCommandTimeout).
    Deprecated: 
    This feature is deprecated (See DeviceLinkCommandTimeout). It was used to indicate the longest GVCP command execution time before a device returns a PENDING_ACK.
    """)
    gevPrimaryApplicationSwitchoverKey = property(lib_mvIMPACT_acquire.TransportLayerControl_gevPrimaryApplicationSwitchoverKey_get, doc=r"""
    An integer property. Controls the key to use to authenticate primary application switchover requests.
    Controls the key to use to authenticate primary application switchover requests.
    """)
    gevGVSPExtendedIDMode = property(lib_mvIMPACT_acquire.TransportLayerControl_gevGVSPExtendedIDMode_get, doc=r"""
    An enumerated integer property. Enables the extended IDs mode.
    Enables the extended IDs mode.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off'): Off
    - **On** (Display string: 'On'): On

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    gevCCP = property(lib_mvIMPACT_acquire.TransportLayerControl_gevCCP_get, doc=r"""
    An enumerated integer property. Controls the device access privilege of an application.
    Controls the device access privilege of an application.

    The following string values might be valid for this feature:
    - **OpenAccess** (Display string: 'Open Access'): Open Access
    - **ExclusiveAccess** (Display string: 'Exclusive Access'): Exclusive Access
    - **ControlAccess** (Display string: 'Control Access'): Control Access
    - **ControlAccessSwitchoverActive** (Display string: 'Control Access Switchover Active'): Control Access Switchover Active

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    gevPrimaryApplicationSocket = property(lib_mvIMPACT_acquire.TransportLayerControl_gevPrimaryApplicationSocket_get, doc=r"""
    An integer property. Returns the UDP source port of the primary application.
    Returns the UDP source port of the primary application.
    """)
    gevPrimaryApplicationIPAddress = property(lib_mvIMPACT_acquire.TransportLayerControl_gevPrimaryApplicationIPAddress_get, doc=r"""
    An integer property. Returns the address of the primary application.
    Returns the address of the primary application.
    """)
    gevMCPHostPort = property(lib_mvIMPACT_acquire.TransportLayerControl_gevMCPHostPort_get, doc=r"""
    An integer property. Controls the port to which the device must send messages.
    Controls the port to which the device must send messages. Setting this value to 0 closes the message channel.
    """)
    gevMCDA = property(lib_mvIMPACT_acquire.TransportLayerControl_gevMCDA_get, doc=r"""
    An integer property. Controls the destination IP address for the message channel.
    Controls the destination IP address for the message channel.
    """)
    gevMCTT = property(lib_mvIMPACT_acquire.TransportLayerControl_gevMCTT_get, doc=r"""
    An integer property. Provides the transmission timeout value in milliseconds.
    Provides the transmission timeout value in milliseconds.
    """)
    gevMCRC = property(lib_mvIMPACT_acquire.TransportLayerControl_gevMCRC_get, doc=r"""
    An integer property. Controls the number of retransmissions allowed when a message channel message times out.
    Controls the number of retransmissions allowed when a message channel message times out.
    """)
    gevMCSP = property(lib_mvIMPACT_acquire.TransportLayerControl_gevMCSP_get, doc=r"""
    An integer property. This feature indicates the source port for the message channel.
    This feature indicates the source port for the message channel.
    """)
    gevStreamChannelSelector = property(lib_mvIMPACT_acquire.TransportLayerControl_gevStreamChannelSelector_get, doc=r"""
    An integer property. Selects the stream channel to control.
    Selects the stream channel to control.
    """)
    gevSCCFGPacketResendDestination = property(lib_mvIMPACT_acquire.TransportLayerControl_gevSCCFGPacketResendDestination_get, doc=r"""
    A boolean property. Enables the alternate IP destination for stream packets resent due to a packet resend request.
    Enables the alternate IP destination for stream packets resent due to a packet resend request. When True, the source IP address provided in the packet resend command packet is used. When False, the value set in the GevSCDA[GevStreamChannelSelector] feature is used.
    """)
    gevSCCFGAllInTransmission = property(lib_mvIMPACT_acquire.TransportLayerControl_gevSCCFGAllInTransmission_get, doc=r"""
    A boolean property. Enables the selected GVSP transmitter to use the single packet per data block All-in Transmission mode.
    Enables the selected GVSP transmitter to use the single packet per data block All-in Transmission mode.
    """)
    gevSCCFGUnconditionalStreaming = property(lib_mvIMPACT_acquire.TransportLayerControl_gevSCCFGUnconditionalStreaming_get, doc=r"""
    A boolean property. Enables the camera to continue to stream, for this stream channel, if its control channel is closed or regardless of the reception of any ICMP messages (such as destination unreachable messages).
    Enables the camera to continue to stream, for this stream channel, if its control channel is closed or regardless of the reception of any ICMP messages (such as destination unreachable messages).
    """)
    gevSCCFGExtendedChunkData = property(lib_mvIMPACT_acquire.TransportLayerControl_gevSCCFGExtendedChunkData_get, doc=r"""
    A boolean property. Enables cameras to use the extended chunk data payload type for this stream channel.
    Enables cameras to use the extended chunk data payload type for this stream channel.
    """)
    gevSCPDirection = property(lib_mvIMPACT_acquire.TransportLayerControl_gevSCPDirection_get, doc=r"""
    An enumerated integer property. This feature is deprecated (See DeviceStreamChannelType).
    Deprecated: 
    This feature is deprecated (See DeviceStreamChannelType). It was used to report the direction of the stream channel.

    The following string values might be valid for this feature:
    - **Transmitter** (Display string: 'Transmitter'): Transmitter
    - **Receiver** (Display string: 'Receiver'): Receiver

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    gevSCPInterfaceIndex = property(lib_mvIMPACT_acquire.TransportLayerControl_gevSCPInterfaceIndex_get, doc=r"""
    An integer property. Index of the logical link to use.
    Index of the logical link to use.
    """)
    gevSCPHostPort = property(lib_mvIMPACT_acquire.TransportLayerControl_gevSCPHostPort_get, doc=r"""
    An integer property. Controls the port of the selected channel to which a GVSP transmitter must send data stream or the port from which a GVSP receiver may receive data stream.
    Controls the port of the selected channel to which a GVSP transmitter must send data stream or the port from which a GVSP receiver may receive data stream. Setting this value to 0 closes the stream channel.
    """)
    gevSCPSFireTestPacket = property(lib_mvIMPACT_acquire.TransportLayerControl_gevSCPSFireTestPacket_get, doc=r"""
    A boolean property. Sends a test packet.
    Sends a test packet. When this feature is set, the device will fire one test packet.
    """)
    gevSCPSDoNotFragment = property(lib_mvIMPACT_acquire.TransportLayerControl_gevSCPSDoNotFragment_get, doc=r"""
    A boolean property. The state of this feature is copied into the 'do not fragment' bit of IP header of each stream packet.
    The state of this feature is copied into the 'do not fragment' bit of IP header of each stream packet. It can be used by the application to prevent IP fragmentation of packets on the stream channel.
    """)
    gevSCPSBigEndian = property(lib_mvIMPACT_acquire.TransportLayerControl_gevSCPSBigEndian_get, doc=r"""
    A boolean property. This feature is deprecated (See DeviceStreamChannelEndianness).
    Deprecated: 
    This feature is deprecated (See DeviceStreamChannelEndianness). It was used to control the endianness of multi-byte pixel data for this stream.
    """)
    gevSCPSPacketSize = property(lib_mvIMPACT_acquire.TransportLayerControl_gevSCPSPacketSize_get, doc=r"""
    An integer property. This GigE Vision specific feature corresponds to DeviceStreamChannelPacketSize and should be kept in sync with it.
    This GigE Vision specific feature corresponds to DeviceStreamChannelPacketSize and should be kept in sync with it. It specifies the stream packet size, in bytes, to send on the selected channel for a GVSP transmitter or specifies the maximum packet size supported by a GVSP receiver.
    """)
    gevSCPD = property(lib_mvIMPACT_acquire.TransportLayerControl_gevSCPD_get, doc=r"""
    An integer property. Controls the delay (in GEV timestamp counter unit) to insert between each packet for this stream channel.
    Controls the delay (in GEV timestamp counter unit) to insert between each packet for this stream channel. This can be used as a crude flow-control mechanism if the application or the network infrastructure cannot keep up with the packets coming from the device.
    """)
    gevSCDA = property(lib_mvIMPACT_acquire.TransportLayerControl_gevSCDA_get, doc=r"""
    An integer property. Controls the destination IP address of the selected stream channel to which a GVSP transmitter must send data stream or the destination IP address from which a GVSP receiver may receive data stream.
    Controls the destination IP address of the selected stream channel to which a GVSP transmitter must send data stream or the destination IP address from which a GVSP receiver may receive data stream.
    """)
    gevSCSP = property(lib_mvIMPACT_acquire.TransportLayerControl_gevSCSP_get, doc=r"""
    An integer property. Indicates the source port of the stream channel.
    Indicates the source port of the stream channel.
    """)
    gevSCZoneCount = property(lib_mvIMPACT_acquire.TransportLayerControl_gevSCZoneCount_get, doc=r"""
    An integer property. Reports the number of zones per block transmitted on the selected stream channel.
    Reports the number of zones per block transmitted on the selected stream channel.
    """)
    gevSCZoneDirectionAll = property(lib_mvIMPACT_acquire.TransportLayerControl_gevSCZoneDirectionAll_get, doc=r"""
    An integer property. Reports the transmission direction of each zone transmitted on the selected stream channel.
    Reports the transmission direction of each zone transmitted on the selected stream channel.
    """)
    gevSCZoneConfigurationLock = property(lib_mvIMPACT_acquire.TransportLayerControl_gevSCZoneConfigurationLock_get, doc=r"""
    A boolean property. Controls whether the selected stream channel multi-zone configuration is locked.
    Controls whether the selected stream channel multi-zone configuration is locked. When locked, the GVSP transmitter is not allowed to change the number of zones and their direction during block acquisition and transmission.
    """)
    aPAUSEMACCtrlFramesTransmitted = property(lib_mvIMPACT_acquire.TransportLayerControl_aPAUSEMACCtrlFramesTransmitted_get, doc=r"""
    An integer property. Reports the number of transmitted PAUSE frames.
    Reports the number of transmitted PAUSE frames.
    """)
    aPAUSEMACCtrlFramesReceived = property(lib_mvIMPACT_acquire.TransportLayerControl_aPAUSEMACCtrlFramesReceived_get, doc=r"""
    An integer property. Reports the number of received PAUSE frames.
    Reports the number of received PAUSE frames.
    """)
    clConfiguration = property(lib_mvIMPACT_acquire.TransportLayerControl_clConfiguration_get, doc=r"""
    An enumerated integer property. This Camera Link specific feature describes the configuration used by the camera.
    This Camera Link specific feature describes the configuration used by the camera. It helps especially when a camera is capable of operation in a non-standard configuration, and when the features PixelSize, SensorDigitizationTaps, and DeviceTapGeometry do not provide enough information for interpretation of the image data provided by the camera.

    The following string values might be valid for this feature:
    - **Base** (Display string: 'Base'): Standard base configuration described by the Camera Link standard.
    - **Medium** (Display string: 'Medium'): Standard medium configuration described by the Camera Link standard.
    - **Full** (Display string: 'Full'): Standard full configuration described by the Camera Link standard.
    - **DualBase** (Display string: 'Dual Base'): The camera streams the data from multiple taps (that do not fit in the standard base configuration) through two Camera Link base ports. It is responsibility of the application or frame grabber to reconstruct the full image. Only one of the ports (fixed) serves as the 'master' for serial communication and triggering.
    - **EightyBit** (Display string: 'Eighty Bit'): Standard 80-bit configuration with 10 taps of 8 bits or 8 taps of 10 bits, as described by the Camera Link standard.
    - **Deca** (Display string: 'Deca'): This enumeration entry is deprecated. It was used for Deca configuration with 10 taps of 8-bit. Use EightyBit instead.
    - **Deca** (Display string: 'Deca'): This enumeration entry is deprecated. It was used for Deca configuration with 10 taps of 8-bit. Use EightyBit instead.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    clTimeSlotsCount = property(lib_mvIMPACT_acquire.TransportLayerControl_clTimeSlotsCount_get, doc=r"""
    An enumerated integer property. This Camera Link specific feature describes the time multiplexing of the camera link connection to transfer more than the configuration allows, in one single clock.
    This Camera Link specific feature describes the time multiplexing of the camera link connection to transfer more than the configuration allows, in one single clock.

    The following string values might be valid for this feature:
    - **One** (Display string: 'One'): One
    - **Two** (Display string: 'Two'): Two
    - **Three** (Display string: 'Three'): Three

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    cxpLinkConfigurationStatus = property(lib_mvIMPACT_acquire.TransportLayerControl_cxpLinkConfigurationStatus_get, doc=r"""
    An enumerated integer property. This feature indicates the current and active Link configuration used by the Device.
    This feature indicates the current and active Link configuration used by the Device.

    The following string values might be valid for this feature:
    - **None** (Display string: 'None'): The Link configuration of the Device is unknown. Either the configuration operation has failed or there is nothing connected.
    - **Pending** (Display string: 'Pending'): The Device is in the process of configuring the Link. The Link cannot be used yet.
    - **CXP1_X1** (Display string: 'CXP 1 X 1'): 1 Connection operating at CXP-1 speed (1.25 Gbps).
    - **CXP2_X1** (Display string: 'CXP 2 X 1'): 1 Connection operating at CXP-2 speed (2.50 Gbps).
    - **CXP3_X1** (Display string: 'CXP 3 X 1'): 1 Connection operating at CXP-3 speed (3.125 Gbps).
    - **CXP5_X1** (Display string: 'CXP 5 X 1'): 1 Connection operating at CXP-5 speed (5.00 Gbps).
    - **CXP6_X1** (Display string: 'CXP 6 X 1'): 1 Connection operating at CXP-6 speed (6.25 Gbps).
    - **CXP10_X1** (Display string: 'CXP 10 X 1'): 1 Connection operating at CXP-10 speed (10.00 Gbps).
    - **CXP12_X1** (Display string: 'CXP 12 X 1'): 1 Connection operating at CXP-12 speed (12.50 Gbps).
    - **CXP1_X2** (Display string: 'CXP 1 X 2'): 2 Connections operating at CXP-1 speed (1.25 Gbps).
    - **CXP2_X2** (Display string: 'CXP 2 X 2'): 2 Connections operating at CXP-2 speed (2.50 Gbps).
    - **CXP3_X2** (Display string: 'CXP 3 X 2'): 2 Connections operating at CXP-3 speed (3.125 Gbps).
    - **CXP5_X2** (Display string: 'CXP 5 X 2'): 2 Connections operating at CXP-5 speed (5.00 Gbps).
    - **CXP6_X2** (Display string: 'CXP 6 X 2'): 2 Connections operating at CXP-6 speed (6.25 Gbps).
    - **CXP10_X2** (Display string: 'CXP 10 X 2'): 2 Connections operating at CXP-10 speed (10.00 Gbps).
    - **CXP12_X2** (Display string: 'CXP 12 X 2'): 2 Connections operating at CXP-12 speed (12.50 Gbps).
    - **CXP1_X3** (Display string: 'CXP 1 X 3'): 3 Connections operating at CXP-1 speed (1.25 Gbps).
    - **CXP2_X3** (Display string: 'CXP 2 X 3'): 3 Connections operating at CXP-2 speed (2.50 Gbps).
    - **CXP3_X3** (Display string: 'CXP 3 X 3'): 3 Connections operating at CXP-3 speed (3.125 Gbps).
    - **CXP5_X3** (Display string: 'CXP 5 X 3'): 3 Connections operating at CXP-5 speed (5.00 Gbps).
    - **CXP6_X3** (Display string: 'CXP 6 X 3'): 3 Connections operating at CXP-6 speed (6.25 Gbps).
    - **CXP10_X3** (Display string: 'CXP 10 X 3'): 3 Connections operating at CXP-10 speed (10.00 Gbps).
    - **CXP12_X3** (Display string: 'CXP 12 X 3'): 3 Connections operating at CXP-12 speed (12.50 Gbps).
    - **CXP1_X4** (Display string: 'CXP 1 X 4'): 4 Connections operating at CXP-1 speed (1.25 Gbps).
    - **CXP2_X4** (Display string: 'CXP 2 X 4'): 4 Connections operating at CXP-2 speed (2.50 Gbps).
    - **CXP3_X4** (Display string: 'CXP 3 X 4'): 4 Connections operating at CXP-3 speed (3.125 Gbps).
    - **CXP5_X4** (Display string: 'CXP 5 X 4'): 4 Connections operating at CXP-5 speed (5.00 Gbps).
    - **CXP6_X4** (Display string: 'CXP 6 X 4'): 4 Connections operating at CXP-6 speed (6.25 Gbps).
    - **CXP10_X4** (Display string: 'CXP 10 X 4'): 4 Connections operating at CXP-10 speed (10.00 Gbps).
    - **CXP12_X4** (Display string: 'CXP 12 X 4'): 4 Connections operating at CXP-12 speed (12.50 Gbps).
    - **CXP1_X5** (Display string: 'CXP 1 X 5'): 5 Connections operating at CXP-1 speed (1.25 Gbps).
    - **CXP2_X5** (Display string: 'CXP 2 X 5'): 5 Connections operating at CXP-2 speed (2.50 Gbps).
    - **CXP3_X5** (Display string: 'CXP 3 X 5'): 5 Connections operating at CXP-3 speed (3.125 Gbps).
    - **CXP5_X5** (Display string: 'CXP 5 X 5'): 5 Connections operating at CXP-5 speed (5.00 Gbps).
    - **CXP6_X5** (Display string: 'CXP 6 X 5'): 5 Connections operating at CXP-6 speed (6.25 Gbps).
    - **CXP10_X5** (Display string: 'CXP 10 X 5'): 5 Connections operating at CXP-10 speed (10.00 Gbps).
    - **CXP12_X5** (Display string: 'CXP 12 X 5'): 5 Connections operating at CXP-12 speed (12.50 Gbps).
    - **CXP1_X6** (Display string: 'CXP 1 X 6'): 6 Connections operating at CXP-1 speed (1.25 Gbps).
    - **CXP2_X6** (Display string: 'CXP 2 X 6'): 6 Connections operating at CXP-2 speed (2.50 Gbps).
    - **CXP3_X6** (Display string: 'CXP 3 X 6'): 6 Connections operating at CXP-3 speed (3.125 Gbps).
    - **CXP5_X6** (Display string: 'CXP 5 X 6'): 6 Connections operating at CXP-5 speed (5.00 Gbps).
    - **CXP6_X6** (Display string: 'CXP 6 X 6'): 6 Connections operating at CXP-6 speed (6.25 Gbps).
    - **CXP10_X6** (Display string: 'CXP 10 X 6'): 6 Connections operating at CXP-10 speed (10.00 Gbps).
    - **CXP12_X6** (Display string: 'CXP 12 X 6'): 6 Connections operating at CXP-12 speed (12.50 Gbps).

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    cxpLinkConfigurationPreferred = property(lib_mvIMPACT_acquire.TransportLayerControl_cxpLinkConfigurationPreferred_get, doc=r"""
    An enumerated integer property. Provides the Link configuration that allows the Transmitter Device to operate in its default mode.
    Provides the Link configuration that allows the Transmitter Device to operate in its default mode.

    The following string values might be valid for this feature:
    - **CXP1_X1** (Display string: 'CXP 1 X 1'): 1 Connection operating at CXP-1 speed (1.25 Gbps).
    - **CXP2_X1** (Display string: 'CXP 2 X 1'): 1 Connection operating at CXP-2 speed (2.50 Gbps).
    - **CXP3_X1** (Display string: 'CXP 3 X 1'): 1 Connection operating at CXP-3 speed (3.125 Gbps).
    - **CXP5_X1** (Display string: 'CXP 5 X 1'): 1 Connection operating at CXP-5 speed (5.00 Gbps).
    - **CXP6_X1** (Display string: 'CXP 6 X 1'): 1 Connection operating at CXP-6 speed (6.25 Gbps).
    - **CXP10_X1** (Display string: 'CXP 10 X 1'): 1 Connection operating at CXP-10 speed (10.00 Gbps).
    - **CXP12_X1** (Display string: 'CXP 12 X 1'): 1 Connection operating at CXP-12 speed (12.50 Gbps).
    - **CXP1_X2** (Display string: 'CXP 1 X 2'): 2 Connections operating at CXP-1 speed (1.25 Gbps).
    - **CXP2_X2** (Display string: 'CXP 2 X 2'): 2 Connections operating at CXP-2 speed (2.50 Gbps).
    - **CXP3_X2** (Display string: 'CXP 3 X 2'): 2 Connections operating at CXP-3 speed (3.125 Gbps).
    - **CXP5_X2** (Display string: 'CXP 5 X 2'): 2 Connections operating at CXP-5 speed (5.00 Gbps).
    - **CXP6_X2** (Display string: 'CXP 6 X 2'): 2 Connections operating at CXP-6 speed (6.25 Gbps).
    - **CXP10_X2** (Display string: 'CXP 10 X 2'): 2 Connections operating at CXP-10 speed (10.00 Gbps).
    - **CXP12_X2** (Display string: 'CXP 12 X 2'): 2 Connections operating at CXP-12 speed (12.50 Gbps).
    - **CXP1_X3** (Display string: 'CXP 1 X 3'): 3 Connections operating at CXP-1 speed (1.25 Gbps).
    - **CXP2_X3** (Display string: 'CXP 2 X 3'): 3 Connections operating at CXP-2 speed (2.50 Gbps).
    - **CXP3_X3** (Display string: 'CXP 3 X 3'): 3 Connections operating at CXP-3 speed (3.125 Gbps).
    - **CXP5_X3** (Display string: 'CXP 5 X 3'): 3 Connections operating at CXP-5 speed (5.00 Gbps).
    - **CXP6_X3** (Display string: 'CXP 6 X 3'): 3 Connections operating at CXP-6 speed (6.25 Gbps).
    - **CXP10_X3** (Display string: 'CXP 10 X 3'): 3 Connections operating at CXP-10 speed (10.00 Gbps).
    - **CXP12_X3** (Display string: 'CXP 12 X 3'): 3 Connections operating at CXP-12 speed (12.50 Gbps).
    - **CXP1_X4** (Display string: 'CXP 1 X 4'): 4 Connections operating at CXP-1 speed (1.25 Gbps).
    - **CXP2_X4** (Display string: 'CXP 2 X 4'): 4 Connections operating at CXP-2 speed (2.50 Gbps).
    - **CXP3_X4** (Display string: 'CXP 3 X 4'): 4 Connections operating at CXP-3 speed (3.125 Gbps).
    - **CXP5_X4** (Display string: 'CXP 5 X 4'): 4 Connections operating at CXP-5 speed (5.00 Gbps).
    - **CXP6_X4** (Display string: 'CXP 6 X 4'): 4 Connections operating at CXP-6 speed (6.25 Gbps).
    - **CXP10_X4** (Display string: 'CXP 10 X 4'): 4 Connections operating at CXP-10 speed (10.00 Gbps).
    - **CXP12_X4** (Display string: 'CXP 12 X 4'): 4 Connections operating at CXP-12 speed (12.50 Gbps).
    - **CXP1_X5** (Display string: 'CXP 1 X 5'): 5 Connections operating at CXP-1 speed (1.25 Gbps).
    - **CXP2_X5** (Display string: 'CXP 2 X 5'): 5 Connections operating at CXP-2 speed (2.50 Gbps).
    - **CXP3_X5** (Display string: 'CXP 3 X 5'): 5 Connections operating at CXP-3 speed (3.125 Gbps).
    - **CXP5_X5** (Display string: 'CXP 5 X 5'): 5 Connections operating at CXP-5 speed (5.00 Gbps).
    - **CXP6_X5** (Display string: 'CXP 6 X 5'): 5 Connections operating at CXP-6 speed (6.25 Gbps).
    - **CXP10_X5** (Display string: 'CXP 10 X 5'): 5 Connections operating at CXP-10 speed (10.00 Gbps).
    - **CXP12_X5** (Display string: 'CXP 12 X 5'): 5 Connections operating at CXP-12 speed (12.50 Gbps).
    - **CXP1_X6** (Display string: 'CXP 1 X 6'): 6 Connections operating at CXP-1 speed (1.25 Gbps).
    - **CXP2_X6** (Display string: 'CXP 2 X 6'): 6 Connections operating at CXP-2 speed (2.50 Gbps).
    - **CXP3_X6** (Display string: 'CXP 3 X 6'): 6 Connections operating at CXP-3 speed (3.125 Gbps).
    - **CXP5_X6** (Display string: 'CXP 5 X 6'): 6 Connections operating at CXP-5 speed (5.00 Gbps).
    - **CXP6_X6** (Display string: 'CXP 6 X 6'): 6 Connections operating at CXP-6 speed (6.25 Gbps).
    - **CXP10_X6** (Display string: 'CXP 10 X 6'): 6 Connections operating at CXP-10 speed (10.00 Gbps).
    - **CXP12_X6** (Display string: 'CXP 12 X 6'): 6 Connections operating at CXP-12 speed (12.50 Gbps).

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    cxpLinkConfiguration = property(lib_mvIMPACT_acquire.TransportLayerControl_cxpLinkConfiguration_get, doc=r"""
    An enumerated integer property. This feature allows specifying the Link configuration for the communication between the Receiver and Transmitter Device.
    This feature allows specifying the Link configuration for the communication between the Receiver and Transmitter Device. In most cases this feature does not need to be written because automatic discovery will set configuration correctly to the value returned by CxpLinkConfigurationPreferred. Note that the currently active configuration of the Link can be read using CxpLinkConfigurationStatus.

    The following string values might be valid for this feature:
    - **Auto** (Display string: 'Auto'): Sets Automatic discovery for the Link Configuration.
    - **CXP1_X1** (Display string: 'CXP 1 X 1'): Force the Link to 1 Connection operating at CXP-1 speed (1.25 Gbps).
    - **CXP2_X1** (Display string: 'CXP 2 X 1'): Force the Link to 1 Connection operating at CXP-2 speed (2.50 Gbps).
    - **CXP3_X1** (Display string: 'CXP 3 X 1'): Force the Link to 1 Connection operating at CXP-3 speed (3.125 Gbps).
    - **CXP5_X1** (Display string: 'CXP 5 X 1'): Force the Link to 1 Connection operating at CXP-5 speed (5.00 Gbps).
    - **CXP6_X1** (Display string: 'CXP 6 X 1'): Force the Link to 1 Connection operating at CXP-6 speed (6.25 Gbps).
    - **CXP10_X1** (Display string: 'CXP 10 X 1'): Force the Link to 1 Connection operating at CXP-10 speed (10.00 Gbps).
    - **CXP12_X1** (Display string: 'CXP 12 X 1'): Force the Link to 1 Connection operating at CXP-12 speed (12.50 Gbps).
    - **CXP1_X2** (Display string: 'CXP 1 X 2'): Force the Link to 2 Connections operating at CXP-1 speed (1.25 Gbps).
    - **CXP2_X2** (Display string: 'CXP 2 X 2'): Force the Link to 2 Connections operating at CXP-2 speed (2.50 Gbps).
    - **CXP3_X2** (Display string: 'CXP 3 X 2'): Force the Link to 2 Connections operating at CXP-3 speed (3.125 Gbps).
    - **CXP5_X2** (Display string: 'CXP 5 X 2'): Force the Link to 2 Connections operating at CXP-5 speed (5.00 Gbps).
    - **CXP6_X2** (Display string: 'CXP 6 X 2'): Force the Link to 2 Connections operating at CXP-6 speed (6.25 Gbps).
    - **CXP10_X2** (Display string: 'CXP 10 X 2'): Force the Link to 2 Connections operating at CXP-10 speed (10.00 Gbps).
    - **CXP12_X2** (Display string: 'CXP 12 X 2'): Force the Link to 2 Connections operating at CXP-12 speed (12.50 Gbps).
    - **CXP1_X3** (Display string: 'CXP 1 X 3'): Force the Link to 3 Connections operating at CXP-1 speed (1.25 Gbps).
    - **CXP2_X3** (Display string: 'CXP 2 X 3'): Force the Link to 3 Connections operating at CXP-2 speed (2.50 Gbps).
    - **CXP3_X3** (Display string: 'CXP 3 X 3'): Force the Link to 3 Connections operating at CXP-3 speed (3.125 Gbps).
    - **CXP5_X3** (Display string: 'CXP 5 X 3'): Force the Link to 3 Connections operating at CXP-5 speed (5.00 Gbps).
    - **CXP6_X3** (Display string: 'CXP 6 X 3'): Force the Link to 3 Connections operating at CXP-6 speed (6.25 Gbps).
    - **CXP10_X3** (Display string: 'CXP 10 X 3'): Force the Link to 3 Connections operating at CXP-10 speed (10.00 Gbps).
    - **CXP12_X3** (Display string: 'CXP 12 X 3'): Force the Link to 3 Connections operating at CXP-12 speed (12.50 Gbps).
    - **CXP1_X4** (Display string: 'CXP 1 X 4'): Force the Link to 4 Connections operating at CXP-1 speed (1.25 Gbps).
    - **CXP2_X4** (Display string: 'CXP 2 X 4'): Force the Link to 4 Connections operating at CXP-2 speed (2.50 Gbps).
    - **CXP3_X4** (Display string: 'CXP 3 X 4'): Force the Link to 4 Connections operating at CXP-3 speed (3.125 Gbps).
    - **CXP5_X4** (Display string: 'CXP 5 X 4'): Force the Link to 4 Connections operating at CXP-5 speed (5.00 Gbps).
    - **CXP6_X4** (Display string: 'CXP 6 X 4'): Force the Link to 4 Connections operating at CXP-6 speed (6.25 Gbps).
    - **CXP10_X4** (Display string: 'CXP 10 X 4'): Force the Link to 4 Connections operating at CXP-10 speed (10.00 Gbps).
    - **CXP12_X4** (Display string: 'CXP 12 X 4'): Force the Link to 4 Connections operating at CXP-12 speed (12.50 Gbps).
    - **CXP1_X5** (Display string: 'CXP 1 X 5'): Force the Link to 5 Connections operating at CXP-1 speed (1.25 Gbps).
    - **CXP2_X5** (Display string: 'CXP 2 X 5'): Force the Link to 5 Connections operating at CXP-2 speed (2.50 Gbps).
    - **CXP3_X5** (Display string: 'CXP 3 X 5'): Force the Link to 5 Connections operating at CXP-3 speed (3.125 Gbps).
    - **CXP5_X5** (Display string: 'CXP 5 X 5'): Force the Link to 5 Connections operating at CXP-5 speed (5.00 Gbps).
    - **CXP6_X5** (Display string: 'CXP 6 X 5'): Force the Link to 5 Connections operating at CXP-6 speed (6.25 Gbps).
    - **CXP10_X5** (Display string: 'CXP 10 X 5'): Force the Link to 5 Connections operating at CXP-10 speed (10.00 Gbps).
    - **CXP12_X5** (Display string: 'CXP 12 X 5'): Force the Link to 5 Connections operating at CXP-12 speed (12.50 Gbps).
    - **CXP1_X6** (Display string: 'CXP 1 X 6'): Force the Link to 6 Connections operating at CXP-1 speed (1.25 Gbps).
    - **CXP2_X6** (Display string: 'CXP 2 X 6'): Force the Link to 6 Connections operating at CXP-2 speed (2.50 Gbps).
    - **CXP3_X6** (Display string: 'CXP 3 X 6'): Force the Link to 6 Connections operating at CXP-3 speed (3.125 Gbps).
    - **CXP5_X6** (Display string: 'CXP 5 X 6'): Force the Link to 6 Connections operating at CXP-5 speed (5.00 Gbps).
    - **CXP6_X6** (Display string: 'CXP 6 X 6'): Force the Link to 6 Connections operating at CXP-6 speed (6.25 Gbps).
    - **CXP10_X6** (Display string: 'CXP 10 X 6'): Force the Link to 6 Connections operating at CXP-10 speed (10.00 Gbps).
    - **CXP12_X6** (Display string: 'CXP 12 X 6'): Force the Link to 6 Connections operating at CXP-12 speed (12.50 Gbps).

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    cxpLinkSharingEnable = property(lib_mvIMPACT_acquire.TransportLayerControl_cxpLinkSharingEnable_get, doc=r"""
    A boolean property. Enable or disable the link sharing functionality of the device.
    Enable or disable the link sharing functionality of the device.
    """)
    cxpLinkSharingSubDeviceSelector = property(lib_mvIMPACT_acquire.TransportLayerControl_cxpLinkSharingSubDeviceSelector_get, doc=r"""
    An integer property. Index of the sub device used in the Link Sharing.
    Index of the sub device used in the Link Sharing.
    """)
    cxpLinkSharingSubDeviceType = property(lib_mvIMPACT_acquire.TransportLayerControl_cxpLinkSharingSubDeviceType_get, doc=r"""
    An enumerated integer property. This feature provides the type of sub device.
    This feature provides the type of sub device.

    The following string values might be valid for this feature:
    - **Master** (Display string: 'Master'): The sub device is the master.
    - **Slave** (Display string: 'Slave'): The sub device is a slave.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    cxpLinkSharingHorizontalStripeCount = property(lib_mvIMPACT_acquire.TransportLayerControl_cxpLinkSharingHorizontalStripeCount_get, doc=r"""
    An integer property. This feature provides the number of horizontal stripes that the device implements.
    This feature provides the number of horizontal stripes that the device implements.
    """)
    cxpLinkSharingVerticalStripeCount = property(lib_mvIMPACT_acquire.TransportLayerControl_cxpLinkSharingVerticalStripeCount_get, doc=r"""
    An integer property. This feature provides the number of vertical stripes that the device implements.
    This feature provides the number of vertical stripes that the device implements.
    """)
    cxpLinkSharingHorizontalOverlap = property(lib_mvIMPACT_acquire.TransportLayerControl_cxpLinkSharingHorizontalOverlap_get, doc=r"""
    An integer property. This feature provides the number of pixel overlap in the horizontal stripes that the device implements.
    This feature provides the number of pixel overlap in the horizontal stripes that the device implements.
    """)
    cxpLinkSharingVerticalOverlap = property(lib_mvIMPACT_acquire.TransportLayerControl_cxpLinkSharingVerticalOverlap_get, doc=r"""
    An integer property. This feature provides the number of pixel overlap in the vertical stripes that the device implements.
    This feature provides the number of pixel overlap in the vertical stripes that the device implements.
    """)
    cxpLinkSharingDuplicateStripe = property(lib_mvIMPACT_acquire.TransportLayerControl_cxpLinkSharingDuplicateStripe_get, doc=r"""
    An integer property. This feature provides the duplicate count in striped system.
    This feature provides the duplicate count in striped system. A non-zero value sets the number of duplicate images sent to sub-Devices.
    """)
    cxpConnectionSelector = property(lib_mvIMPACT_acquire.TransportLayerControl_cxpConnectionSelector_get, doc=r"""
    An integer property. Selects the CoaXPress physical connection to control.
    Selects the CoaXPress physical connection to control.
    """)
    cxpConnectionTestMode = property(lib_mvIMPACT_acquire.TransportLayerControl_cxpConnectionTestMode_get, doc=r"""
    An enumerated integer property. Enables the test mode for an individual physical connection of the Device.
    Enables the test mode for an individual physical connection of the Device.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off'): Off
    - **Mode1** (Display string: 'Mode 1'): Mode 1

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    cxpConnectionTestErrorCount = property(lib_mvIMPACT_acquire.TransportLayerControl_cxpConnectionTestErrorCount_get, doc=r"""
    An integer property. Reports the current connection error count for test packets received by the device on the connection selected by CxpConnectionSelector.
    Reports the current connection error count for test packets received by the device on the connection selected by CxpConnectionSelector.
    """)
    cxpSendReceiveSelector = property(lib_mvIMPACT_acquire.TransportLayerControl_cxpSendReceiveSelector_get, doc=r"""
    An enumerated integer property. Selects which one of the send or receive features to control.
    Selects which one of the send or receive features to control.

    The following string values might be valid for this feature:
    - **Send** (Display string: 'Send'): Send
    - **Receive** (Display string: 'Receive'): Receive

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    cxpConnectionTestPacketCount = property(lib_mvIMPACT_acquire.TransportLayerControl_cxpConnectionTestPacketCount_get, doc=r"""
    An integer property. Reports the current count for the test packets on the connection selected by CxpConnectionSelector.
    Reports the current count for the test packets on the connection selected by CxpConnectionSelector.
    """)
    cxpErrorCounterSelector = property(lib_mvIMPACT_acquire.TransportLayerControl_cxpErrorCounterSelector_get, doc=r"""
    An enumerated integer property. Selects which Cxp Error Counter to read or reset.
    Selects which Cxp Error Counter to read or reset.

    The following string values might be valid for this feature:
    - **ConnectionLockLoss** (Display string: 'Connection Lock Loss'): Counts the number of times the lock was lost.
    - **Encoding** (Display string: 'Encoding'): Counts the number of protocol encoding errors detected.
    - **StreamDataPacketCrc** (Display string: 'Stream Data Packet Crc'): Counts the number of CRC errors detected in a data packet. This counter is only available on the CoaXpress host.
    - **ControlPacketCrc** (Display string: 'Control Packet Crc'): Counts the number of CRC errors detected in a control packet.
    - **EventPacketCrc** (Display string: 'Event Packet Crc'): Counts the number of CRC errors detected in an event packet.
    - **DuplicatedCharactersCorrected** (Display string: 'Duplicated Characters Corrected'): Counts the number of corrected errors in the duplicated characters in CXP control words.
    - **DuplicatedCharactersUncorrected** (Display string: 'Duplicated Characters Uncorrected'): Counts the number of uncorrected errors in the duplicated characters in CXP control words.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    cxpErrorCounterReset = property(lib_mvIMPACT_acquire.TransportLayerControl_cxpErrorCounterReset_get, doc=r"""
    A method object. Resets the selected Cxp Error Counter on the connection selected by CxpConnectionSelector.
    Resets the selected Cxp Error Counter on the connection selected by CxpConnectionSelector. The counter starts counting events immediately after the reset.
    """)
    cxpErrorCounterValue = property(lib_mvIMPACT_acquire.TransportLayerControl_cxpErrorCounterValue_get, doc=r"""
    An integer property. Reads the current value of the selected Cxp Error Counter on the connection selected by CxpConnectionSelector.
    Reads the current value of the selected Cxp Error Counter on the connection selected by CxpConnectionSelector.
    """)
    cxpErrorCounterStatus = property(lib_mvIMPACT_acquire.TransportLayerControl_cxpErrorCounterStatus_get, doc=r"""
    An enumerated integer property. Returns the current status of the selected Cxp Error Counter on the connection selected by CxpConnectionSelector.
    Returns the current status of the selected Cxp Error Counter on the connection selected by CxpConnectionSelector.

    The following string values might be valid for this feature:
    - **CounterActive** (Display string: 'Counter Active'): The counter is actively counting errors.
    - **CounterOverflow** (Display string: 'Counter Overflow'): The counter exceeded its maximum error count.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    cxpPoCxpAuto = property(lib_mvIMPACT_acquire.TransportLayerControl_cxpPoCxpAuto_get, doc=r"""
    A method object. Activate automatic control of the Power over CoaXPress (PoCXP) for the Link.
    Activate automatic control of the Power over CoaXPress (PoCXP) for the Link.
    """)
    cxpPoCxpTurnOff = property(lib_mvIMPACT_acquire.TransportLayerControl_cxpPoCxpTurnOff_get, doc=r"""
    A method object. Disable Power over CoaXPress (PoCXP) for the Link.
    Disable Power over CoaXPress (PoCXP) for the Link.
    """)
    cxpPoCxpTripReset = property(lib_mvIMPACT_acquire.TransportLayerControl_cxpPoCxpTripReset_get, doc=r"""
    A method object. Reset the Power over CoaXPress (PoCXP) Link after an over-current trip on the Device connection(s).
    Reset the Power over CoaXPress (PoCXP) Link after an over-current trip on the Device connection(s).
    """)
    cxpPoCxpStatus = property(lib_mvIMPACT_acquire.TransportLayerControl_cxpPoCxpStatus_get, doc=r"""
    An enumerated integer property. Returns the Power over CoaXPress (PoCXP) status of the Device.
    Returns the Power over CoaXPress (PoCXP) status of the Device.

    The following string values might be valid for this feature:
    - **Auto** (Display string: 'Auto'): Normal automatic PoCXP operation.
    - **Off** (Display string: 'Off'): PoCXP is forced off.
    - **Tripped** (Display string: 'Tripped'): The Link has shut down because of an over-current trip.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    cxpFirstLineTriggerWithFrameStart = property(lib_mvIMPACT_acquire.TransportLayerControl_cxpFirstLineTriggerWithFrameStart_get, doc=r"""
    A boolean property. Specifies if a FrameStart trigger also triggers the first LineStart at the same time.
    Specifies if a FrameStart trigger also triggers the first LineStart at the same time.
    """)
    mvGevSCBWControl = property(lib_mvIMPACT_acquire.TransportLayerControl_mvGevSCBWControl_get, doc=r"""
    An enumerated integer property. Selects the bandwidth control for the selected stream channel.
    This enumeration selects the bandwidth control for the selected stream channel.

    The following string values might be valid for this feature:
    - **GevSCPD** (Display string: 'Gev SCPD')
    - **mvGevSCBW** (Display string: 'mv Gev SCBW')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvGevSCBW = property(lib_mvIMPACT_acquire.TransportLayerControl_mvGevSCBW_get, doc=r"""
    An integer property. Sets the stream channels max. bandwidth in KBps
    This value sets the stream channels max. bandwidth in KBps.
    """)

    def gevGetEffectivePayloadPacketsPerImage(self, *args):
        r"""
        *Overload 1:*
         Calculates the effective number of payload packets (not including leader and trailer) per block of data (e.g. an image) for a GigE Vision data stream when transferring the payload type *image*.
         This will include all overhead introduced by the network protocol. The value will be correct for payload type image only, thus e.g. when
         transferring chunk data the result will not be 100 per cent accurate as then some packets will use a slightly different layout. However
         these differences are negligible when working in modes, where individual images are not smaller than roughly 64 by 64 pixels.
         Since: 2.5.11
         :rtype: int
         :return: The effective number of payload packets (not including leader and trailer) per block of data (e.g. an image) transferred by a GigE Vision device with the current parameters.

        :type gevSCPSPacketSizeValue: int
        :param gevSCPSPacketSizeValue: [in] The current or desired gevSCPSPacketSizeValue. This value depends e.g. on the MTU of the NIC the stream has been created on. See network configuration chapters for details.
        :type payloadSizeValue: int
        :param payloadSizeValue: [in] The current value of the *payloadSize* property.
        :type boExtendedID: boolean
        :param boExtendedID: [in] Indicates whether the bandwidth shall be calculated for the extended ID mode (introduced in GigE Vision 2.0) or not. With *boExtendedID* the protocol overhead will increase slightly.

        |

        *Overload 2:*

         This will include all overhead introduced by the network protocol. The value will be correct for payload type image only, thus e.g. when
         transferring chunk data the result will not be 100 per cent accurate as then some packets will use a slightly different layout. However
         these differences are negligible when working in modes, where individual images are not smaller than roughly 64 by 64 pixels.
         Since: 2.5.7
         :rtype: int
         :return: The effective number of payload packets (not including leader and trailer) per block of data (e.g. an image) transferred by a GigE Vision device with the current parameters.

        :type gevSCPSPacketSizeValue: int
        :param gevSCPSPacketSizeValue: [in] The current or desired gevSCPSPacketSizeValue. This value depends e.g. on the MTU of the NIC the stream has been created on. See network configuration chapters for details.
        :type boExtendedID: boolean
        :param boExtendedID: [in] Indicates whether the bandwidth shall be calculated for the extended ID mode (introduced in GigE Vision 2.0) or not. With *boExtendedID* the protocol overhead will increase slightly.

        |

        *Overload 3:*

         This will include all overhead introduced by the network protocol. The value will be correct for payload type image only, thus e.g. when
         transferring chunk data the result will not be 100 per cent accurate as then some packets will use a slightly different layout. However
         these differences are negligible when working in modes, where individual images are not smaller than roughly 64 by 64 pixels.
         Since: 2.5.7
         :rtype: int
         :return: The effective number of payload packets (not including leader and trailer) per block of data (e.g. an image) transferred by a GigE Vision device with the current parameters.

        :type gevSCPSPacketSizeValue: int
        :param gevSCPSPacketSizeValue: [in] The current or desired gevSCPSPacketSizeValue. This value depends e.g. on the MTU of the NIC the stream has been created on. See network configuration chapters for details.
        :param boExtendedID: [in] Indicates whether the bandwidth shall be calculated for the extended ID mode (introduced in GigE Vision 2.0) or not. With *boExtendedID* the protocol overhead will increase slightly.
        """
        return lib_mvIMPACT_acquire.TransportLayerControl_gevGetEffectivePayloadPacketsPerImage(self, *args)

    def gevGetEffectiveBytesPerImage(self, *args):
        r"""
        *Overload 1:*
         Calculates the effective bytes per block of data (e.g. an image) for a GigE Vision data stream when transferring the payload type *image*.
         This will include all overhead introduced by the network protocol. The value will be correct for payload type image only, thus e.g. when
         transferring chunk data the result will not be 100 per cent accurate as then some packets will use a slightly different layout. However
         these differences are negligible when working in modes, where individual images are not smaller than roughly 64 by 64 pixels.
         Since: 2.5.11
         :rtype: int
         :return: The effective bytes per block of data (e.g. an image) transferred by a GigE Vision device with the current parameters.

        :type gevSCPSPacketSizeValue: int
        :param gevSCPSPacketSizeValue: [in] The current or desired gevSCPSPacketSizeValue. This value depends e.g. on the MTU of the NIC the stream has been created on. See network configuration chapters for details.
        :type payloadSizeValue: int
        :param payloadSizeValue: [in] The current value of the *payloadSize* property.
        :type boExtendedID: boolean
        :param boExtendedID: [in] Indicates whether the bandwidth shall be calculated for the extended ID mode (introduced in GigE Vision 2.0) or not. With *boExtendedID* the protocol overhead will increase slightly.

        |

        *Overload 2:*
         Calculates the effective bytes per block of data (e.g. an image) for a GigE Vision data stream when transferring the payload type *image*.
         This will include all overhead introduced by the network protocol. The value will be correct for payload type image only, thus e.g. when
         transferring chunk data the result will not be 100 per cent accurate as then some packets will use a slightly different layout. However
         these differences are negligible when working in modes, where individual images are not smaller than roughly 64 by 64 pixels.
         Since: 2.5.7
         :rtype: int
         :return: The effective bytes per block of data (e.g. an image) transferred by a GigE Vision device with the current parameters.

        :type gevSCPSPacketSizeValue: int
        :param gevSCPSPacketSizeValue: [in] The current or desired gevSCPSPacketSizeValue. This value depends e.g. on the MTU of the NIC the stream has been created on. See network configuration chapters for details.
        :type boExtendedID: boolean
        :param boExtendedID: [in] Indicates whether the bandwidth shall be calculated for the extended ID mode (introduced in GigE Vision 2.0) or not. With *boExtendedID* the protocol overhead will increase slightly.

        |

        *Overload 3:*
         Calculates the effective bytes per block of data (e.g. an image) for a GigE Vision data stream when transferring the payload type *image*.
         This will include all overhead introduced by the network protocol. The value will be correct for payload type image only, thus e.g. when
         transferring chunk data the result will not be 100 per cent accurate as then some packets will use a slightly different layout. However
         these differences are negligible when working in modes, where individual images are not smaller than roughly 64 by 64 pixels.
         Since: 2.5.7
         :rtype: int
         :return: The effective bytes per block of data (e.g. an image) transferred by a GigE Vision device with the current parameters.

        :type gevSCPSPacketSizeValue: int
        :param gevSCPSPacketSizeValue: [in] The current or desired gevSCPSPacketSizeValue. This value depends e.g. on the MTU of the NIC the stream has been created on. See network configuration chapters for details.
        :param boExtendedID: [in] Indicates whether the bandwidth shall be calculated for the extended ID mode (introduced in GigE Vision 2.0) or not. With *boExtendedID* the protocol overhead will increase slightly.
        """
        return lib_mvIMPACT_acquire.TransportLayerControl_gevGetEffectiveBytesPerImage(self, *args)

    def gevGetResultingBandwidth(self, *args):
        r"""
        *Overload 1:*
         Calculates the overall resulting bandwidth (in bytes) needed for GigE Vision data streams when transferring the payload type *image*.
         This will include all overhead introduced by the network protocol. The value will be correct for payload type image only, thus e.g. when
         transferring chunk data the result will not be 100 per cent precise as then some packets will use a slightly different layout. However
         these differences are negligible when working in modes, where individual images are not smaller than roughly 64 by 64 pixels.
         Since: 2.5.11
         :rtype: int
         :return: The overall resulting bandwidth (in bytes) needed for GigE Vision data streams when transferring the payload type *image*.

        :type acquisitionFrameRateValue: float
        :param acquisitionFrameRateValue: [in] The overall current or desired frame rate.
        :type gevSCPSPacketSizeValue: int
        :param gevSCPSPacketSizeValue: [in] The current or desired gevSCPSPacketSizeValue. This value depends e.g. on the MTU of the NIC the stream has been created on. See network configuration chapters for details.
        :type payloadSizeValue: int
        :param payloadSizeValue: [in] The current value of the *payloadSize* property.
        :type boExtendedID: boolean
        :param boExtendedID: [in] Indicates whether the bandwidth shall be calculated for the extended ID mode (introduced in GigE Vision 2.0) or not. With *boExtendedID* the protocol overhead will increase slightly.

        |

        *Overload 2:*
         Calculates the overall resulting bandwidth (in bytes) needed for GigE Vision data streams when transferring the payload type *image*.
         This will include all overhead introduced by the network protocol. The value will be correct for payload type image only, thus e.g. when
         transferring chunk data the result will not be 100 per cent precise as then some packets will use a slightly different layout. However
         these differences are negligible when working in modes, where individual images are not smaller than roughly 64 by 64 pixels.
         Since: 2.5.7
         :rtype: int
         :return: The overall resulting bandwidth (in bytes) needed for GigE Vision data streams when transferring the payload type *image*.

        :type acquisitionFrameRateValue: float
        :param acquisitionFrameRateValue: [in] The overall current or desired frame rate.
        :type gevSCPSPacketSizeValue: int
        :param gevSCPSPacketSizeValue: [in] The current or desired gevSCPSPacketSizeValue. This value depends e.g. on the MTU of the NIC the stream has been created on. See network configuration chapters for details.
        :type boExtendedID: boolean
        :param boExtendedID: [in] Indicates whether the bandwidth shall be calculated for the extended ID mode (introduced in GigE Vision 2.0) or not. With *boExtendedID* the protocol overhead will increase slightly.

        |

        *Overload 3:*
         Calculates the overall resulting bandwidth (in bytes) needed for GigE Vision data streams when transferring the payload type *image*.
         This will include all overhead introduced by the network protocol. The value will be correct for payload type image only, thus e.g. when
         transferring chunk data the result will not be 100 per cent precise as then some packets will use a slightly different layout. However
         these differences are negligible when working in modes, where individual images are not smaller than roughly 64 by 64 pixels.
         Since: 2.5.7
         :rtype: int
         :return: The overall resulting bandwidth (in bytes) needed for GigE Vision data streams when transferring the payload type *image*.

        :type acquisitionFrameRateValue: float
        :param acquisitionFrameRateValue: [in] The overall current or desired frame rate.
        :type gevSCPSPacketSizeValue: int
        :param gevSCPSPacketSizeValue: [in] The current or desired gevSCPSPacketSizeValue. This value depends e.g. on the MTU of the NIC the stream has been created on. See network configuration chapters for details.
        :param boExtendedID: [in] Indicates whether the bandwidth shall be calculated for the extended ID mode (introduced in GigE Vision 2.0) or not. With *boExtendedID* the protocol overhead will increase slightly.
        """
        return lib_mvIMPACT_acquire.TransportLayerControl_gevGetResultingBandwidth(self, *args)

    def gevGetResultingPacketDelay(self, *args):
        r"""
        *Overload 1:*
         Calculates the inter-packet delay needed to achieve a uniform packet and thus payload distribution for GigE Vision data streams when transferring the payload type *image*.
         This will include all overhead introduced by the network protocol. The value will be correct for payload type image only, thus e.g. when
         transferring chunk data the result will not be 100 per cent accurate as then some packets will use a slightly different layout. However
         these differences are negligible when working in modes, where individual images are not smaller than roughly 64 by 64 pixels.

         The result of this function should be written to the property **mvIMPACT::acquire::TransportLayerControl::gevSCPD** if supported by the device.
         Since: 2.5.11
         :rtype: int
         :return: The *GevSCPD* value for the given input parameters. If this value is negative, this indicates that the overall bandwidth resulting
             from the given input parameters is higher than stated by *bandwidthAvailable*. In such a case the inter-packet delay must be set to 0 and
             it should be noted that the desired frame rate cannot be reached in this configuration.

        :type acquisitionFrameRateValue: float
        :param acquisitionFrameRateValue: [in] The overall current or desired frame rate.
        :type gevSCPSPacketSizeValue: int
        :param gevSCPSPacketSizeValue: [in] The current or desired gevSCPSPacketSizeValue. This value depends e.g. on the MTU of the NIC the stream has been created on. See network configuration chapters for details.
        :type payloadSizeValue: int
        :param payloadSizeValue: [in] The current value of the *payloadSize* property.
        :type gevTimestampTickFrequencyValue: int
        :param gevTimestampTickFrequencyValue: [in] The timestamp tick frequency of the GEV remote device.
        :type bandwidthAvailable: int
        :param bandwidthAvailable: [in] The overall bandwidth in bytes that is available on the given link.
        :type boExtendedID: boolean
        :param boExtendedID: [in] Indicates whether the bandwidth shall be calculated for the extended ID mode (introduced in GigE Vision 2.0) or not. With *boExtendedID* the protocol overhead will increase slightly.

        |

        *Overload 2:*
         Calculates the inter-packet delay needed to achieve a uniform packet and thus payload distribution for GigE Vision data streams when transferring the payload type *image*.
         This will include all overhead introduced by the network protocol. The value will be correct for payload type image only, thus e.g. when
         transferring chunk data the result will not be 100 per cent accurate as then some packets will use a slightly different layout. However
         these differences are negligible when working in modes, where individual images are not smaller than roughly 64 by 64 pixels.

         The result of this function should be written to the property **mvIMPACT::acquire::TransportLayerControl::gevSCPD** if supported by the device.
         Since: 2.5.7
         :rtype: int
         :return: The *GevSCPD* value for the given input parameters. If this value is negative, this indicates that the overall bandwidth resulting
             from the given input parameters is higher than stated by *bandwidthAvailable*. In such a case the inter-packet delay must be set to 0 and
             it should be noted that the desired frame rate cannot be reached in this configuration.

        :type acquisitionFrameRateValue: float
        :param acquisitionFrameRateValue: [in] The overall current or desired frame rate.
        :type gevSCPSPacketSizeValue: int
        :param gevSCPSPacketSizeValue: [in] The current or desired gevSCPSPacketSizeValue. This value depends e.g. on the MTU of the NIC the stream has been created on. See network configuration chapters for details.
        :type gevTimestampTickFrequencyValue: int
        :param gevTimestampTickFrequencyValue: [in] The timestamp tick frequency of the GEV remote device.
        :type bandwidthAvailable: int
        :param bandwidthAvailable: [in] The overall bandwidth in bytes that is available on the given link.
        :type boExtendedID: boolean
        :param boExtendedID: [in] Indicates whether the bandwidth shall be calculated for the extended ID mode (introduced in GigE Vision 2.0) or not. With *boExtendedID* the protocol overhead will increase slightly.

        |

        *Overload 3:*
         Calculates the inter-packet delay needed to achieve a uniform packet and thus payload distribution for GigE Vision data streams when transferring the payload type *image*.
         This will include all overhead introduced by the network protocol. The value will be correct for payload type image only, thus e.g. when
         transferring chunk data the result will not be 100 per cent accurate as then some packets will use a slightly different layout. However
         these differences are negligible when working in modes, where individual images are not smaller than roughly 64 by 64 pixels.

         The result of this function should be written to the property **mvIMPACT::acquire::TransportLayerControl::gevSCPD** if supported by the device.
         Since: 2.5.7
         :rtype: int
         :return: The *GevSCPD* value for the given input parameters. If this value is negative, this indicates that the overall bandwidth resulting
             from the given input parameters is higher than stated by *bandwidthAvailable*. In such a case the inter-packet delay must be set to 0 and
             it should be noted that the desired frame rate cannot be reached in this configuration.

        :type acquisitionFrameRateValue: float
        :param acquisitionFrameRateValue: [in] The overall current or desired frame rate.
        :type gevSCPSPacketSizeValue: int
        :param gevSCPSPacketSizeValue: [in] The current or desired gevSCPSPacketSizeValue. This value depends e.g. on the MTU of the NIC the stream has been created on. See network configuration chapters for details.
        :type gevTimestampTickFrequencyValue: int
        :param gevTimestampTickFrequencyValue: [in] The timestamp tick frequency of the GEV remote device.
        :type bandwidthAvailable: int
        :param bandwidthAvailable: [in] The overall bandwidth in bytes that is available on the given link.
        :param boExtendedID: [in] Indicates whether the bandwidth shall be calculated for the extended ID mode (introduced in GigE Vision 2.0) or not. With *boExtendedID* the protocol overhead will increase slightly.
        """
        return lib_mvIMPACT_acquire.TransportLayerControl_gevGetResultingPacketDelay(self, *args)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_TransportLayerControl

# Register TransportLayerControl in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.TransportLayerControl_swigregister(TransportLayerControl)

class mvSerialInterfaceControl(ComponentCollection):
    r"""
    Contains features to control the serial interface.
    Contains features to control the serial interface.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::GenICam::mvSerialInterfaceControl** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.mvSerialInterfaceControl_swiginit(self, lib_mvIMPACT_acquire.new_mvSerialInterfaceControl(*args))
    mvSerialInterfaceEnable = property(lib_mvIMPACT_acquire.mvSerialInterfaceControl_mvSerialInterfaceEnable_get, doc=r"""
    A boolean property. Controls whether the serial interface is enabled or not.
    Controls whether the serial interface is enabled or not.
    """)
    mvSerialInterfaceMode = property(lib_mvIMPACT_acquire.mvSerialInterfaceControl_mvSerialInterfaceMode_get, doc=r"""
    An enumerated integer property. States the interface mode of the serial interface
    States the interface mode of the serial interface

    The following string values might be valid for this feature:
    - **Plain** (Display string: 'Plain')
    - **InveniosLiquidLens** (Display string: 'Invenios Liquid Lens')
    - **OptoEngineeringStepper** (Display string: 'Opto Engineering Stepper')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvSerialInterfaceBaudRate = property(lib_mvIMPACT_acquire.mvSerialInterfaceControl_mvSerialInterfaceBaudRate_get, doc=r"""
    An enumerated integer property. Serial interface clock frequency.
    Serial interface clock frequency.

    The following string values might be valid for this feature:
    - **Hz_115200** (Display string: '115200 Hz')
    - **Hz_57600** (Display string: '57600 Hz')
    - **Hz_38400** (Display string: '38400 Hz')
    - **Hz_19200** (Display string: '19200 Hz')
    - **Hz_9600** (Display string: '9600 Hz')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvSerialInterfaceDataBits = property(lib_mvIMPACT_acquire.mvSerialInterfaceControl_mvSerialInterfaceDataBits_get, doc=r"""
    An enumerated integer property. Number of data bits.
    Number of data bits.

    The following string values might be valid for this feature:
    - **Seven** (Display string: 'Seven')
    - **Eight** (Display string: 'Eight')
    - **Nine** (Display string: 'Nine')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvSerialInterfaceStopBits = property(lib_mvIMPACT_acquire.mvSerialInterfaceControl_mvSerialInterfaceStopBits_get, doc=r"""
    An enumerated integer property. Number of stop bits.
    Number of stop bits.

    The following string values might be valid for this feature:
    - **One** (Display string: 'One')
    - **Two** (Display string: 'Two')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvSerialInterfaceParity = property(lib_mvIMPACT_acquire.mvSerialInterfaceControl_mvSerialInterfaceParity_get, doc=r"""
    An enumerated integer property. Serial interface parity.
    Serial interface parity.

    The following string values might be valid for this feature:
    - **None** (Display string: 'None')
    - **Odd** (Display string: 'Odd')
    - **Even** (Display string: 'Even')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvSerialInterfaceASCIIBuffer = property(lib_mvIMPACT_acquire.mvSerialInterfaceControl_mvSerialInterfaceASCIIBuffer_get, doc=r"""
    A string property. Buffer for exchanging ASCII data over the serial interface. This buffer uses the same memory as 'mvSerialInterfaceBinaryBuffer'.
    Buffer for exchanging ASCII data over the serial interface. This buffer uses the same memory as 'mvSerialInterfaceBinaryBuffer'.
    """)
    mvSerialInterfaceBinaryBuffer = property(lib_mvIMPACT_acquire.mvSerialInterfaceControl_mvSerialInterfaceBinaryBuffer_get, doc=r"""
    A string property. Buffer for exchanging binary data over the serial interface. This buffer uses the same memory as 'mvSerialInterfaceASCIIBuffer'.
    Buffer for exchanging binary data over the serial interface. This buffer uses the same memory as 'mvSerialInterfaceASCIIBuffer'.
    """)
    mvSerialInterfaceBytesToWrite = property(lib_mvIMPACT_acquire.mvSerialInterfaceControl_mvSerialInterfaceBytesToWrite_get, doc=r"""
    An integer property. Length of data to write.
    Length of data to write.
    """)
    mvSerialInterfaceBytesAvailableForRead = property(lib_mvIMPACT_acquire.mvSerialInterfaceControl_mvSerialInterfaceBytesAvailableForRead_get, doc=r"""
    An integer property. Number of serial data bytes available for read.
    Number of serial data bytes available for read.
    """)
    mvSerialInterfaceReceiveStatus = property(lib_mvIMPACT_acquire.mvSerialInterfaceControl_mvSerialInterfaceReceiveStatus_get, doc=r"""
    An integer property. Result of the serial receive error detection mechanism.
    Result of the serial receive error detection mechanism.
    """)
    mvSerialInterfaceBytesToRead = property(lib_mvIMPACT_acquire.mvSerialInterfaceControl_mvSerialInterfaceBytesToRead_get, doc=r"""
    An integer property. Number of serial bytes to read.
    Number of serial bytes to read.
    """)
    mvSerialInterfaceRead = property(lib_mvIMPACT_acquire.mvSerialInterfaceControl_mvSerialInterfaceRead_get, doc=r"""
    A method object. Command to read data from serial interface.
    Command to read data from serial interface.
    """)
    mvSerialInterfaceWrite = property(lib_mvIMPACT_acquire.mvSerialInterfaceControl_mvSerialInterfaceWrite_get, doc=r"""
    A method object. Command to write data to serial interface
    Command to write data to serial interface
    """)
    mvLiquidLensFirmwareVersion = property(lib_mvIMPACT_acquire.mvSerialInterfaceControl_mvLiquidLensFirmwareVersion_get, doc=r"""
    An integer property. Returns the firmware version of the Liquid Lens.
    Returns the firmware version of the Liquid Lens.
    """)
    mvLiquidLensStatus = property(lib_mvIMPACT_acquire.mvSerialInterfaceControl_mvLiquidLensStatus_get, doc=r"""
    An enumerated integer property. Returns the current status of the Liquid Lens.
    Returns the current status of the Liquid Lens.

    The following string values might be valid for this feature:
    - **NoError** (Display string: 'No Error'): No Errors.
    - **VhOverload** (Display string: 'Vh Overload'): Vh below 70V because Liquid Lens is taking too much current.
    - **ThermalOverload** (Display string: 'Thermal Overload'): Driver shutdown because Liquid Lens is too hot.
    - **VhAndThermalOverload** (Display string: 'Vh And Thermal Overload'): Vh does not reach 70V and driver shutdown because Liquid Lens is too hot.
    - **StatusReadErrorNoAnswer** (Display string: 'Status Read Error No Answer'): No response from Liquid Lens.
    - **StatusReadErrorCRC** (Display string: 'Status Read Error CRC'): CRC error in response from Liquid Lens.
    - **StatusReadErrorNakAnswer** (Display string: 'Status Read Error Nak Answer'): NAK response from Liquid Lens.
    - **StatusReadErrorInvalidAnswer** (Display string: 'Status Read Error Invalid Answer'): Invalid Size or Command in response from Liquid Lens.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvLiquidLensErrorCount = property(lib_mvIMPACT_acquire.mvSerialInterfaceControl_mvLiquidLensErrorCount_get, doc=r"""
    An integer property. This register increments whenever an error occurred while communicating with the Liquid Lens.
    This register increments whenever an error occurred while communicating with the Liquid Lens.
    """)
    mvLiquidLensPowerMode = property(lib_mvIMPACT_acquire.mvSerialInterfaceControl_mvLiquidLensPowerMode_get, doc=r"""
    An enumerated integer property. Selects the device power mode.
    Selects the device power mode.

    The following string values might be valid for this feature:
    - **mvLiquidLensActive** (Display string: 'mv Liquid Lens Active'): Puts the device to power-active mode.
    - **mvLiquidLensStandby** (Display string: 'mv Liquid Lens Standby'): Puts the Liquid Lens in power-saving mode. In this mode the device will only consume up to 25 percent of its normal power consumption.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvLiquidLensSetFocusValue = property(lib_mvIMPACT_acquire.mvSerialInterfaceControl_mvLiquidLensSetFocusValue_get, doc=r"""
    An integer property. Focus position value for Liquid Lens.
    Focus position value for Liquid Lens.
    """)
    mvLiquidLensReceiveStatus = property(lib_mvIMPACT_acquire.mvSerialInterfaceControl_mvLiquidLensReceiveStatus_get, doc=r"""
    An integer property. Result of the serial receive error detection mechanism.
    Result of the serial receive error detection mechanism. This is a bit field. The bits have the following meaning: 0x1: CRC Error, 0x2: NAK received, 0x4: No response, 0x8 Incorrect answer received.
    """)
    mvLiquidLensSaveFocusValue = property(lib_mvIMPACT_acquire.mvSerialInterfaceControl_mvLiquidLensSaveFocusValue_get, doc=r"""
    A method object. Saves the current Focus position into LiquidLens EEPROM.
    Saves the current Focus position into LiquidLens EEPROM.
    """)
    mvStepperFirmwareVersion = property(lib_mvIMPACT_acquire.mvSerialInterfaceControl_mvStepperFirmwareVersion_get, doc=r"""
    An integer property. Returns the firmware version of the Opto Engineering Stepper.
    Returns the firmware version of the Opto Engineering Stepper.
    """)
    mvStepperReceiveStatus = property(lib_mvIMPACT_acquire.mvSerialInterfaceControl_mvStepperReceiveStatus_get, doc=r"""
    An integer property. Result of the serial receive error detection mechanism.
    Result of the serial receive error detection mechanism. This is a bit field. The bits have the following meaning: 0x1: Reserved, 0x2: Mismatch in answer detected, 0x4: No response, 0x8 Incorrect answer received.
    """)
    mvStepperErrorCount = property(lib_mvIMPACT_acquire.mvSerialInterfaceControl_mvStepperErrorCount_get, doc=r"""
    An integer property. This register increments whenever an error occurred while communicating with the Opto Engineering Stepper.
    This register increments whenever an error occurred while communicating with the Opto Engineering Stepper.
    """)
    mvStepperAutoSavePositionEnable = property(lib_mvIMPACT_acquire.mvSerialInterfaceControl_mvStepperAutoSavePositionEnable_get, doc=r"""
    A boolean property. Controls if the auto-save of motor positions is active.
    Controls if the auto-save of motor positions is active.
    """)
    mvStepperMotorSelector = property(lib_mvIMPACT_acquire.mvSerialInterfaceControl_mvStepperMotorSelector_get, doc=r"""
    An enumerated integer property. Selects the stepper motor to control.
    Selects the stepper motor to control(Zoom, Iris or Focus).

    The following string values might be valid for this feature:
    - **All** (Display string: 'All'): All stepper motors are selected.
    - **Zoom** (Display string: 'Zoom'): Selects the stepper motor controlling the zoom.
    - **Focus** (Display string: 'Focus'): Selects the stepper motor controlling the focus.
    - **Iris** (Display string: 'Iris'): Selects the stepper motor controlling the iris.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvStepperStatus = property(lib_mvIMPACT_acquire.mvSerialInterfaceControl_mvStepperStatus_get, doc=r"""
    An enumerated integer property. Returns the current status of the stepper.
    Returns the current status of the stepper.

    The following string values might be valid for this feature:
    - **Unknown** (Display string: 'Unknown'): The current status of the stepper is unknown.
    - **Moving** (Display string: 'Moving'): The selected stepper motor is currently moving.
    - **StoppedAtLowerLimitWithTorque** (Display string: 'Stopped At Lower Limit With Torque'): The selected stepper motor has stopped at its lower limit with torque(this should never happen and indicates a problem).
    - **StoppedAtLowerLimit** (Display string: 'Stopped At Lower Limit'): The selected stepper motor has stopped at its lower limit.
    - **StoppedAtUpperLimitWithTorque** (Display string: 'Stopped At Upper Limit With Torque'): The selected stepper motor has stopped at its upper limit with torque(this should never happen and indicates a problem).
    - **StoppedAtUpperLimit** (Display string: 'Stopped At Upper Limit'): The selected stepper motor has stopped at its upper limit.
    - **StoppedWithTorque** (Display string: 'Stopped With Torque'): The selected stepper motor has stopped with torque(this should never happen and indicates a problem).
    - **Stopped** (Display string: 'Stopped'): The selected stepper motor has stopped.
    - **OvercurrentOrOvertemperatureError** (Display string: 'Overcurrent Or Overtemperature Error'): The selected stepper motor either became too hot or is taking in too much current(this should never happen and indicates a problem).

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvStepperCurrentPosition = property(lib_mvIMPACT_acquire.mvSerialInterfaceControl_mvStepperCurrentPosition_get, doc=r"""
    An integer property. Read current position from stepper.
    Read current position from stepper.
    """)
    mvStepperDesiredPosition = property(lib_mvIMPACT_acquire.mvSerialInterfaceControl_mvStepperDesiredPosition_get, doc=r"""
    An integer property. The desired position of the selected stepper motor.
    The desired position of the selected stepper motor. When the motor has not yet reached this position(is moving) this value may differ from 'mvStepperCurrentPosition'.
    """)
    mvStepperSpeed = property(lib_mvIMPACT_acquire.mvSerialInterfaceControl_mvStepperSpeed_get, doc=r"""
    A floating point property. Current speed of the selected stepper motor.
    Current speed of the selected stepper motor.
    """)
    mvStepperAcceleration = property(lib_mvIMPACT_acquire.mvSerialInterfaceControl_mvStepperAcceleration_get, doc=r"""
    A floating point property. Current acceleration of the selected stepper motor.
    Current acceleration of the selected stepper motor.
    """)
    mvStepperSpeedManual = property(lib_mvIMPACT_acquire.mvSerialInterfaceControl_mvStepperSpeedManual_get, doc=r"""
    A floating point property. Manual speed of the selected stepper motor.
    Manual speed of the selected stepper motor.
    """)
    mvStepperPositionSetSelector = property(lib_mvIMPACT_acquire.mvSerialInterfaceControl_mvStepperPositionSetSelector_get, doc=r"""
    An integer property. Selects the stepper parameter set to load or save.
    Selects the stepper parameter set to load or save.
    """)
    mvStepperPositionSetLoad = property(lib_mvIMPACT_acquire.mvSerialInterfaceControl_mvStepperPositionSetLoad_get, doc=r"""
    A method object. Loads the stepper 'mvStepperDesiredPosition' specified by 'mvStepperPositionSetSelector' and makes it active for each motor.
    Loads the stepper 'mvStepperDesiredPosition' specified by 'mvStepperPositionSetSelector' and makes it active for each motor.
    """)
    mvStepperPositionSetSave = property(lib_mvIMPACT_acquire.mvSerialInterfaceControl_mvStepperPositionSetSave_get, doc=r"""
    A method object. Saves the stepper 'mvStepperDesiredPosition' specified by 'mvStepperPositionSetSelector' into the steppers non-volatile memory for each motor.
    Saves the stepper 'mvStepperDesiredPosition' specified by 'mvStepperPositionSetSelector' into the steppers non-volatile memory for each motor.
    """)
    mvStepperMoveToHomeAll = property(lib_mvIMPACT_acquire.mvSerialInterfaceControl_mvStepperMoveToHomeAll_get, doc=r"""
    A method object. Moves all stepper motors to their home position.
    Moves all stepper motors to their home position.
    """)
    mvStepperStopAll = property(lib_mvIMPACT_acquire.mvSerialInterfaceControl_mvStepperStopAll_get, doc=r"""
    A method object. Stops all stepper motors.
    Stops all stepper motors.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_mvSerialInterfaceControl

# Register mvSerialInterfaceControl in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.mvSerialInterfaceControl_swigregister(mvSerialInterfaceControl)

class mvI2cInterfaceControl(object):
    r"""
    Contains features to control the I2C interface.
    Contains features to control the I2C interface.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::GenICam::mvI2cInterfaceControl** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.mvI2cInterfaceControl_swiginit(self, lib_mvIMPACT_acquire.new_mvI2cInterfaceControl(*args))
    mvI2cInterfaceEnable = property(lib_mvIMPACT_acquire.mvI2cInterfaceControl_mvI2cInterfaceEnable_get, doc=r"""
    A boolean property. Controls whether the I2C interface is enabled or not.
    Controls whether the I2C interface is enabled or not.
    """)
    mvI2cInterfaceDeviceAddress = property(lib_mvIMPACT_acquire.mvI2cInterfaceControl_mvI2cInterfaceDeviceAddress_get, doc=r"""
    An integer property. I2C device address, must be even.
    I2C device address, must be even, blocked addresses: 0x20, 0x30 (Test), 0x32, 0x34, 0x36, 0x3E, 0x60, 0x62, 0x64, 0x66, 0x6E, 0x90, 0x92, 0xA0, 0xA2, 0xA4, 0xA6, 0xAE, 0xB0, 0xB2, 0xB4, 0xB6, 0xB8, 0xBA, 0xBC, 0xBE.
    """)
    mvI2cInterfaceDeviceSubAddress = property(lib_mvIMPACT_acquire.mvI2cInterfaceControl_mvI2cInterfaceDeviceSubAddress_get, doc=r"""
    An integer property. I2C device sub address ignored when set to -1, 2 byte address if bit 0x10000 is set, else 1 Byte.
    I2C device sub address ignored when set to -1, 2 byte address if bit 0x10000 is set, else 1 Byte.
    """)
    mvI2cInterfaceASCIIBuffer = property(lib_mvIMPACT_acquire.mvI2cInterfaceControl_mvI2cInterfaceASCIIBuffer_get, doc=r"""
    A string property. Buffer for exchanging ASCII data over the I2C interface. This buffer uses the same memory as 'mvI2cInterfaceBinaryBuffer'.
    Buffer for exchanging ASCII data over the I2C interface. This buffer uses the same memory as 'mvI2cInterfaceBinaryBuffer'.
    """)
    mvI2cInterfaceBinaryBuffer = property(lib_mvIMPACT_acquire.mvI2cInterfaceControl_mvI2cInterfaceBinaryBuffer_get, doc=r"""
    A string property. Buffer for exchanging binary data over the I2C interface. This buffer uses the same memory as 'mvI2cInterfaceASCIIBuffer'.
    Buffer for exchanging binary data over the I2C interface. This buffer uses the same memory as 'mvI2cInterfaceASCIIBuffer'.
    """)
    mvI2cInterfaceBytesToWrite = property(lib_mvIMPACT_acquire.mvI2cInterfaceControl_mvI2cInterfaceBytesToWrite_get, doc=r"""
    An integer property. Number of bytes from mvI2cInterfaceBuffer to write to I2C device.
    Number of bytes from mvI2cInterfaceBuffer to write to I2C device.
    """)
    mvI2cInterfaceBytesToRead = property(lib_mvIMPACT_acquire.mvI2cInterfaceControl_mvI2cInterfaceBytesToRead_get, doc=r"""
    An integer property. Number of bytes to read from I2C device.
    Number of bytes to read from I2C device.
    """)
    mvI2cInterfaceRead = property(lib_mvIMPACT_acquire.mvI2cInterfaceControl_mvI2cInterfaceRead_get, doc=r"""
    A method object. Command to read data from I2C device.
    Command to read data from I2C device.
    """)
    mvI2cInterfaceWrite = property(lib_mvIMPACT_acquire.mvI2cInterfaceControl_mvI2cInterfaceWrite_get, doc=r"""
    A method object. Command to write data to I2C device
    Command to write data to I2C device
    """)
    mvI2cInterfaceSpeed = property(lib_mvIMPACT_acquire.mvI2cInterfaceControl_mvI2cInterfaceSpeed_get, doc=r"""
    An enumerated integer property. I2C interface clock frequency.
    I2C interface clock frequency.

    The following string values might be valid for this feature:
    - **kHz_100** (Display string: '100 kHz'): default speed
    - **kHz_400** (Display string: '400 kHz'): fast speed

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_mvI2cInterfaceControl

# Register mvI2cInterfaceControl in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.mvI2cInterfaceControl_swigregister(mvI2cInterfaceControl)

class mvCustomData(ComponentCollection):
    r"""
    Custom area.
    Custom area.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::GenICam::mvCustomData** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.mvCustomData_swiginit(self, lib_mvIMPACT_acquire.new_mvCustomData(*args))
    mvCustomText = property(lib_mvIMPACT_acquire.mvCustomData_mvCustomText_get, doc=r"""
    A string property. Custom text.
    Custom text.
    """)
    mvWriteCustomData = property(lib_mvIMPACT_acquire.mvCustomData_mvWriteCustomData_get, doc=r"""
    A method object. Function to write custom data.
    Function to write custom data.
    """)
    mvReadCustomData = property(lib_mvIMPACT_acquire.mvCustomData_mvReadCustomData_get, doc=r"""
    A method object. Function to read custom data.
    Function to read custom data.
    """)
    mvSensorRegister = property(lib_mvIMPACT_acquire.mvCustomData_mvSensorRegister_get, doc=r"""
    An integer property. Sensor register address to access.
    Sensor register address to access.
    """)
    mvSensorRegisterValue = property(lib_mvIMPACT_acquire.mvCustomData_mvSensorRegisterValue_get, doc=r"""
    An integer property. Value of sensor register.
    Value of sensor register.
    """)
    mvInternalRegister = property(lib_mvIMPACT_acquire.mvCustomData_mvInternalRegister_get, doc=r"""
    An integer property. Register address to access.
    Register address to access.
    """)
    mvInternalRegisterValue = property(lib_mvIMPACT_acquire.mvCustomData_mvInternalRegisterValue_get, doc=r"""
    An integer property. Value of internal register.
    Value of internal register.
    """)
    mvMSeqRegister = property(lib_mvIMPACT_acquire.mvCustomData_mvMSeqRegister_get, doc=r"""
    An integer property. Register address to access.
    Register address to access.
    """)
    mvMSeqRegisterValue = property(lib_mvIMPACT_acquire.mvCustomData_mvMSeqRegisterValue_get, doc=r"""
    An integer property. Value of mseq register.
    Value of mseq register.
    """)
    mvStateSumRegister = property(lib_mvIMPACT_acquire.mvCustomData_mvStateSumRegister_get, doc=r"""
    An integer property. Indicates several states besides some other info.
    Indicates several states besides some other info.
    """)
    mvStat2SumRegister = property(lib_mvIMPACT_acquire.mvCustomData_mvStat2SumRegister_get, doc=r"""
    An integer property. Indicates several states besides some other info.
    Indicates several states besides some other info.
    """)
    mvStat3SumRegister = property(lib_mvIMPACT_acquire.mvCustomData_mvStat3SumRegister_get, doc=r"""
    An integer property. Indicates several states besides some other info.
    Indicates several states besides some other info.
    """)
    mvStat4SumRegister = property(lib_mvIMPACT_acquire.mvCustomData_mvStat4SumRegister_get, doc=r"""
    An integer property. Indicates several states besides some other info.
    Indicates several states besides some other info.
    """)
    mvStat5SumRegister = property(lib_mvIMPACT_acquire.mvCustomData_mvStat5SumRegister_get, doc=r"""
    An integer property. Indicates several states besides some other info.
    Indicates several states besides some other info.
    """)
    mvStat6SumRegister = property(lib_mvIMPACT_acquire.mvCustomData_mvStat6SumRegister_get, doc=r"""
    An integer property. Indicates several states besides some other info.
    Indicates several states besides some other info.
    """)
    mvStateSumRegisterReset = property(lib_mvIMPACT_acquire.mvCustomData_mvStateSumRegisterReset_get, doc=r"""
    A method object. Resets the state register.
    Resets the state register.
    """)
    mvStateSumRegister3Reset = property(lib_mvIMPACT_acquire.mvCustomData_mvStateSumRegister3Reset_get, doc=r"""
    A method object. Resets the state register.
    Resets the state register.
    """)
    mvLVDSSelection = property(lib_mvIMPACT_acquire.mvCustomData_mvLVDSSelection_get, doc=r"""
    An integer property. Selector for LVDS lanes.
    Selector for LVDS lanes.
    """)
    mvLVDSAlignment = property(lib_mvIMPACT_acquire.mvCustomData_mvLVDSAlignment_get, doc=r"""
    An integer property. Alignment of LVDS lanes.
    Alignment of LVDS lanes.
    """)
    mvRunTest = property(lib_mvIMPACT_acquire.mvCustomData_mvRunTest_get, doc=r"""
    A method object. Runs internal test.
    Runs internal test.
    """)
    mvTestNumber = property(lib_mvIMPACT_acquire.mvCustomData_mvTestNumber_get, doc=r"""
    An integer property. Number of test to run.
    Number of test to run.
    """)
    mvTestMin = property(lib_mvIMPACT_acquire.mvCustomData_mvTestMin_get, doc=r"""
    An integer property. Min number for test.
    Min number for test.
    """)
    mvTestMax = property(lib_mvIMPACT_acquire.mvCustomData_mvTestMax_get, doc=r"""
    An integer property. Max number for test.
    Max number for test.
    """)
    mvCustomCommandInterpreterVersionMajor = property(lib_mvIMPACT_acquire.mvCustomData_mvCustomCommandInterpreterVersionMajor_get, doc=r"""
    An integer property. Returns the major version of the custom command interpreter on the device.
    Returns the major version of the custom command interpreter on the device.
    """)
    mvCustomCommandInterpreterVersionMinor = property(lib_mvIMPACT_acquire.mvCustomData_mvCustomCommandInterpreterVersionMinor_get, doc=r"""
    An integer property. Returns the minor version of the custom command interpreter on the device.
    Returns the minor version of the custom command interpreter on the device.
    """)
    mvCustomCommandBuffer = property(lib_mvIMPACT_acquire.mvCustomData_mvCustomCommandBuffer_get, doc=r"""
    A string property. Command buffer for custom commands.
    Command buffer for custom commands.
    """)
    mvImxSensorType = property(lib_mvIMPACT_acquire.mvCustomData_mvImxSensorType_get, doc=r"""
    An enumerated integer property. IMX sensor type from registers.
    IMX sensor type from registers.

    The following string values might be valid for this feature:
    - **mvUnknown** (Display string: 'mv Unknown'): unknown or TS
    - **IMX250G** (Display string: 'IMX250G'): IMX250 Grey
    - **IMX250G_POL** (Display string: 'IMX250G_POL'): IMX250 Grey with POL filter
    - **IMX250C** (Display string: 'IMX250C'): IMX250 Color
    - **IMX250C_POL** (Display string: 'IMX250C_POL'): IMX250 Color with POL filter
    - **IMX252G** (Display string: 'IMX252G'): IMX252 Grey
    - **IMX252C** (Display string: 'IMX252C'): IMX252 Color
    - **IMX253G** (Display string: 'IMX253G'): IMX253 Grey
    - **IMX253C** (Display string: 'IMX253C'): IMX253 Color
    - **IMX255G** (Display string: 'IMX255G'): IMX255 Grey
    - **IMX255C** (Display string: 'IMX255C'): IMX255 Color
    - **IMX264G** (Display string: 'IMX264G'): IMX264 Grey
    - **IMX264C** (Display string: 'IMX264C'): IMX264 Color
    - **IMX265G** (Display string: 'IMX265G'): IMX265 Grey
    - **IMX265C** (Display string: 'IMX265C'): IMX265 Color
    - **IMX267G** (Display string: 'IMX267G'): IMX267 Grey
    - **IMX267C** (Display string: 'IMX267C'): IMX267 Color
    - **IMX273G** (Display string: 'IMX273G'): IMX273 Grey
    - **IMX273C** (Display string: 'IMX273C'): IMX273 Color
    - **IMX392G** (Display string: 'IMX392G'): IMX392 Grey
    - **IMX392C** (Display string: 'IMX392C'): IMX392 Color
    - **IMX287G** (Display string: 'IMX287G'): IMX287 Grey
    - **IMX287C** (Display string: 'IMX287C'): IMX287 Color
    - **IMX304G** (Display string: 'IMX304G'): IMX304 Grey
    - **IMX304C** (Display string: 'IMX304C'): IMX304 Color
    - **IMX342G** (Display string: 'IMX342G'): IMX342 Grey
    - **IMX342C** (Display string: 'IMX342C'): IMX342 Color
    - **IMX367G** (Display string: 'IMX367G'): IMX367 Grey
    - **IMX367C** (Display string: 'IMX367C'): IMX367 Color
    - **IMX387G** (Display string: 'IMX387G'): IMX387 Grey
    - **IMX387C** (Display string: 'IMX387C'): IMX387 Color
    - **IMX420G** (Display string: 'IMX420G'): IMX420 Grey
    - **IMX420C** (Display string: 'IMX420C'): IMX420 Color
    - **IMX425G** (Display string: 'IMX425G'): IMX425 Grey
    - **IMX425C** (Display string: 'IMX425C'): IMX425 Color
    - **IMX428G** (Display string: 'IMX428G'): IMX428 Grey
    - **IMX428C** (Display string: 'IMX428C'): IMX428 Color
    - **IMX430G** (Display string: 'IMX430G'): IMX430 Grey
    - **IMX430C** (Display string: 'IMX430C'): IMX430 Color
    - **IMX432G** (Display string: 'IMX432G'): IMX432 Grey
    - **IMX432C** (Display string: 'IMX432C'): IMX432 Color
    - **IMX531G** (Display string: 'IMX531G'): IMX531 Grey
    - **IMX531C** (Display string: 'IMX531C'): IMX531 Color
    - **IMX532G** (Display string: 'IMX532G'): IMX532 Grey
    - **IMX532C** (Display string: 'IMX532C'): IMX532 Color
    - **IMX535G** (Display string: 'IMX535G'): IMX535 Grey
    - **IMX535C** (Display string: 'IMX535C'): IMX535 Color
    - **IMX540G** (Display string: 'IMX540G'): IMX540 Grey
    - **IMX540C** (Display string: 'IMX540C'): IMX540 Color
    - **IMX541G** (Display string: 'IMX541G'): IMX541 Grey
    - **IMX541C** (Display string: 'IMX541C'): IMX541 Color
    - **IMX542G** (Display string: 'IMX542G'): IMX542 Grey
    - **IMX542C** (Display string: 'IMX542C'): IMX542 Color

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvImxSensorIdOne = property(lib_mvIMPACT_acquire.mvCustomData_mvImxSensorIdOne_get, doc=r"""
    An integer property. IMX SensorID1
    IMX SensorID1
    """)
    mvImxGroup = property(lib_mvIMPACT_acquire.mvCustomData_mvImxGroup_get, doc=r"""
    An enumerated integer property. IMX Group
    IMX Group

    The following string values might be valid for this feature:
    - **mvUnknown** (Display string: 'mv Unknown'): unknown
    - **V2TypeOneGroup** (Display string: 'V2 Type One Group'): Type 1/1 Group: IMX253/255/267/304/305 (2nd Generation GS-CIS)
    - **V2TypeTwoThirdsGroup** (Display string: 'V2 Type Two Thirds Group'): Type 2/3 Group: IMX250/252/264/265 (2nd Generation GS-CIS)
    - **V2TypeOneThirdGroup** (Display string: 'V2 Type One Third Group'): Type 1/3 Group: IMX273/287/296/297/392 (2nd Generation GS-CIS)
    - **V25Group342** (Display string: 'V2.5 Group 342'): Group 342: IMX342/367/387 (IMX342 GS-CIS)
    - **V3Group1** (Display string: 'V3 Group 1'): Group 1: IMX420/428 (3rd Generation GS-CIS)
    - **V3Group2** (Display string: 'V3 Group 2'): Group 2: IMX421/422/429/430/437 (3rd Generation GS-CIS)
    - **V3Group3** (Display string: 'V3 Group 3'): Group 3: IMX425/432 (3rd Generation GS-CIS)
    - **V3Group4** (Display string: 'V3 Group 4'): Group 4: IMX426/433 (3rd Generation GS-CIS)
    - **V4Group1** (Display string: 'V4 Group 1'): Group 1: IMX530/540 (4th Generation GS-CIS)

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvImxSensorIdTwo = property(lib_mvIMPACT_acquire.mvCustomData_mvImxSensorIdTwo_get, doc=r"""
    An integer property. IMX SensorID2
    IMX SensorID2
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_mvCustomData

# Register mvCustomData in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.mvCustomData_swigregister(mvCustomData)

class mvLogicGateControl(ComponentCollection):
    r"""
    Category that contains features to control the devices Logic Gate Control parameters.
    A category that contains features to control the devices Logic Gate Control parameters.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::GenICam::mvLogicGateControl** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.mvLogicGateControl_swiginit(self, lib_mvIMPACT_acquire.new_mvLogicGateControl(*args))
    mvLogicGateANDSelector = property(lib_mvIMPACT_acquire.mvLogicGateControl_mvLogicGateANDSelector_get, doc=r"""
    An enumerated integer property. Selects the AND gate to configure.
    This enumeration selects the AND gate to configure.

    The following string values might be valid for this feature:
    - **mvLogicGateAND1** (Display string: 'mv Logic Gate AND 1')
    - **mvLogicGateAND2** (Display string: 'mv Logic Gate AND 2')
    - **mvLogicGateAND3** (Display string: 'mv Logic Gate AND 3')
    - **mvLogicGateAND4** (Display string: 'mv Logic Gate AND 4')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvLogicGateANDSource1 = property(lib_mvIMPACT_acquire.mvLogicGateControl_mvLogicGateANDSource1_get, doc=r"""
    An enumerated integer property. Selects the first input signal of the AND gate selected by mvLogicGateANDSelector.
    This enumeration can be used to select the first input signal of the AND gate selected by mvLogicGateANDSelector.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off')
    - **Line4** (Display string: 'Line 4')
    - **Line5** (Display string: 'Line 5')
    - **Line6** (Display string: 'Line 6')
    - **Line7** (Display string: 'Line 7')
    - **Line12** (Display string: 'Line 12')
    - **Line13** (Display string: 'Line 13')
    - **Line14** (Display string: 'Line 14')
    - **Line15** (Display string: 'Line 15')
    - **ExposureActive** (Display string: 'Exposure Active')
    - **mvExposureSensor2Active** (Display string: 'mv Exposure Sensor 2 Active')
    - **UserOutput0** (Display string: 'User Output 0')
    - **UserOutput1** (Display string: 'User Output 1')
    - **UserOutput2** (Display string: 'User Output 2')
    - **UserOutput3** (Display string: 'User Output 3')
    - **UserOutput4** (Display string: 'User Output 4')
    - **UserOutput5** (Display string: 'User Output 5')
    - **UserOutput6** (Display string: 'User Output 6')
    - **UserOutput7** (Display string: 'User Output 7')
    - **Timer1Active** (Display string: 'Timer 1 Active')
    - **Timer2Active** (Display string: 'Timer 2 Active')
    - **Timer3Active** (Display string: 'Timer 3 Active')
    - **Counter1Active** (Display string: 'Counter 1 Active')
    - **Counter2Active** (Display string: 'Counter 2 Active')
    - **Counter3Active** (Display string: 'Counter 3 Active')
    - **Counter4Active** (Display string: 'Counter 4 Active')
    - **Counter5Active** (Display string: 'Counter 5 Active')
    - **Counter6Active** (Display string: 'Counter 6 Active')
    - **Counter7Active** (Display string: 'Counter 7 Active')
    - **Counter8Active** (Display string: 'Counter 8 Active')
    - **AcquisitionActive** (Display string: 'Acquisition Active')
    - **FrameActive** (Display string: 'Frame Active')
    - **LineActive** (Display string: 'Line Active')
    - **FrameTriggerWait** (Display string: 'Frame Trigger Wait')
    - **mvTemperatureOutOfRange** (Display string: 'mv Temperature Out Of Range')
    - **mvExposureActive** (Display string: 'mv Exposure Active')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvANDSource1Inverter = property(lib_mvIMPACT_acquire.mvLogicGateControl_mvANDSource1Inverter_get, doc=r"""
    A boolean property. Inverts the first input signal of the AND gate selected by mvLogicGateANDSelector
    Inverts the first input signal of the AND gate selected by mvLogicGateANDSelector
    """)
    mvLogicGateANDSource2 = property(lib_mvIMPACT_acquire.mvLogicGateControl_mvLogicGateANDSource2_get, doc=r"""
    An enumerated integer property. Selects the second input signal of the AND gate selected by mvLogicGateANDSelector.
    This enumeration can be used to select the second input signal of the AND gate selected by mvLogicGateANDSelector.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off')
    - **Line4** (Display string: 'Line 4')
    - **Line5** (Display string: 'Line 5')
    - **Line6** (Display string: 'Line 6')
    - **Line7** (Display string: 'Line 7')
    - **Line12** (Display string: 'Line 12')
    - **Line13** (Display string: 'Line 13')
    - **Line14** (Display string: 'Line 14')
    - **Line15** (Display string: 'Line 15')
    - **ExposureActive** (Display string: 'Exposure Active')
    - **mvExposureSensor2Active** (Display string: 'mv Exposure Sensor 2 Active')
    - **UserOutput0** (Display string: 'User Output 0')
    - **UserOutput1** (Display string: 'User Output 1')
    - **UserOutput2** (Display string: 'User Output 2')
    - **UserOutput3** (Display string: 'User Output 3')
    - **UserOutput4** (Display string: 'User Output 4')
    - **UserOutput5** (Display string: 'User Output 5')
    - **UserOutput6** (Display string: 'User Output 6')
    - **UserOutput7** (Display string: 'User Output 7')
    - **Timer1Active** (Display string: 'Timer 1 Active')
    - **Timer2Active** (Display string: 'Timer 2 Active')
    - **Timer3Active** (Display string: 'Timer 3 Active')
    - **Counter1Active** (Display string: 'Counter 1 Active')
    - **Counter2Active** (Display string: 'Counter 2 Active')
    - **Counter3Active** (Display string: 'Counter 3 Active')
    - **Counter4Active** (Display string: 'Counter 4 Active')
    - **Counter5Active** (Display string: 'Counter 5 Active')
    - **Counter6Active** (Display string: 'Counter 6 Active')
    - **Counter7Active** (Display string: 'Counter 7 Active')
    - **Counter8Active** (Display string: 'Counter 8 Active')
    - **AcquisitionActive** (Display string: 'Acquisition Active')
    - **FrameActive** (Display string: 'Frame Active')
    - **LineActive** (Display string: 'Line Active')
    - **FrameTriggerWait** (Display string: 'Frame Trigger Wait')
    - **mvTemperatureOutOfRange** (Display string: 'mv Temperature Out Of Range')
    - **mvExposureActive** (Display string: 'mv Exposure Active')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvANDSource2Inverter = property(lib_mvIMPACT_acquire.mvLogicGateControl_mvANDSource2Inverter_get, doc=r"""
    A boolean property. Inverts the second input signal of the AND gate selected by mvLogicGateANDSelector
    Inverts the second input signal of the AND gate selected by mvLogicGateANDSelector
    """)
    mvLogicGateORSelector = property(lib_mvIMPACT_acquire.mvLogicGateControl_mvLogicGateORSelector_get, doc=r"""
    An enumerated integer property. Selects the OR gate to configure.
    This enumeration selects the OR gate to configure.

    The following string values might be valid for this feature:
    - **mvLogicGateOR1** (Display string: 'mv Logic Gate OR 1')
    - **mvLogicGateOR2** (Display string: 'mv Logic Gate OR 2')
    - **mvLogicGateOR3** (Display string: 'mv Logic Gate OR 3')
    - **mvLogicGateOR4** (Display string: 'mv Logic Gate OR 4')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvLogicGateORSource1 = property(lib_mvIMPACT_acquire.mvLogicGateControl_mvLogicGateORSource1_get, doc=r"""
    An enumerated integer property. Selects the first input signal of the OR gate selected by mvLogicGateORSelector.
    This enumeration can be used to select the first input signal of the OR gate selected by mvLogicGateORSelector.

    The following string values might be valid for this feature:
    - **mvLogicGateAND1Output** (Display string: 'mv Logic Gate AND 1 Output')
    - **mvLogicGateAND2Output** (Display string: 'mv Logic Gate AND 2 Output')
    - **mvLogicGateAND3Output** (Display string: 'mv Logic Gate AND 3 Output')
    - **mvLogicGateAND4Output** (Display string: 'mv Logic Gate AND 4 Output')
    - **Off** (Display string: 'Off')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvLogicGateORSource2 = property(lib_mvIMPACT_acquire.mvLogicGateControl_mvLogicGateORSource2_get, doc=r"""
    An enumerated integer property. Selects the second input signal of the OR gate selected by mvLogicGateORSelector.
    This enumeration can be used to select the second input signal of the OR gate selected by mvLogicGateORSelector.

    The following string values might be valid for this feature:
    - **mvLogicGateAND1Output** (Display string: 'mv Logic Gate AND 1 Output')
    - **mvLogicGateAND2Output** (Display string: 'mv Logic Gate AND 2 Output')
    - **mvLogicGateAND3Output** (Display string: 'mv Logic Gate AND 3 Output')
    - **mvLogicGateAND4Output** (Display string: 'mv Logic Gate AND 4 Output')
    - **Off** (Display string: 'Off')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvLogicGateORSource3 = property(lib_mvIMPACT_acquire.mvLogicGateControl_mvLogicGateORSource3_get, doc=r"""
    An enumerated integer property. Selects the third input signal of the OR gate selected by mvLogicGateORSelector.
    This enumeration can be used to select the third input signal of the OR gate selected by mvLogicGateORSelector.

    The following string values might be valid for this feature:
    - **mvLogicGateAND1Output** (Display string: 'mv Logic Gate AND 1 Output')
    - **mvLogicGateAND2Output** (Display string: 'mv Logic Gate AND 2 Output')
    - **mvLogicGateAND3Output** (Display string: 'mv Logic Gate AND 3 Output')
    - **mvLogicGateAND4Output** (Display string: 'mv Logic Gate AND 4 Output')
    - **Off** (Display string: 'Off')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvLogicGateORSource4 = property(lib_mvIMPACT_acquire.mvLogicGateControl_mvLogicGateORSource4_get, doc=r"""
    An enumerated integer property. Selects the fourth input signal of the OR gate selected by mvLogicGateORSelector.
    This enumeration can be used to select the fourth input signal of the OR gate selected by mvLogicGateORSelector.

    The following string values might be valid for this feature:
    - **mvLogicGateAND1Output** (Display string: 'mv Logic Gate AND 1 Output')
    - **mvLogicGateAND2Output** (Display string: 'mv Logic Gate AND 2 Output')
    - **mvLogicGateAND3Output** (Display string: 'mv Logic Gate AND 3 Output')
    - **mvLogicGateAND4Output** (Display string: 'mv Logic Gate AND 4 Output')
    - **Off** (Display string: 'Off')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvLogicGateSourceSelector = property(lib_mvIMPACT_acquire.mvLogicGateControl_mvLogicGateSourceSelector_get, doc=r"""
    An enumerated integer property. Selects the LogicGateSource of the AND-OR-Matrix.
    Selects the LogicGateSource of the AND-OR-Matrix.

    The following string values might be valid for this feature:
    - **mvLogicGateSource0** (Display string: 'mv Logic Gate Source 0')
    - **mvLogicGateSource1** (Display string: 'mv Logic Gate Source 1')
    - **mvLogicGateSource2** (Display string: 'mv Logic Gate Source 2')
    - **mvLogicGateSource3** (Display string: 'mv Logic Gate Source 3')
    - **mvLogicGateSource4** (Display string: 'mv Logic Gate Source 4')
    - **mvLogicGateSource5** (Display string: 'mv Logic Gate Source 5')
    - **mvLogicGateSource6** (Display string: 'mv Logic Gate Source 6')
    - **mvLogicGateSource7** (Display string: 'mv Logic Gate Source 7')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvLogicGateSource = property(lib_mvIMPACT_acquire.mvLogicGateControl_mvLogicGateSource_get, doc=r"""
    An enumerated integer property. Selects the input signal of the AND-OR-Matrix selected by mvLogicGateSourceSelector.
    Selects the input signal of the AND-OR-Matrix selected by mvLogicGateSourceSelector.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off')
    - **Line4** (Display string: 'Line 4')
    - **Line5** (Display string: 'Line 5')
    - **Line6** (Display string: 'Line 6')
    - **Line7** (Display string: 'Line 7')
    - **ExposureActive** (Display string: 'Exposure Active')
    - **mvExposureSensor2Active** (Display string: 'mv Exposure Sensor 2 Active')
    - **UserOutput0** (Display string: 'User Output 0')
    - **UserOutput1** (Display string: 'User Output 1')
    - **UserOutput2** (Display string: 'User Output 2')
    - **UserOutput3** (Display string: 'User Output 3')
    - **UserOutput4** (Display string: 'User Output 4')
    - **UserOutput5** (Display string: 'User Output 5')
    - **UserOutput6** (Display string: 'User Output 6')
    - **UserOutput7** (Display string: 'User Output 7')
    - **Timer1Active** (Display string: 'Timer 1 Active')
    - **Timer2Active** (Display string: 'Timer 2 Active')
    - **Timer3Active** (Display string: 'Timer 3 Active')
    - **Counter1Active** (Display string: 'Counter 1 Active')
    - **Counter2Active** (Display string: 'Counter 2 Active')
    - **Counter3Active** (Display string: 'Counter 3 Active')
    - **Counter4Active** (Display string: 'Counter 4 Active')
    - **Counter5Active** (Display string: 'Counter 5 Active')
    - **Counter6Active** (Display string: 'Counter 6 Active')
    - **Counter7Active** (Display string: 'Counter 7 Active')
    - **Counter8Active** (Display string: 'Counter 8 Active')
    - **AcquisitionActive** (Display string: 'Acquisition Active')
    - **FrameActive** (Display string: 'Frame Active')
    - **LineActive** (Display string: 'Line Active')
    - **FrameTriggerWait** (Display string: 'Frame Trigger Wait')
    - **mvTemperatureOutOfRange** (Display string: 'mv Temperature Out Of Range')
    - **mvExposureActive** (Display string: 'mv Exposure Active')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvLogicGateSourceInverter = property(lib_mvIMPACT_acquire.mvLogicGateControl_mvLogicGateSourceInverter_get, doc=r"""
    A boolean property. Inverts the input signal.
    Inverts the input signal.
    """)
    mvLogicGateANDTermSelector = property(lib_mvIMPACT_acquire.mvLogicGateControl_mvLogicGateANDTermSelector_get, doc=r"""
    An enumerated integer property. Selects the AND-term of the AND-OR-matrix.
    Selects the AND-term of the AND-OR-matrix.

    The following string values might be valid for this feature:
    - **mvLogicGateANDTerm0** (Display string: 'mv Logic Gate AND Term 0')
    - **mvLogicGateANDTerm1** (Display string: 'mv Logic Gate AND Term 1')
    - **mvLogicGateANDTerm2** (Display string: 'mv Logic Gate AND Term 2')
    - **mvLogicGateANDTerm3** (Display string: 'mv Logic Gate AND Term 3')
    - **mvLogicGateANDTerm4** (Display string: 'mv Logic Gate AND Term 4')
    - **mvLogicGateANDTerm5** (Display string: 'mv Logic Gate AND Term 5')
    - **mvLogicGateANDTerm6** (Display string: 'mv Logic Gate AND Term 6')
    - **mvLogicGateANDTerm7** (Display string: 'mv Logic Gate AND Term 7')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvLogicGateANDTermSrc0 = property(lib_mvIMPACT_acquire.mvLogicGateControl_mvLogicGateANDTermSrc0_get, doc=r"""
    An enumerated integer property. Selects the first input signal of the AND-term selected by mvLogicGateANDTermSelector.
    Selects the first input signal of the AND-term selected by mvLogicGateANDTermSelector.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off')
    - **mvLogicGateSource0** (Display string: 'mv Logic Gate Source 0')
    - **mvLogicGateSource1** (Display string: 'mv Logic Gate Source 1')
    - **mvLogicGateSource2** (Display string: 'mv Logic Gate Source 2')
    - **mvLogicGateSource3** (Display string: 'mv Logic Gate Source 3')
    - **mvLogicGateSource4** (Display string: 'mv Logic Gate Source 4')
    - **mvLogicGateSource5** (Display string: 'mv Logic Gate Source 5')
    - **mvLogicGateSource6** (Display string: 'mv Logic Gate Source 6')
    - **mvLogicGateSource7** (Display string: 'mv Logic Gate Source 7')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvLogicGateANDTermSrc1 = property(lib_mvIMPACT_acquire.mvLogicGateControl_mvLogicGateANDTermSrc1_get, doc=r"""
    An enumerated integer property. Selects the second input signal of the AND-term selected by mvLogicGateANDTermSelector.
    Selects the second input signal of the AND-term selected by mvLogicGateANDTermSelector.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off')
    - **mvLogicGateSource0** (Display string: 'mv Logic Gate Source 0')
    - **mvLogicGateSource1** (Display string: 'mv Logic Gate Source 1')
    - **mvLogicGateSource2** (Display string: 'mv Logic Gate Source 2')
    - **mvLogicGateSource3** (Display string: 'mv Logic Gate Source 3')
    - **mvLogicGateSource4** (Display string: 'mv Logic Gate Source 4')
    - **mvLogicGateSource5** (Display string: 'mv Logic Gate Source 5')
    - **mvLogicGateSource6** (Display string: 'mv Logic Gate Source 6')
    - **mvLogicGateSource7** (Display string: 'mv Logic Gate Source 7')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvLogicGateORTermSelector = property(lib_mvIMPACT_acquire.mvLogicGateControl_mvLogicGateORTermSelector_get, doc=r"""
    An enumerated integer property. Selects the OR-term of the AND-OR-matrix.
    Selects the OR-term of the AND-OR-matrix.

    The following string values might be valid for this feature:
    - **mvLogicGateORTerm0** (Display string: 'mv Logic Gate OR Term 0')
    - **mvLogicGateORTerm1** (Display string: 'mv Logic Gate OR Term 1')
    - **mvLogicGateORTerm2** (Display string: 'mv Logic Gate OR Term 2')
    - **mvLogicGateORTerm3** (Display string: 'mv Logic Gate OR Term 3')
    - **mvLogicGateORTerm4** (Display string: 'mv Logic Gate OR Term 4')
    - **mvLogicGateORTerm5** (Display string: 'mv Logic Gate OR Term 5')
    - **mvLogicGateORTerm6** (Display string: 'mv Logic Gate OR Term 6')
    - **mvLogicGateORTerm7** (Display string: 'mv Logic Gate OR Term 7')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvLogicGateORTermSrc0 = property(lib_mvIMPACT_acquire.mvLogicGateControl_mvLogicGateORTermSrc0_get, doc=r"""
    An enumerated integer property. Selects the first input signal of the ORTerm selected by mvLogicGateORTermSelector.
    Selects the first input signal of the ORTerm selected by mvLogicGateORTermSelector.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off')
    - **mvLogicGateANDTerm0** (Display string: 'mv Logic Gate AND Term 0')
    - **mvLogicGateANDTerm1** (Display string: 'mv Logic Gate AND Term 1')
    - **mvLogicGateANDTerm2** (Display string: 'mv Logic Gate AND Term 2')
    - **mvLogicGateANDTerm3** (Display string: 'mv Logic Gate AND Term 3')
    - **mvLogicGateANDTerm4** (Display string: 'mv Logic Gate AND Term 4')
    - **mvLogicGateANDTerm5** (Display string: 'mv Logic Gate AND Term 5')
    - **mvLogicGateANDTerm6** (Display string: 'mv Logic Gate AND Term 6')
    - **mvLogicGateANDTerm7** (Display string: 'mv Logic Gate AND Term 7')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvLogicGateORTermSrc1 = property(lib_mvIMPACT_acquire.mvLogicGateControl_mvLogicGateORTermSrc1_get, doc=r"""
    An enumerated integer property. Selects the second input signal of the ORTerm selected by mvLogicGateORTermSelector.
    Selects the second input signal of the ORTerm selected by mvLogicGateORTermSelector.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off')
    - **mvLogicGateANDTerm0** (Display string: 'mv Logic Gate AND Term 0')
    - **mvLogicGateANDTerm1** (Display string: 'mv Logic Gate AND Term 1')
    - **mvLogicGateANDTerm2** (Display string: 'mv Logic Gate AND Term 2')
    - **mvLogicGateANDTerm3** (Display string: 'mv Logic Gate AND Term 3')
    - **mvLogicGateANDTerm4** (Display string: 'mv Logic Gate AND Term 4')
    - **mvLogicGateANDTerm5** (Display string: 'mv Logic Gate AND Term 5')
    - **mvLogicGateANDTerm6** (Display string: 'mv Logic Gate AND Term 6')
    - **mvLogicGateANDTerm7** (Display string: 'mv Logic Gate AND Term 7')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_mvLogicGateControl

# Register mvLogicGateControl in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.mvLogicGateControl_swigregister(mvLogicGateControl)

class mvCurrentControl(ComponentCollection):
    r"""
    Category that contains features to control the devices Current Control parameters.
    A category that contains features to control the devices Current Control parameters.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::GenICam::mvCurrentControl** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.mvCurrentControl_swiginit(self, lib_mvIMPACT_acquire.new_mvCurrentControl(*args))
    mvCurrentSelector = property(lib_mvIMPACT_acquire.mvCurrentControl_mvCurrentSelector_get, doc=r"""
    An enumerated integer property. Selects the current source to configure.
    Selects the current source to configure.

    The following string values might be valid for this feature:
    - **Current0** (Display string: 'Current 0')
    - **Current1** (Display string: 'Current 1')
    - **Current2** (Display string: 'Current 2')
    - **Current3** (Display string: 'Current 3')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvCurrent = property(lib_mvIMPACT_acquire.mvCurrentControl_mvCurrent_get, doc=r"""
    An integer property. Sets the current value for the selected device(e.g.: LED).
    Sets the current value for the selected device(e.g.: LED).
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_mvCurrentControl

# Register mvCurrentControl in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.mvCurrentControl_swigregister(mvCurrentControl)

class mvLensControl(ComponentCollection):
    r"""
    Contains features to control motorized lenses
    Contains features to control motorized lenses.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::GenICam::mvLensControl** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.mvLensControl_swiginit(self, lib_mvIMPACT_acquire.new_mvLensControl(*args))
    mvIrisType = property(lib_mvIMPACT_acquire.mvLensControl_mvIrisType_get, doc=r"""
    An enumerated integer property. Sets the iris type.
    Sets the iris type.

    The following string values might be valid for this feature:
    - **mvVideoIris** (Display string: 'mv Video Iris')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvIrisMode = property(lib_mvIMPACT_acquire.mvLensControl_mvIrisMode_get, doc=r"""
    An enumerated integer property. Sets the iris operating mode.
    Sets the iris operating mode.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off'): No iris adjustment will be done.
    - **mvIrisAuto** (Display string: 'mv Iris Auto'): The iris adjustment will be done automatically by evaluating the current image data.
    - **mvIrisOpen** (Display string: 'mv Iris Open'): The iris is fully open.
    - **mvIrisClose** (Display string: 'mv Iris Close'): The iris is fully closed.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvIrisSignalLevelMin = property(lib_mvIMPACT_acquire.mvLensControl_mvIrisSignalLevelMin_get, doc=r"""
    An integer property. Sets the minimum iris signal level in mV.
    Sets the minimum iris signal level in mV.
    """)
    mvIrisSignalLevelMax = property(lib_mvIMPACT_acquire.mvLensControl_mvIrisSignalLevelMax_get, doc=r"""
    An integer property. Sets the maximum iris signal level in mV.
    Sets the maximum iris signal level in mV.
    """)
    mvDriveSelector = property(lib_mvIMPACT_acquire.mvLensControl_mvDriveSelector_get, doc=r"""
    An enumerated integer property. Selects the lens drive that should be adjusted.
    Selects the lens drive that should be adjusted.

    The following string values might be valid for this feature:
    - **mvFocus** (Display string: 'mv Focus'): Selects the motor to control the focus.
    - **mvZoom** (Display string: 'mv Zoom'): Selects the motor to control the zoom.
    - **mvIris** (Display string: 'mv Iris'): Selects the motor to control the iris.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvDriveForward = property(lib_mvIMPACT_acquire.mvLensControl_mvDriveForward_get, doc=r"""
    A method object. Generates a pulse defined by 'mvDriveDuration' and 'mvDriveLevel' to move the selected motor in forward direction.
    Generates a pulse defined by 'mvDriveDuration' and 'mvDriveLevel' to move the selected motor in forward direction.
    """)
    mvDriveBackward = property(lib_mvIMPACT_acquire.mvLensControl_mvDriveBackward_get, doc=r"""
    A method object. Generates a pulse defined by 'mvDriveDuration' and 'mvDriveLevel' to move the selected motor in backward direction.
    Generates a pulse defined by 'mvDriveDuration' and 'mvDriveLevel' to move the selected motor in backward direction.
    """)
    mvDriveDuration = property(lib_mvIMPACT_acquire.mvLensControl_mvDriveDuration_get, doc=r"""
    An integer property. Sets the duration of the drive command in us.
    Sets the duration of the drive command in us.
    """)
    mvDriveLevel = property(lib_mvIMPACT_acquire.mvLensControl_mvDriveLevel_get, doc=r"""
    An integer property. Sets the voltage level of the drive command in mV.
    Sets the voltage level of the drive command in mV.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_mvLensControl

# Register mvLensControl in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.mvLensControl_swigregister(mvLensControl)

class mvFFCControl(ComponentCollection):
    r"""
    Contains features to control the devices Flat Field Correction parameters.
    Contains features to control the devices Flat Field Correction parameters.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::GenICam::mvFFCControl** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.mvFFCControl_swiginit(self, lib_mvIMPACT_acquire.new_mvFFCControl(*args))
    mvFFCEnable = property(lib_mvIMPACT_acquire.mvFFCControl_mvFFCEnable_get, doc=r"""
    A boolean property. Enables the Flat Field Correction.
    Enables the Flat Field Correction.
    """)
    mvFFCCalibrationImageCount = property(lib_mvIMPACT_acquire.mvFFCControl_mvFFCCalibrationImageCount_get, doc=r"""
    An integer property. The number of images to use for the calculation of the correction image.
    The number of images to use for the calculation of the correction image.
    """)
    mvFFCCalibrate = property(lib_mvIMPACT_acquire.mvFFCControl_mvFFCCalibrate_get, doc=r"""
    A method object. Starts the Calibration of the Flat Field Correction.
    Starts the Calibration of the Flat Field Correction.
    """)
    mvFFCImageLoad = property(lib_mvIMPACT_acquire.mvFFCControl_mvFFCImageLoad_get, doc=r"""
    A method object. Loads the Flat Field Correction image from flash.
    Loads the Flat Field Correction image from flash.
    """)
    mvFFCImageSave = property(lib_mvIMPACT_acquire.mvFFCControl_mvFFCImageSave_get, doc=r"""
    A method object. Saves the calibrated Flat Field Correction image to flash.
    Saves the calibrated Flat Field Correction image to flash.
    """)
    mvFFCAutoLoadMode = property(lib_mvIMPACT_acquire.mvFFCControl_mvFFCAutoLoadMode_get, doc=r"""
    An enumerated integer property. Selects whether FFC image shall be automatically loaded at camera startup.
    Selects whether FFC image shall be automatically loaded at camera startup.

    The following string values might be valid for this feature:
    - **mvLegacy** (Display string: 'mv Legacy'): )
    - **Off** (Display string: 'Off'): FFC image will not be automatically loaded at startup. Use this for short boot times.
    - **On** (Display string: 'On'): FFC image will be automatically loaded at startup. Boot time will increase accordingly.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_mvFFCControl

# Register mvFFCControl in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.mvFFCControl_swigregister(mvFFCControl)

class mvFrameAverageControl(ComponentCollection):
    r"""
    Category that contains features to control the frame averaging engine.
    A category that contains features to control the frame averaging engine.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::GenICam::mvFrameAverageControl** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.mvFrameAverageControl_swiginit(self, lib_mvIMPACT_acquire.new_mvFrameAverageControl(*args))
    mvFrameAverageMode = property(lib_mvIMPACT_acquire.mvFrameAverageControl_mvFrameAverageMode_get, doc=r"""
    An enumerated integer property. Sets the frame average operating mode.
    Sets the frame average operating mode.

    The following string values might be valid for this feature:
    - **mvPlain** (Display string: 'mv Plain')
    - **mvDynamic** (Display string: 'mv Dynamic')
    - **mvNTo1** (Display string: 'mv N To 1')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvFrameAverageEnable = property(lib_mvIMPACT_acquire.mvFrameAverageControl_mvFrameAverageEnable_get, doc=r"""
    A boolean property. Enables the frame averaging engine.
    Enables the frame averaging engine.
    """)
    mvFrameAverageSlope = property(lib_mvIMPACT_acquire.mvFrameAverageControl_mvFrameAverageSlope_get, doc=r"""
    An integer property. Here you specify the noise border for very dark pictures.
    Here you specify the noise border for very dark pictures.
    """)
    mvFrameAverageDynamicMode = property(lib_mvIMPACT_acquire.mvFrameAverageControl_mvFrameAverageDynamicMode_get, doc=r"""
    An enumerated integer property. Sets the frame average dynamic operating mode.
    Sets the frame average dynamic operating mode.

    The following string values might be valid for this feature:
    - **mvStandard** (Display string: 'mv Standard')
    - **mvGauss** (Display string: 'mv Gauss')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvFrameAverageNoiseLimit = property(lib_mvIMPACT_acquire.mvFrameAverageControl_mvFrameAverageNoiseLimit_get, doc=r"""
    An integer property. Here you specify the noise limit for very bright pictures.
    Here you specify the noise limit for very bright pictures.
    """)
    mvFrameAverageNoiseGain = property(lib_mvIMPACT_acquire.mvFrameAverageControl_mvFrameAverageNoiseGain_get, doc=r"""
    An integer property. Here you specify the noise border for very bright pictures.
    Here you specify the noise border for very bright pictures.
    """)
    mvFrameAverageFrameCount = property(lib_mvIMPACT_acquire.mvFrameAverageControl_mvFrameAverageFrameCount_get, doc=r"""
    An integer property. Here you specify the frame count used for the calculation of the frame average.
    Here you specify the frame count used for the calculation of the frame average.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_mvFrameAverageControl

# Register mvFrameAverageControl in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.mvFrameAverageControl_swigregister(mvFrameAverageControl)

class mvHDRControl(ComponentCollection):
    r"""
    Category that contains features to control the devices High Dynamic Range parameters.
    A category that contains features to control the devices High Dynamic Range parameters.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::GenICam::mvHDRControl** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.mvHDRControl_swiginit(self, lib_mvIMPACT_acquire.new_mvHDRControl(*args))
    mvHDREnable = property(lib_mvIMPACT_acquire.mvHDRControl_mvHDREnable_get, doc=r"""
    A boolean property. Enables the High Dynamic Range Feature.
    Enables the High Dynamic Range Feature.
    """)
    mvHDRPreset = property(lib_mvIMPACT_acquire.mvHDRControl_mvHDRPreset_get, doc=r"""
    An enumerated integer property. Selects the HDR parameter set.
    Selects the HDR parameter set.

    The following string values might be valid for this feature:
    - **mvDualKneePoint0** (Display string: 'mv Dual Knee Point 0')
    - **mvDualKneePoint1** (Display string: 'mv Dual Knee Point 1')
    - **mvDualKneePoint2** (Display string: 'mv Dual Knee Point 2')
    - **mvDualKneePoint3** (Display string: 'mv Dual Knee Point 3')
    - **mvDualKneePoint4** (Display string: 'mv Dual Knee Point 4')
    - **mvDualKneePoint5** (Display string: 'mv Dual Knee Point 5')
    - **mvDualKneePoint6** (Display string: 'mv Dual Knee Point 6')
    - **mvDualKneePointUser** (Display string: 'mv Dual Knee Point User')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvHDRSelector = property(lib_mvIMPACT_acquire.mvHDRControl_mvHDRSelector_get, doc=r"""
    An enumerated integer property. Selects the HDR parameter set to configure.
    This enumeration selects the HDR parameter set to configure.

    The following string values might be valid for this feature:
    - **mvDualKneePoint0** (Display string: 'mv Dual Knee Point 0')
    - **mvDualKneePoint1** (Display string: 'mv Dual Knee Point 1')
    - **mvDualKneePoint2** (Display string: 'mv Dual Knee Point 2')
    - **mvDualKneePoint3** (Display string: 'mv Dual Knee Point 3')
    - **mvDualKneePoint4** (Display string: 'mv Dual Knee Point 4')
    - **mvDualKneePoint5** (Display string: 'mv Dual Knee Point 5')
    - **mvDualKneePoint6** (Display string: 'mv Dual Knee Point 6')
    - **mvDualKneePointUser** (Display string: 'mv Dual Knee Point User')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvHDRVoltage1 = property(lib_mvIMPACT_acquire.mvHDRControl_mvHDRVoltage1_get, doc=r"""
    An integer property. First HDR Voltage in mV.
    First HDR Voltage in mV.
    """)
    mvHDRVoltage2 = property(lib_mvIMPACT_acquire.mvHDRControl_mvHDRVoltage2_get, doc=r"""
    An integer property. Second HDR Voltage in mV.
    Second HDR Voltage in mV.
    """)
    mvHDRExposure1 = property(lib_mvIMPACT_acquire.mvHDRControl_mvHDRExposure1_get, doc=r"""
    An integer property. First HDR Exposure in ppm.
    First HDR Exposure in ppm.
    """)
    mvHDRExposure2 = property(lib_mvIMPACT_acquire.mvHDRControl_mvHDRExposure2_get, doc=r"""
    An integer property. Second HDR Exposure in ppm.
    Second HDR Exposure in ppm.
    """)
    mvHDRExposureRatio = property(lib_mvIMPACT_acquire.mvHDRControl_mvHDRExposureRatio_get, doc=r"""
    An enumerated integer property. T1/T2 Exposure Ratio
    The ratio of the long exposure time to the short exposure time.

    The following string values might be valid for this feature:
    - **mvRatio4x** (Display string: 'mv Ratio 4x')
    - **mvRatio8x** (Display string: 'mv Ratio 8x')
    - **mvRatio16x** (Display string: 'mv Ratio 16x')
    - **mvRatio32x** (Display string: 'mv Ratio 32x')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvHDRMotionCompensationEnable = property(lib_mvIMPACT_acquire.mvHDRControl_mvHDRMotionCompensationEnable_get, doc=r"""
    A boolean property. Enables motion compensation
    Enables motion compensation. Recommended for scenes with a lot of motion.
    """)
    mvHDRAdaptiveLocalToneMappingEnable = property(lib_mvIMPACT_acquire.mvHDRControl_mvHDRAdaptiveLocalToneMappingEnable_get, doc=r"""
    A boolean property. Enables Adaptive Local Tone Mapping
    Enables Adaptive Local Tone Mapping. Recommended if mvHDRMotionCompensationEnable is enabled.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_mvHDRControl

# Register mvHDRControl in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.mvHDRControl_swigregister(mvHDRControl)

class SystemModule(ComponentCollection):
    r"""
    Category that contains items that belong to the system module of the transport layer.
    The System category contains items that belong to the system module of the transport layer.
    """

    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"""
        *Overload 1:*
         Constructs a new **mvIMPACT::acquire::GenICam::SystemModule** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type index: int
        :param index: [in] The *index* of the instance this object shall be created for. Passing an invalid index will raise an exception.

        |

        *Overload 2:*
         Constructs a new **mvIMPACT::acquire::GenICam::SystemModule** object.
         Since: 2.17.0

        :type index: int
        :param index: [in] The *index* of the instance this object shall be created for. Passing an invalid index will raise an exception.

        |

        *Overload 3:*
         Constructs a new **mvIMPACT::acquire::GenICam::SystemModule** object.
         Since: 2.17.0

        :param index: [in] The *index* of the instance this object shall be created for. Passing an invalid index will raise an exception.
        """
        lib_mvIMPACT_acquire.SystemModule_swiginit(self, lib_mvIMPACT_acquire.new_SystemModule(*args))
    TLVendorName = property(lib_mvIMPACT_acquire.SystemModule_TLVendorName_get, doc=r"""
    A string property. Indicates the name of the transport layer vendor.
    This is a read only element. It is a string that indicates the name of the transport layer vendor.
    """)
    TLModelName = property(lib_mvIMPACT_acquire.SystemModule_TLModelName_get, doc=r"""
    A string property. Indicates the name of the transport layer Model.
    This is a read only element. It is a string that indicates the name of the transport layer Model to distinguish different kinds of GenTL Producer implementations from one vendor.
    """)
    TLID = property(lib_mvIMPACT_acquire.SystemModule_TLID_get, doc=r"""
    A string property. Indicates the ID of the transport layer.
    This is a read only element. It is a string that indicates the ID of the transport layer.
    """)
    TLVersion = property(lib_mvIMPACT_acquire.SystemModule_TLVersion_get, doc=r"""
    A string property. Indicates a vendor specific version string for this transport layer.
    This is a read only element. It is a string that indicates a vendor specific version string for this transport layer.
    """)
    TLFileName = property(lib_mvIMPACT_acquire.SystemModule_TLFileName_get, doc=r"""
    A string property. Indicates the file name of the GenTL Producer driver including name and extension.
    This is a read only element. It is a string that indicates the file name of the GenTL Producer driver including name and extension.
    """)
    TLDisplayName = property(lib_mvIMPACT_acquire.SystemModule_TLDisplayName_get, doc=r"""
    A string property. User readable name of the GenTL Producer.
    This is a read only element. It is a string that indicates a user readable name of the GenTL Producer.
    """)
    TLPath = property(lib_mvIMPACT_acquire.SystemModule_TLPath_get, doc=r"""
    A string property. Indicates the full path to the GenTL Producer driver including name and extension.
    This is a read only element. It is a string that indicates the full path to the GenTL Producer driver including name and extension.
    """)
    TLType = property(lib_mvIMPACT_acquire.SystemModule_TLType_get, doc=r"""
    An enumerated integer property. Identifies the transport layer technology of the GenTL Producer implementation.
    This is a read only feature. This enumeration provides a value that indicates the transport layer technology of the GenTL Producer implementation.

    The following string values might be valid for this feature:
    - **Mixed** (Display string: 'Mixed'): This enumeration value indicates that this is a transport layer for a mixed protocol.
    - **Custom** (Display string: 'Custom'): This enumeration value indicates that this is a transport layer for a custom protocol.
    - **GEV** (Display string: 'GigE Vision'): This enumeration value indicates that this is a transport layer for the GigE Vision protocol.
    - **CameraLink** (Display string: 'CameraLink'): This enumeration value indicates that this is a transport layer for the CameraLink protocol.
    - **CoaXPress** (Display string: 'CoaXPress'): This enumeration value indicates that this is a transport layer for the CoaXPress protocol.
    - **CameraLinkHS** (Display string: 'CameraLink HS'): This enumeration value indicates that this is a transport layer for the CameraLink HS protocol.
    - **U3V** (Display string: 'USB3 Vision'): This enumeration value indicates that this is a transport layer for the USB3 Vision protocol.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    genTLVersionMajor = property(lib_mvIMPACT_acquire.SystemModule_genTLVersionMajor_get, doc=r"""
    An integer property. Defines the major version number of the GenTL specification the GenTL Producer implementation complies with.
    This is a read only element. It defines the major version number of the GenTL specification the GenTL Producer implementation complies with.
    """)
    genTLVersionMinor = property(lib_mvIMPACT_acquire.SystemModule_genTLVersionMinor_get, doc=r"""
    An integer property. Defines the minor version number of the GenTL specification the GenTL Producer implementation complies with.
    This is a read only element. It defines the minor version number of the GenTL specification the GenTL Producer implementation complies with.
    """)
    genTLSFNCVersionMajor = property(lib_mvIMPACT_acquire.SystemModule_genTLSFNCVersionMajor_get, doc=r"""
    An integer property. Defines the major version number of the GenTL SFNC specification the GenTL Producer implementation complies with.
    This is a read only element. It defines the major version number of the GenTL SFNC specification the GenTL Producer implementation complies with.
    """)
    genTLSFNCVersionMinor = property(lib_mvIMPACT_acquire.SystemModule_genTLSFNCVersionMinor_get, doc=r"""
    An integer property. Defines the minor version number of the GenTL SFNC specification the GenTL Producer implementation complies with.
    This is a read only element. It defines the minor version number of the GenTL SFNC specification the GenTL Producer implementation complies with.
    """)
    genTLSFNCVersionSubMinor = property(lib_mvIMPACT_acquire.SystemModule_genTLSFNCVersionSubMinor_get, doc=r"""
    An integer property. Defines the sub minor version number of the GenTL SFNC specification the GenTL Producer implementation complies with.
    This is a read only element. It defines the sub minor version number of the GenTL SFNC specification the GenTL Producer implementation complies with.
    """)
    genCPVersionMajor = property(lib_mvIMPACT_acquire.SystemModule_genCPVersionMajor_get, doc=r"""
    An integer property. Indicates the major version number of the GenCP specification this GenTL Producer implementation complies with.
    This is a read only element. It indicates the major version number of the GenCP specification this GenTL Producer implementation complies with.
    """)
    genCPVersionMinor = property(lib_mvIMPACT_acquire.SystemModule_genCPVersionMinor_get, doc=r"""
    An integer property. Indicates the minor version number of the GenCP specification this GenTL Producer implementation complies with.
    This is a read only element. It indicates the minor version number of the GenCP specification this GenTL Producer implementation complies with.
    """)
    gevVersionMajor = property(lib_mvIMPACT_acquire.SystemModule_gevVersionMajor_get, doc=r"""
    An integer property. Indicates the major version number of the GigE Vision specification this GenTL Producer implementation complies with.
    This is a read only element. It indicates the major version number of the GigE Vision specification this GenTL Producer implementation complies with.
    """)
    gevVersionMinor = property(lib_mvIMPACT_acquire.SystemModule_gevVersionMinor_get, doc=r"""
    An integer property. Indicates the minor version number of the GigE Vision specification this GenTL Producer implementation complies with.
    This is a read only element. It indicates the minor version number of the GigE Vision specification this GenTL Producer implementation complies with.
    """)
    u3vVersionMajor = property(lib_mvIMPACT_acquire.SystemModule_u3vVersionMajor_get, doc=r"""
    An integer property. Indicates the major version number of the USB3 Vision specification this GenTL Producer implementation complies with.
    This is a read only element. It indicates the major version number of the USB3 Vision specification this GenTL Producer implementation complies with.
    """)
    u3vVersionMinor = property(lib_mvIMPACT_acquire.SystemModule_u3vVersionMinor_get, doc=r"""
    An integer property. Indicates the minor version number of the USB3 Vision specification this GenTL Producer implementation complies with.
    This is a read only element. It indicates the minor version number of the USB3 Vision specification this GenTL Producer implementation complies with.
    """)
    mvGevChannelDummyPacketSendEnable = property(lib_mvIMPACT_acquire.SystemModule_mvGevChannelDummyPacketSendEnable_get, doc=r"""
    A boolean property. Enables or disables the periodical sending of dummy packets to a stream or message channel source port of a GigE Vision device.
    Enables or disables the periodical sending of dummy packets to a stream or message channel source port of a GigE Vision device. This might be useful to overcome firewall related problems when working with network devices.
    """)
    mvGevChannelDummyPacketSendInterval = property(lib_mvIMPACT_acquire.SystemModule_mvGevChannelDummyPacketSendInterval_get, doc=r"""
    An integer property. Defines the period(in ms) for sending dummy packets to a stream or message channel source port of a GigE Vision device.
    Defines the period(in ms) for sending dummy packets to a stream or message channel source port of a GigE Vision device. This might be useful to overcome firewall related problems when working with network devices.
    """)
    mvInterfaceTechnologyToIgnoreSelector = property(lib_mvIMPACT_acquire.SystemModule_mvInterfaceTechnologyToIgnoreSelector_get, doc=r"""
    An enumerated integer property. Selects the interface technology type that should be ignored when updating the device list.
    Selects the interface technology type that should be ignored when updating the device list.

    The following string values might be valid for this feature:
    - **Mixed** (Display string: 'Mixed')
    - **Custom** (Display string: 'Custom')
    - **GEV** (Display string: 'GigE Vision')
    - **CameraLink** (Display string: 'CameraLink')
    - **CoaXPress** (Display string: 'CoaXPress')
    - **CameraLinkHS** (Display string: 'CameraLink HS')
    - **U3V** (Display string: 'USB3 Vision')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvInterfaceTechnologyToIgnoreEnable = property(lib_mvIMPACT_acquire.SystemModule_mvInterfaceTechnologyToIgnoreEnable_get, doc=r"""
    A boolean property. When enabled, the selected interface technology type is ignored when updating the device list.
    When enabled, the selected interface technology type is ignored when updating the device list.
    """)
    interfaceUpdateList = property(lib_mvIMPACT_acquire.SystemModule_interfaceUpdateList_get, doc=r"""
    A method object. Updates the internal interface list.
    This command updates the internal interface list of this transport layer.
    """)
    interfaceUpdateTimeout = property(lib_mvIMPACT_acquire.SystemModule_interfaceUpdateTimeout_get, doc=r"""
    An integer property. Specifies timeout for the InterfaceUpdateList Command.
    Specifies timeout for the InterfaceUpdateList Command.
    """)
    interfaceSelector = property(lib_mvIMPACT_acquire.SystemModule_interfaceSelector_get, doc=r"""
    An integer property. Selector for the different GenTL Producer interfaces.
    Selector for the different GenTL Producer interfaces. Selector for the different GenTL Producer interfaces. This interface list only changes on execution of InterfaceUpdateList. The selector is 0-based in order to match the index of the C interface.
    """)
    interfaceID = property(lib_mvIMPACT_acquire.SystemModule_interfaceID_get, doc=r"""
    A string property. GenTL producer wide unique identifier of the selected interface.
    This is a read only element. It is a string that indicates a GenTL producer wide unique identifier of the selected interface.
    """)
    interfaceDisplayName = property(lib_mvIMPACT_acquire.SystemModule_interfaceDisplayName_get, doc=r"""
    A string property. A user-friendly name of the Interface.
    This is a read only element. It is a string that indicates a  user-friendly name of the Interface.
    """)
    interfaceType = property(lib_mvIMPACT_acquire.SystemModule_interfaceType_get, doc=r"""
    An enumerated integer property. Identifies the interfaces technology of the GenTL Producer implementation.
    This is a read only feature. This enumeration provides a value that indicates interfaces technology of the GenTL Producer implementation.

    The following string values might be valid for this feature:
    - **Mixed** (Display string: 'Mixed'): This enumeration value indicates that this is an interface for a mixed protocol.
    - **Custom** (Display string: 'Custom'): This enumeration value indicates that this is an interface for a custom protocol.
    - **GEV** (Display string: 'GigE Vision'): This enumeration value indicates that this is an interface for the GigE Vision protocol.
    - **CameraLink** (Display string: 'CameraLink'): This enumeration value indicates that this is an interface for the CameraLink protocol.
    - **CoaXPress** (Display string: 'CoaXPress'): This enumeration value indicates that this is an interface for the CoaXPress protocol.
    - **CameraLinkHS** (Display string: 'CameraLink HS'): This enumeration value indicates that this is an interface for the CameraLink HS protocol.
    - **U3V** (Display string: 'USB3 Vision'): This enumeration value indicates that this is an interface for the USB3 Vision protocol.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    gevInterfaceMACAddress = property(lib_mvIMPACT_acquire.SystemModule_gevInterfaceMACAddress_get, doc=r"""
    An integer property. Indicates the 48-bit MAC address of the selected interface.
    This is a read only element. It indicates the 48-bit MAC address of the selected interface.
    """)
    gevInterfaceDefaultIPAddress = property(lib_mvIMPACT_acquire.SystemModule_gevInterfaceDefaultIPAddress_get, doc=r"""
    An integer property. Indicates the IP address of the first subnet of the selected interface.
    This is a read only element. It indicates the IP address of the first subnet of the selected interface.
    """)
    gevInterfaceDefaultSubnetMask = property(lib_mvIMPACT_acquire.SystemModule_gevInterfaceDefaultSubnetMask_get, doc=r"""
    An integer property. Indicates the subnet mask of the first subnet of the selected interface.
    This is a read only element. It indicates the subnet mask of the first subnet of the selected interface.
    """)
    gevInterfaceDefaultGateway = property(lib_mvIMPACT_acquire.SystemModule_gevInterfaceDefaultGateway_get, doc=r"""
    An integer property. Indicates the default gateway of the first subnet of the selected interface.
    This is a read only element. It indicates the default gateway of the first subnet of the selected interface.
    """)
    mvGevInterfaceMTU = property(lib_mvIMPACT_acquire.SystemModule_mvGevInterfaceMTU_get, doc=r"""
    An integer property. Indicates the MTU of the selected interface.
    This is a read only element. It indicates the MTU(Maximum Transmission Unit) of the selected interface.
    """)
    mvGevInterfaceLinkSpeed = property(lib_mvIMPACT_acquire.SystemModule_mvGevInterfaceLinkSpeed_get, doc=r"""
    An integer property. Indicates the link speed of this interface.
    This is a read only element. It indicates the link speed(in Mbits per second) of this interface.
    """)
    mvDeviceUpdateListBehaviour = property(lib_mvIMPACT_acquire.SystemModule_mvDeviceUpdateListBehaviour_get, doc=r"""
    An enumerated integer property. Defines the behavior of the interface when the device list is being updated.
    Defines the behavior of the interface when the device list is being updated.

    The following string values might be valid for this feature:
    - **NotConfigured** (Display string: 'Not Configured'): Interface will enumerate devices or not according to the general enumeration behavior of this interface type(according to mvInterfaceTechnologyToIgnoreEnable setting).
    - **ForceIgnore** (Display string: 'Force Ignore'): Interface will not enumerate devices, regardless of the the general enumeration behavior of this interface type(overrides mvInterfaceTechnologyToIgnoreEnable setting).
    - **ForceEnumerate** (Display string: 'Force Enumerate'): Interface will forcefully enumerate devices, regardless of the the general enumeration behavior of this interface type(overrides mvInterfaceTechnologyToIgnoreEnable setting).

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    eventSelector = property(lib_mvIMPACT_acquire.SystemModule_eventSelector_get, doc=r"""
    An enumerated integer property. Selects which Event to signal to the host application.
    Selects which Event to signal to the host application.

    The following string values might be valid for this feature:
    - **AcquisitionTrigger** (Display string: 'Acquisition Trigger'): Device just received a trigger for the Acquisition of one or many Frames.
    - **AcquisitionTriggerMissed** (Display string: 'Acquisition Trigger Missed'): Device just missed a trigger for the Acquisition of one or many Frames.
    - **AcquisitionStart** (Display string: 'Acquisition Start'): Device just started the Acquisition of one or many Frames.
    - **AcquisitionEnd** (Display string: 'Acquisition End'): Device just completed the Acquisition of one or many Frames.
    - **AcquisitionTransferStart** (Display string: 'Acquisition Transfer Start'): Device just started the transfer of one or many Frames.
    - **AcquisitionTransferEnd** (Display string: 'Acquisition Transfer End'): Device just completed the transfer of one or many Frames.
    - **AcquisitionError** (Display string: 'Acquisition Error'): Device just detected an error during the active Acquisition.
    - **FrameBurstStart** (Display string: 'Frame Burst Start'): Device just started the capture of a burst of Frames.
    - **FrameBurstEnd** (Display string: 'Frame Burst End'): Device just completed the capture of a burst of Frames.
    - **FrameTrigger** (Display string: 'Frame Trigger'): Device just received a trigger to start the capture of one Frame.
    - **FrameTriggerMissed** (Display string: 'Frame Trigger Missed'): Device just missed a trigger to start the capture of one Frame.
    - **FrameStart** (Display string: 'Frame Start'): Device just started the capture of one Frame.
    - **FrameEnd** (Display string: 'Frame End'): Device just completed the capture of one Frame.
    - **FrameTransferStart** (Display string: 'Frame Transfer Start'): Device just started the transfer of one Frame.
    - **FrameTransferEnd** (Display string: 'Frame Transfer End'): Device just completed the transfer of one Frame.
    - **LineTrigger** (Display string: 'Line Trigger'): Device just received a trigger to start the capture of one Line.
    - **LineTriggerMissed** (Display string: 'Line Trigger Missed'): Device just missed a trigger to start the capture of one Line.
    - **LineStart** (Display string: 'Line Start'): Device just started the capture of one Line.
    - **LineEnd** (Display string: 'Line End'): Device just completed the capture of one Line.
    - **ExposureStart** (Display string: 'Exposure Start'): Device just started the exposure of one Frame (or Line).
    - **ExposureEnd** (Display string: 'Exposure End'): Device just completed the exposure of one Frame (or Line).
    - **Stream0TransferStart** (Display string: 'Stream 0 Transfer Start'): Device just started the transfer of one or many Blocks.
    - **Stream0TransferEnd** (Display string: 'Stream 0 Transfer End'): Device just completed the transfer of one or many Blocks.
    - **Stream0TransferPause** (Display string: 'Stream 0 Transfer Pause'): Device just paused the transfer.
    - **Stream0TransferResume** (Display string: 'Stream 0 Transfer Resume'): Device just resumed the transfer.
    - **Stream0TransferBlockStart** (Display string: 'Stream 0 Transfer Block Start'): Device just started the transfer of one Block.
    - **Stream0TransferBlockEnd** (Display string: 'Stream 0 Transfer Block End'): Device just completed the transfer of one Block.
    - **Stream0TransferBlockTrigger** (Display string: 'Stream 0 Transfer Block Trigger'): Device just received a trigger to start the transfer of one Block.
    - **Stream0TransferBurstStart** (Display string: 'Stream 0 Transfer Burst Start'): Device just started the transfer of a burst of Blocks.
    - **Stream0TransferBurstEnd** (Display string: 'Stream 0 Transfer Burst End'): Device just completed the transfer of a burst of Blocks.
    - **Stream0TransferOverflow** (Display string: 'Stream 0 Transfer Overflow'): Device transfer queue overflowed.
    - **SequencerSetChange** (Display string: 'Sequencer Set Change'): Device sequencer set has changed.
    - **Counter0Start** (Display string: 'Counter 0 Start'): The event will be generated when counter 0 starts counting.
    - **Counter1Start** (Display string: 'Counter 1 Start'): The event will be generated when counter 1 starts counting.
    - **Counter**#2#Start (Display string: 'Counter #2# Start'): The event will be generated when counter #2# starts counting.
    - **Counter0End** (Display string: 'Counter 0 End'): The event will be generated when counter 0 ends counting.
    - **Counter1End** (Display string: 'Counter 1 End'): The event will be generated when counter 1 ends counting.
    - **Counter**#2#End (Display string: 'Counter #2# End'): The event will be generated when counter #2# ends counting.
    - **Timer0Start** (Display string: 'Timer 0 Start'): The event will be generated when Timer 0 starts counting.
    - **Timer1Start** (Display string: 'Timer 1 Start'): The event will be generated when Timer 1 starts counting.
    - **Timer**#2#Start (Display string: 'Timer #2# Start'): The event will be generated when Timer #2# starts counting.
    - **Timer0End** (Display string: 'Timer 0 End'): The event will be generated when Timer 0 ends counting.
    - **Timer1End** (Display string: 'Timer 1 End'): The event will be generated when Timer 1 ends counting.
    - **Timer**#2#End (Display string: 'Timer #2# End'): The event will be generated when Timer #2# ends counting.
    - **Encoder0Stopped** (Display string: 'Encoder 0 Stopped'): The event will be generated when the Encoder 0 stops for longer than EncoderTimeout.
    - **Encoder1Stopped** (Display string: 'Encoder 1 Stopped'): The event will be generated when the Encoder 1 stops for longer than EncoderTimeout.
    - **Encoder**#2#Stopped (Display string: 'Encoder #2# Stopped'): The event will be generated when the Encoder #2# stops for longer than EncoderTimeout.
    - **Encoder0Restarted** (Display string: 'Encoder 0 Restarted'): The event will be generated when the Encoder 0 restarts moving.
    - **Encoder1Restarted** (Display string: 'Encoder 1 Restarted'): The event will be generated when the Encoder 1 restarts moving.
    - **Encoder**#2#Restarted (Display string: 'Encoder #2# Restarted'): The event will be generated when the Encoder #2# restarts moving.
    - **Line0RisingEdge** (Display string: 'Line 0 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 0.
    - **Line1RisingEdge** (Display string: 'Line 1 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 1.
    - **Line**#2#RisingEdge (Display string: 'Line #2# Rising Edge'): The event will be generated when a Rising Edge is detected on the Line #2#.
    - **Line0FallingEdge** (Display string: 'Line 0 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 0.
    - **Line1FallingEdge** (Display string: 'Line 1 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 1.
    - **Line**#2#FallingEdge (Display string: 'Line #2# Falling Edge'): The event will be generated when a Falling Edge is detected on the Line #2#.
    - **Line0AnyEdge** (Display string: 'Line 0 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 0.
    - **Line1AnyEdge** (Display string: 'Line 1 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 1.
    - **Line**#2#AnyEdge (Display string: 'Line #2# Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line #2#.
    - **LinkTrigger0** (Display string: 'Link Trigger 0'): The event will be generated when a Rising Edge is detected on the LinkTrigger 0.
    - **LinkTrigger1** (Display string: 'Link Trigger 1'): The event will be generated when a Rising Edge is detected on the LinkTrigger 1.
    - **LinkTrigger**#2# (Display string: 'Link Trigger #2#'): The event will be generated when a Rising Edge is detected on the LinkTrigger #2#.
    - **LinkSpeedChange** (Display string: 'Link Speed Change'): The event will be generated when the link speed has changed.
    - **ActionLate** (Display string: 'Action Late'): The event will be generated when a valid scheduled action command is received and is scheduled to be executed at a time that is already past.
    - **Error** (Display string: 'Error'): Device just detected an error during the active Acquisition.
    - **Test** (Display string: 'Test'): The test event will be generated when the device receives the TestEventGenerate command (EventNotification for the Test event is always On).
    - **PrimaryApplicationSwitch** (Display string: 'Primary Application Switch'): The event will be generated when a primary application switchover has been granted (GigE Vision Specific).
    - **Counter2Start** (Display string: 'Counter 2 Start'): The event will be generated when counter 2 starts counting.
    - **Counter3Start** (Display string: 'Counter 3 Start'): The event will be generated when counter 3 starts counting.
    - **Counter4Start** (Display string: 'Counter 4 Start'): The event will be generated when counter 4 starts counting.
    - **Counter5Start** (Display string: 'Counter 5 Start'): The event will be generated when counter 5 starts counting.
    - **Counter6Start** (Display string: 'Counter 6 Start'): The event will be generated when counter 6 starts counting.
    - **Counter7Start** (Display string: 'Counter 7 Start'): The event will be generated when counter 7 starts counting.
    - **Counter8Start** (Display string: 'Counter 8 Start'): The event will be generated when counter 8 starts counting.
    - **Counter9Start** (Display string: 'Counter 9 Start'): The event will be generated when counter 9 starts counting.
    - **Counter10Start** (Display string: 'Counter 10 Start'): The event will be generated when counter 10 starts counting.
    - **Counter11Start** (Display string: 'Counter 11 Start'): The event will be generated when counter 11 starts counting.
    - **Counter12Start** (Display string: 'Counter 12 Start'): The event will be generated when counter 12 starts counting.
    - **Counter13Start** (Display string: 'Counter 13 Start'): The event will be generated when counter 13 starts counting.
    - **Counter14Start** (Display string: 'Counter 14 Start'): The event will be generated when counter 14 starts counting.
    - **Counter15Start** (Display string: 'Counter 15 Start'): The event will be generated when counter 15 starts counting.
    - **Counter2End** (Display string: 'Counter 2 End'): The event will be generated when counter 2 ends counting.
    - **Counter3End** (Display string: 'Counter 3 End'): The event will be generated when counter 3 ends counting.
    - **Counter4End** (Display string: 'Counter 4 End'): The event will be generated when counter 4 ends counting.
    - **Counter5End** (Display string: 'Counter 5 End'): The event will be generated when counter 5 ends counting.
    - **Counter6End** (Display string: 'Counter 6 End'): The event will be generated when counter 6 ends counting.
    - **Counter7End** (Display string: 'Counter 7 End'): The event will be generated when counter 7 ends counting.
    - **Counter8End** (Display string: 'Counter 8 End'): The event will be generated when counter 8 ends counting.
    - **Counter9End** (Display string: 'Counter 9 End'): The event will be generated when counter 9 ends counting.
    - **Counter10End** (Display string: 'Counter 10 End'): The event will be generated when counter 10 ends counting.
    - **Counter11End** (Display string: 'Counter 11 End'): The event will be generated when counter 11 ends counting.
    - **Counter12End** (Display string: 'Counter 12 End'): The event will be generated when counter 12 ends counting.
    - **Counter13End** (Display string: 'Counter 13 End'): The event will be generated when counter 13 ends counting.
    - **Counter14End** (Display string: 'Counter 14 End'): The event will be generated when counter 14 ends counting.
    - **Counter15End** (Display string: 'Counter 15 End'): The event will be generated when counter 15 ends counting.
    - **Timer2Start** (Display string: 'Timer 2 Start'): The event will be generated when Timer 2 starts counting.
    - **Timer3Start** (Display string: 'Timer 3 Start'): The event will be generated when Timer 3 starts counting.
    - **Timer4Start** (Display string: 'Timer 4 Start'): The event will be generated when Timer 4 starts counting.
    - **Timer5Start** (Display string: 'Timer 5 Start'): The event will be generated when Timer 5 starts counting.
    - **Timer6Start** (Display string: 'Timer 6 Start'): The event will be generated when Timer 6 starts counting.
    - **Timer7Start** (Display string: 'Timer 7 Start'): The event will be generated when Timer 7 starts counting.
    - **Timer8Start** (Display string: 'Timer 8 Start'): The event will be generated when Timer 8 starts counting.
    - **Timer9Start** (Display string: 'Timer 9 Start'): The event will be generated when Timer 9 starts counting.
    - **Timer10Start** (Display string: 'Timer 10 Start'): The event will be generated when Timer 10 starts counting.
    - **Timer11Start** (Display string: 'Timer 11 Start'): The event will be generated when Timer 11 starts counting.
    - **Timer12Start** (Display string: 'Timer 12 Start'): The event will be generated when Timer 12 starts counting.
    - **Timer13Start** (Display string: 'Timer 13 Start'): The event will be generated when Timer 13 starts counting.
    - **Timer14Start** (Display string: 'Timer 14 Start'): The event will be generated when Timer 14 starts counting.
    - **Timer15Start** (Display string: 'Timer 15 Start'): The event will be generated when Timer 15 starts counting.
    - **Timer2End** (Display string: 'Timer 2 End'): The event will be generated when Timer 2 ends counting.
    - **Timer3End** (Display string: 'Timer 3 End'): The event will be generated when Timer 3 ends counting.
    - **Timer4End** (Display string: 'Timer 4 End'): The event will be generated when Timer 4 ends counting.
    - **Timer5End** (Display string: 'Timer 5 End'): The event will be generated when Timer 5 ends counting.
    - **Timer6End** (Display string: 'Timer 6 End'): The event will be generated when Timer 6 ends counting.
    - **Timer7End** (Display string: 'Timer 7 End'): The event will be generated when Timer 7 ends counting.
    - **Timer8End** (Display string: 'Timer 8 End'): The event will be generated when Timer 8 ends counting.
    - **Timer9End** (Display string: 'Timer 9 End'): The event will be generated when Timer 9 ends counting.
    - **Timer10End** (Display string: 'Timer 10 End'): The event will be generated when Timer 10 ends counting.
    - **Timer11End** (Display string: 'Timer 11 End'): The event will be generated when Timer 11 ends counting.
    - **Timer12End** (Display string: 'Timer 12 End'): The event will be generated when Timer 12 ends counting.
    - **Timer13End** (Display string: 'Timer 13 End'): The event will be generated when Timer 13 ends counting.
    - **Timer14End** (Display string: 'Timer 14 End'): The event will be generated when Timer 14 ends counting.
    - **Timer15End** (Display string: 'Timer 15 End'): The event will be generated when Timer 15 ends counting.
    - **Encoder2Stopped** (Display string: 'Encoder 2 Stopped'): The event will be generated when the Encoder 2 stops for longer than EncoderTimeout.
    - **Encoder3Stopped** (Display string: 'Encoder 3 Stopped'): The event will be generated when the Encoder 3 stops for longer than EncoderTimeout.
    - **Encoder4Stopped** (Display string: 'Encoder 4 Stopped'): The event will be generated when the Encoder 4 stops for longer than EncoderTimeout.
    - **Encoder5Stopped** (Display string: 'Encoder 5 Stopped'): The event will be generated when the Encoder 5 stops for longer than EncoderTimeout.
    - **Encoder6Stopped** (Display string: 'Encoder 6 Stopped'): The event will be generated when the Encoder 6 stops for longer than EncoderTimeout.
    - **Encoder7Stopped** (Display string: 'Encoder 7 Stopped'): The event will be generated when the Encoder 7 stops for longer than EncoderTimeout.
    - **Encoder8Stopped** (Display string: 'Encoder 8 Stopped'): The event will be generated when the Encoder 8 stops for longer than EncoderTimeout.
    - **Encoder9Stopped** (Display string: 'Encoder 9 Stopped'): The event will be generated when the Encoder 9 stops for longer than EncoderTimeout.
    - **Encoder10Stopped** (Display string: 'Encoder 10 Stopped'): The event will be generated when the Encoder 10 stops for longer than EncoderTimeout.
    - **Encoder11Stopped** (Display string: 'Encoder 11 Stopped'): The event will be generated when the Encoder 11 stops for longer than EncoderTimeout.
    - **Encoder12Stopped** (Display string: 'Encoder 12 Stopped'): The event will be generated when the Encoder 12 stops for longer than EncoderTimeout.
    - **Encoder13Stopped** (Display string: 'Encoder 13 Stopped'): The event will be generated when the Encoder 13 stops for longer than EncoderTimeout.
    - **Encoder14Stopped** (Display string: 'Encoder 14 Stopped'): The event will be generated when the Encoder 14 stops for longer than EncoderTimeout.
    - **Encoder15Stopped** (Display string: 'Encoder 15 Stopped'): The event will be generated when the Encoder 15 stops for longer than EncoderTimeout.
    - **Encoder2Restarted** (Display string: 'Encoder 2 Restarted'): The event will be generated when the Encoder 2 restarts moving.
    - **Encoder3Restarted** (Display string: 'Encoder 3 Restarted'): The event will be generated when the Encoder 3 restarts moving.
    - **Encoder4Restarted** (Display string: 'Encoder 4 Restarted'): The event will be generated when the Encoder 4 restarts moving.
    - **Encoder5Restarted** (Display string: 'Encoder 5 Restarted'): The event will be generated when the Encoder 5 restarts moving.
    - **Encoder6Restarted** (Display string: 'Encoder 6 Restarted'): The event will be generated when the Encoder 6 restarts moving.
    - **Encoder7Restarted** (Display string: 'Encoder 7 Restarted'): The event will be generated when the Encoder 7 restarts moving.
    - **Encoder8Restarted** (Display string: 'Encoder 8 Restarted'): The event will be generated when the Encoder 8 restarts moving.
    - **Encoder9Restarted** (Display string: 'Encoder 9 Restarted'): The event will be generated when the Encoder 9 restarts moving.
    - **Encoder10Restarted** (Display string: 'Encoder 10 Restarted'): The event will be generated when the Encoder 10 restarts moving.
    - **Encoder11Restarted** (Display string: 'Encoder 11 Restarted'): The event will be generated when the Encoder 11 restarts moving.
    - **Encoder12Restarted** (Display string: 'Encoder 12 Restarted'): The event will be generated when the Encoder 12 restarts moving.
    - **Encoder13Restarted** (Display string: 'Encoder 13 Restarted'): The event will be generated when the Encoder 13 restarts moving.
    - **Encoder14Restarted** (Display string: 'Encoder 14 Restarted'): The event will be generated when the Encoder 14 restarts moving.
    - **Encoder15Restarted** (Display string: 'Encoder 15 Restarted'): The event will be generated when the Encoder 15 restarts moving.
    - **Line2RisingEdge** (Display string: 'Line 2 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 2.
    - **Line3RisingEdge** (Display string: 'Line 3 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 3.
    - **Line4RisingEdge** (Display string: 'Line 4 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 4.
    - **Line5RisingEdge** (Display string: 'Line 5 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 5.
    - **Line6RisingEdge** (Display string: 'Line 6 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 6.
    - **Line7RisingEdge** (Display string: 'Line 7 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 7.
    - **Line8RisingEdge** (Display string: 'Line 8 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 8.
    - **Line9RisingEdge** (Display string: 'Line 9 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 9.
    - **Line10RisingEdge** (Display string: 'Line 10 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 10.
    - **Line11RisingEdge** (Display string: 'Line 11 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 11.
    - **Line12RisingEdge** (Display string: 'Line 12 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 12.
    - **Line13RisingEdge** (Display string: 'Line 13 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 13.
    - **Line14RisingEdge** (Display string: 'Line 14 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 14.
    - **Line15RisingEdge** (Display string: 'Line 15 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 15.
    - **Line2FallingEdge** (Display string: 'Line 2 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 2.
    - **Line3FallingEdge** (Display string: 'Line 3 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 3.
    - **Line4FallingEdge** (Display string: 'Line 4 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 4.
    - **Line5FallingEdge** (Display string: 'Line 5 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 5.
    - **Line6FallingEdge** (Display string: 'Line 6 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 6.
    - **Line7FallingEdge** (Display string: 'Line 7 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 7.
    - **Line8FallingEdge** (Display string: 'Line 8 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 8.
    - **Line9FallingEdge** (Display string: 'Line 9 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 9.
    - **Line10FallingEdge** (Display string: 'Line 10 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 10.
    - **Line11FallingEdge** (Display string: 'Line 11 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 11.
    - **Line12FallingEdge** (Display string: 'Line 12 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 12.
    - **Line13FallingEdge** (Display string: 'Line 13 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 13.
    - **Line14FallingEdge** (Display string: 'Line 14 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 14.
    - **Line15FallingEdge** (Display string: 'Line 15 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 15.
    - **Line2AnyEdge** (Display string: 'Line 2 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 2.
    - **Line3AnyEdge** (Display string: 'Line 3 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 3.
    - **Line4AnyEdge** (Display string: 'Line 4 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 4.
    - **Line5AnyEdge** (Display string: 'Line 5 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 5.
    - **Line6AnyEdge** (Display string: 'Line 6 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 6.
    - **Line7AnyEdge** (Display string: 'Line 7 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 7.
    - **Line8AnyEdge** (Display string: 'Line 8 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 8.
    - **Line9AnyEdge** (Display string: 'Line 9 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 9.
    - **Line10AnyEdge** (Display string: 'Line 10 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 10.
    - **Line11AnyEdge** (Display string: 'Line 11 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 11.
    - **Line12AnyEdge** (Display string: 'Line 12 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 12.
    - **Line13AnyEdge** (Display string: 'Line 13 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 13.
    - **Line14AnyEdge** (Display string: 'Line 14 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 14.
    - **Line15AnyEdge** (Display string: 'Line 15 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 15.
    - **Link0Trigger** (Display string: 'Link 0 Trigger')
    - **Link1Trigger** (Display string: 'Link 1 Trigger')
    - **Link2Trigger** (Display string: 'Link 2 Trigger')
    - **Link3Trigger** (Display string: 'Link 3 Trigger')
    - **Link4Trigger** (Display string: 'Link 4 Trigger')
    - **Link5Trigger** (Display string: 'Link 5 Trigger')
    - **Link6Trigger** (Display string: 'Link 6 Trigger')
    - **Link7Trigger** (Display string: 'Link 7 Trigger')
    - **Link8Trigger** (Display string: 'Link 8 Trigger')
    - **Link9Trigger** (Display string: 'Link 9 Trigger')
    - **Link10Trigger** (Display string: 'Link 10 Trigger')
    - **Link11Trigger** (Display string: 'Link 11 Trigger')
    - **Link12Trigger** (Display string: 'Link 12 Trigger')
    - **Link13Trigger** (Display string: 'Link 13 Trigger')
    - **Link14Trigger** (Display string: 'Link 14 Trigger')
    - **Link15Trigger** (Display string: 'Link 15 Trigger')
    - **InterfaceListChanged** (Display string: 'Interface List Changed'): This enumeration value indicates an event that is fired when the list of interfaces has been updated.
    - **InterfaceLost** (Display string: 'Interface Lost'): This enumeration value indicates an event that is raised when the interface connection is lost.
    - **DeviceListChanged** (Display string: 'Device List Changed'): This enumeration value indicates an event that is fired when the list of devices has been updated.
    - **DeviceLost** (Display string: 'Device Lost'): This enumeration value indicates an event that is raised when the local host looses connection to the physical(remote) device.
    - **BufferTooSmall** (Display string: 'Buffer Too Small'): This enumeration value indicates an event that is raised when the buffer was too small to receive the expected amount of data.
    - **BuffersDiscarded** (Display string: 'Buffers Discarded'): This enumeration value indicates an event that is raised when buffers discared by GenTL or device. This event could optionally carry two numeric child data fields EventBuffersDiscardedDeviceCount and EventBuffersDiscardedProducerCount.
    - **BuffersDiscardedDeviceCount** (Display string: 'Buffers Discarded Device Count'): This enumeration value indicates the number of buffers discarded by the device since last fired instance of this event (the producer would get to know about this for example by observing a gap in the block_id sequence).
    - **BuffersDiscardedProducerCount** (Display string: 'Buffers Discarded Producer Count'): This enumeration value indicates the number of buffers discarded by the producer since last fired instance of this event (this would happen e.g. if there are no free buffers available or if given buffer handling mode requires discarding old buffers etc.).

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    eventNotification = property(lib_mvIMPACT_acquire.SystemModule_eventNotification_get, doc=r"""
    An enumerated integer property. Activate or deactivate the notification to the host application of the occurrence of the selected Event.
    Activate or deactivate the notification to the host application of the occurrence of the selected Event.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off'): The selected Event notification is disabled.
    - **On** (Display string: 'On'): The selected Event notification is enabled.
    - **Once** (Display string: 'Once'): The selected Event notification is enabled for one event then return to Off state.
    - **GigEVisionEvent** (Display string: 'Gig E Vision Event')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)

    @staticmethod
    def getSystemModuleCount():
        r"""
        Returns the number of GenTL producers detected in the current system.
        This is also the number of system modules detected thus this value - 1 defines the maximum value that can
        be passed as the *index* parameter into a **mvIMPACT::acquire::SystemModule** constructor.
        Since: 2.32.0
        """
        return lib_mvIMPACT_acquire.SystemModule_getSystemModuleCount()

    def getInterfaceModuleCount(self):
        r"""
         Returns the number of interfaces associated with this GenTL producer.
        This should return the same value as when calling **mvIMPACT::acquire::GenICam::SystemModule::interfaceSelector::getMaxValue**
        however there are producers out there that do not implement the ``interfaceSelector`` property correctly.

         Since: 2.34.0
        """
        return lib_mvIMPACT_acquire.SystemModule_getInterfaceModuleCount(self)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_SystemModule

# Register SystemModule in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.SystemModule_swigregister(SystemModule)

def SystemModule_getSystemModuleCount():
    r"""
    Returns the number of GenTL producers detected in the current system.
    This is also the number of system modules detected thus this value - 1 defines the maximum value that can
    be passed as the *index* parameter into a **mvIMPACT::acquire::SystemModule** constructor.
    Since: 2.32.0
    """
    return lib_mvIMPACT_acquire.SystemModule_getSystemModuleCount()

class InterfaceModule(ComponentCollection):
    r"""
    Category that contains items that belong to the interface module of the transport layer.
    The Interface category contains items that belong to the interface module of the transport layer.
    """

    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, index):
        r"""
         Constructs a new **mvIMPACT::acquire::GenICam::InterfaceModule** object.
         Since: 2.32.0

        :type parent: :py:class:`SystemModule`
        :param parent: [in] The **mvIMPACT::acquire::GenICam::SystemModule** instance providing access to the interface module to be created.
        :type index: int
        :param index: [in] The *index* of the instance this object shall be created for. Passing an invalid index will raise an exception.
        """
        lib_mvIMPACT_acquire.InterfaceModule_swiginit(self, lib_mvIMPACT_acquire.new_InterfaceModule(parent, index))
    interfaceID = property(lib_mvIMPACT_acquire.InterfaceModule_interfaceID_get, doc=r"""
    A string property. GenTL producer wide unique identifier of the selected interface.
    This is a read only element. It is a string that indicates a GenTL producer wide unique identifier of the selected interface.
    """)
    interfaceDisplayName = property(lib_mvIMPACT_acquire.InterfaceModule_interfaceDisplayName_get, doc=r"""
    A string property. A user-friendly name of the Interface.
    This is a read only element. It is a string that indicates a  user-friendly name of the Interface.
    """)
    interfaceType = property(lib_mvIMPACT_acquire.InterfaceModule_interfaceType_get, doc=r"""
    An enumerated integer property. Identifies the interfaces technology of the GenTL Producer implementation.
    This is a read only feature. This enumeration provides a value that indicates interfaces technology of the GenTL Producer implementation.

    The following string values might be valid for this feature:
    - **Mixed** (Display string: 'Mixed'): This enumeration value indicates that this is an interface for a mixed protocol.
    - **Custom** (Display string: 'Custom'): This enumeration value indicates that this is an interface for a custom protocol.
    - **GEV** (Display string: 'GigE Vision'): This enumeration value indicates that this is an interface for the GigE Vision protocol.
    - **CameraLink** (Display string: 'CameraLink'): This enumeration value indicates that this is an interface for the CameraLink protocol.
    - **CoaXPress** (Display string: 'CoaXPress'): This enumeration value indicates that this is an interface for the CoaXPress protocol.
    - **CameraLinkHS** (Display string: 'CameraLink HS'): This enumeration value indicates that this is an interface for the CameraLink HS protocol.
    - **U3V** (Display string: 'USB3 Vision'): This enumeration value indicates that this is an interface for the USB3 Vision protocol.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    interfaceTLVersionMajor = property(lib_mvIMPACT_acquire.InterfaceModule_interfaceTLVersionMajor_get, doc=r"""
    An integer property. Indicates the major version number of the transport layer specification the GenTL Producer complies with.
    This is a read only element. It indicates the major version number of the transport layer specification the GenTL Producer complies with.
    """)
    interfaceTLVersionMinor = property(lib_mvIMPACT_acquire.InterfaceModule_interfaceTLVersionMinor_get, doc=r"""
    An integer property. Indicates the minor version number of the transport layer specification the GenTL Producer complies with.
    This is a read only element. It indicates the minor version number of the transport layer specification the GenTL Producer complies with.
    """)
    gevInterfaceGatewaySelector = property(lib_mvIMPACT_acquire.InterfaceModule_gevInterfaceGatewaySelector_get, doc=r"""
    An integer property. Selector for the different gateway entries for this interface.
    Selector for the different gateway entries for this interface. The selector is 0-based in order to match the index of the C interface.
    """)
    gevInterfaceGateway = property(lib_mvIMPACT_acquire.InterfaceModule_gevInterfaceGateway_get, doc=r"""
    An integer property. Indicates the IP address of the selected gateway entry of this interface.
    This is a read only element. It indicates the IP address of the selected gateway entry of this interface.
    """)
    gevInterfaceMACAddress = property(lib_mvIMPACT_acquire.InterfaceModule_gevInterfaceMACAddress_get, doc=r"""
    An integer property. Indicates the 48-bit MAC address of the selected interface.
    This is a read only element. It indicates the 48-bit MAC address of the selected interface.
    """)
    gevInterfaceSubnetSelector = property(lib_mvIMPACT_acquire.InterfaceModule_gevInterfaceSubnetSelector_get, doc=r"""
    An integer property. Selector for the different subnet entries for this interface.
    Selector for the different subnet entries for this interface. The selector is 0-based in order to match the index of the C interface.
    """)
    gevInterfaceSubnetIPAddress = property(lib_mvIMPACT_acquire.InterfaceModule_gevInterfaceSubnetIPAddress_get, doc=r"""
    An integer property. Indicates the IP address of the selected subnet entry of this interface.
    This is a read only element. It indicates the IP address of the selected subnet entry of this interface.
    """)
    gevInterfaceSubnetMask = property(lib_mvIMPACT_acquire.InterfaceModule_gevInterfaceSubnetMask_get, doc=r"""
    An integer property. Indicates the subnet mask of the selected subnet entry of this interface.
    This is a read only element. It indicates the subnet mask of the selected subnet entry of this interface.
    """)
    mvGevInterfaceMTU = property(lib_mvIMPACT_acquire.InterfaceModule_mvGevInterfaceMTU_get, doc=r"""
    An integer property. Indicates the MTU of this interface.
    This is a read only element. It indicates the MTU(Maximum Transmission Unit) of this interface.
    """)
    mvGevInterfaceLinkSpeed = property(lib_mvIMPACT_acquire.InterfaceModule_mvGevInterfaceLinkSpeed_get, doc=r"""
    An integer property. Indicates the link speed of this interface.
    This is a read only element. It indicates the link speed(in Mbits per second) of this interface.
    """)
    mvGevAdvancedDeviceDiscoveryEnable = property(lib_mvIMPACT_acquire.InterfaceModule_mvGevAdvancedDeviceDiscoveryEnable_get, doc=r"""
    A boolean property. Enables or disables the advanced device discovery.
    Enables or disables the advanced device discovery. When enabled also devices, which currently use an incorrect IP configuration for the network they are connected to might be detectable. However depending on the operating system this may result in devices showing up on interfaces to which they are not physically connected.
    """)
    deviceUpdateList = property(lib_mvIMPACT_acquire.InterfaceModule_deviceUpdateList_get, doc=r"""
    A method object. Updates the internal device list of this interface.
    This command updates the internal device list of this interface.
    """)
    deviceUpdateTimeout = property(lib_mvIMPACT_acquire.InterfaceModule_deviceUpdateTimeout_get, doc=r"""
    An integer property. Specifies timeout for the DeviceUpdateList Command.
    Specifies timeout for the DeviceUpdateList Command.
    """)
    deviceSelector = property(lib_mvIMPACT_acquire.InterfaceModule_deviceSelector_get, doc=r"""
    An integer property. Selector for the different devices on this interface.
    Selector for the different devices on this interface. The limits of this feature might change upon execution of DeviceUpdateList.
    """)
    deviceID = property(lib_mvIMPACT_acquire.InterfaceModule_deviceID_get, doc=r"""
    A string property. This feature is deprecated (See DeviceSerialNumber).
    Deprecated: 
    This feature is deprecated (See DeviceSerialNumber). It was representing the Device unique identifier (serial number).
    """)
    deviceVendorName = property(lib_mvIMPACT_acquire.InterfaceModule_deviceVendorName_get, doc=r"""
    A string property. Name of the manufacturer of the device.
    Name of the manufacturer of the device.
    """)
    deviceModelName = property(lib_mvIMPACT_acquire.InterfaceModule_deviceModelName_get, doc=r"""
    A string property. Model of the device.
    Model of the device.
    """)
    deviceType = property(lib_mvIMPACT_acquire.InterfaceModule_deviceType_get, doc=r"""
    An enumerated integer property. Returns the device type.
    Returns the device type.

    The following string values might be valid for this feature:
    - **Transmitter** (Display string: 'Transmitter'): Data stream transmitter device.
    - **Receiver** (Display string: 'Receiver'): Data stream receiver device.
    - **Transceiver** (Display string: 'Transceiver'): Data stream receiver and transmitter device.
    - **Peripheral** (Display string: 'Peripheral'): Controllable device (with no data stream handling).
    - **Mixed** (Display string: 'Mixed'): This enumeration value indicates that this is a device for a mixed protocol.
    - **Custom** (Display string: 'Custom'): This enumeration value indicates that this is a device for a custom protocol.
    - **GEV** (Display string: 'GigE Vision'): This enumeration value indicates that this is a device for the GigE Vision protocol.
    - **CameraLink** (Display string: 'CameraLink'): This enumeration value indicates that this is a device for the CameraLink protocol.
    - **CoaXPress** (Display string: 'CoaXPress'): This enumeration value indicates that this is a device for the CoaXPress protocol.
    - **CameraLinkHS** (Display string: 'CameraLink HS'): This enumeration value indicates that this is a device for the CameraLink HS protocol.
    - **U3V** (Display string: 'USB3 Vision'): This enumeration value indicates that this is a device for the USB3 Vision protocol.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    deviceLinkSpeed = property(lib_mvIMPACT_acquire.InterfaceModule_deviceLinkSpeed_get, doc=r"""
    An integer property. Indicates the speed of transmission negotiated on the specified Link.
    Indicates the speed of transmission negotiated on the specified Link.
    """)
    deviceAccessStatus = property(lib_mvIMPACT_acquire.InterfaceModule_deviceAccessStatus_get, doc=r"""
    An enumerated integer property. Indicates the current access status for the device.
    This is a read only feature. This enumeration gives the device's access status at the moment of the last execution of the DeviceUpdateList command. This value only changes on execution of the DeviceUpdateList command.

    The following string values might be valid for this feature:
    - **Unknown** (Display string: 'Unknown'): This enumeration value indicates that the device accessibility is not known.
    - **ReadWrite** (Display string: 'Read/Write'): This enumeration value indicates that full access to the device is available.
    - **ReadOnly** (Display string: 'Read Only'): This enumeration value indicates that read access to the device is available.
    - **NoAccess** (Display string: 'No Access'): This enumeration value indicates that no access to the device is available.
    - **Busy** (Display string: 'Busy'): This enumeration value indicates that the device is already opened by another entity.
    - **OpenReadWrite** (Display string: 'Open Read Write'): This enumeration value indicates that the device is open in Read/Write mode by this GenTL host.
    - **OpenReadOnly** (Display string: 'Open Read Only'): This enumeration value indicates that the device is open in Read only mode by this GenTL host.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    deviceSerialNumber = property(lib_mvIMPACT_acquire.InterfaceModule_deviceSerialNumber_get, doc=r"""
    A string property. Device's serial number.
    Device's serial number. This string is a unique identifier of the device.
    """)
    deviceUserID = property(lib_mvIMPACT_acquire.InterfaceModule_deviceUserID_get, doc=r"""
    A string property. User-programmable device identifier.
    User-programmable device identifier.
    """)
    deviceTLVersionMajor = property(lib_mvIMPACT_acquire.InterfaceModule_deviceTLVersionMajor_get, doc=r"""
    An integer property. Major version of the Transport Layer of the device.
    Major version of the Transport Layer of the device.
    """)
    deviceTLVersionMinor = property(lib_mvIMPACT_acquire.InterfaceModule_deviceTLVersionMinor_get, doc=r"""
    An integer property. Minor version of the Transport Layer of the device.
    Minor version of the Transport Layer of the device.
    """)
    gevDeviceIPAddress = property(lib_mvIMPACT_acquire.InterfaceModule_gevDeviceIPAddress_get, doc=r"""
    An integer property. Indicates the current IP address of the GVCP interface of the selected remote device.
    This is a read only element. It indicates the current IP address of the GVCP interface of the selected remote device.
    """)
    gevDeviceSubnetMask = property(lib_mvIMPACT_acquire.InterfaceModule_gevDeviceSubnetMask_get, doc=r"""
    An integer property. Indicates the current subnet mask of the GVCP interface of the selected remote device.
    This is a read only element. It indicates the current subnet mask of the GVCP interface of the selected remote device.
    """)
    gevDeviceGateway = property(lib_mvIMPACT_acquire.InterfaceModule_gevDeviceGateway_get, doc=r"""
    An integer property. Indicates the current gateway of the GVCP interface of the selected remote device.
    This is a read only element. It indicates the current gateway of the GVCP interface of the selected remote device.
    """)
    gevDeviceIPConfigurationStatus = property(lib_mvIMPACT_acquire.InterfaceModule_gevDeviceIPConfigurationStatus_get, doc=r"""
    An enumerated integer property. Identifies the IP configuration of the GVCP interface of the selected remote device.
    This is a read only feature. This enumeration provides a value that indicates the Device IP configuration of the GVCP interface of the selected remote device. This value only changes on execution of the DeviceUpdateList command.

    The following string values might be valid for this feature:
    - **DHCP** (Display string: 'DHCP')
    - **PersistentIP** (Display string: 'Persistent IP')
    - **LinkLocal** (Display string: 'Link Local')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    gevDeviceMACAddress = property(lib_mvIMPACT_acquire.InterfaceModule_gevDeviceMACAddress_get, doc=r"""
    An integer property. Indicates the 48-bit MAC address of the GVCP interface of the selected remote device.
    This is a read only element. It indicates the 48-bit MAC address of the GVCP interface of the selected remote device.
    """)
    gevCurrentControlMode = property(lib_mvIMPACT_acquire.InterfaceModule_gevCurrentControlMode_get, doc=r"""
    An enumerated integer property. The current control mode of the device.
    This enumeration provides a value that indicates the current control mode of the device.

    The following string values might be valid for this feature:
    - **Open** (Display string: 'Open'): This enumeration value indicates that the device is open for control or exclusive access.
    - **ControlAccess** (Display string: 'Control Access'): This enumeration value indicates that the device is controlled by another host, but switchover or read-only access is possible.
    - **ExclusiveAccess** (Display string: 'Exclusive Access'): This enumeration value indicates that the device is under exclusive access by a host and cannot be accessed by another.
    - **NoAccess** (Display string: 'No Access'): This enumeration value indicates that the device cannot be accessed, for instance it may be a GigE Vision device on a subnet different from the interface.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvDeviceCommandChannelTransmissionTimeout = property(lib_mvIMPACT_acquire.InterfaceModule_mvDeviceCommandChannelTransmissionTimeout_get, doc=r"""
    An integer property. Defines the maximum time in milli-seconds the host driver will wait for an ACK from the device to a previously sent command(deprecated).
    Deprecated: 
    Defines the maximum time in milli-seconds the host driver will wait for an ACK from the device to a previously sent command. This feature has been declared deprecated. Use 'LinkCommandTimeout' of the DeviceModule instead.
    """)
    mvDeviceCommandChannelRetryCount = property(lib_mvIMPACT_acquire.InterfaceModule_mvDeviceCommandChannelRetryCount_get, doc=r"""
    An integer property. Indicates the number of retransmissions allowed when command channel message timed out (no ACK was received from the device)(deprecated).
    Deprecated: 
    Indicates the number of retransmissions allowed when command channel message timed out (no ACK was received from the device). This feature has been declared deprecated. Use 'LinkCommandRetryCount' of the DeviceModule instead.
    """)
    gevVersionMajor = property(lib_mvIMPACT_acquire.InterfaceModule_gevVersionMajor_get, doc=r"""
    An integer property. Indicates the major version number of the GigE Vision specification this device complies with.
    This is a read only element. It indicates the major version number of the GigE Vision specification this device complies with.
    """)
    gevVersionMinor = property(lib_mvIMPACT_acquire.InterfaceModule_gevVersionMinor_get, doc=r"""
    An integer property. Indicates the minor version number of the GigE Vision specification this device complies with.
    This is a read only element. It indicates the minor version number of the GigE Vision specification this device complies with.
    """)
    genCPVersionMajor = property(lib_mvIMPACT_acquire.InterfaceModule_genCPVersionMajor_get, doc=r"""
    An integer property. Indicates the major version number of the GenCP specification this device complies with.
    This is a read only element. It indicates the major version number of the GenCP specification this device complies with.
    """)
    genCPVersionMinor = property(lib_mvIMPACT_acquire.InterfaceModule_genCPVersionMinor_get, doc=r"""
    An integer property. Indicates the minor version number of the GenCP specification this device complies with.
    This is a read only element. It indicates the minor version number of the GenCP specification this device complies with.
    """)
    u3vVersionMajor = property(lib_mvIMPACT_acquire.InterfaceModule_u3vVersionMajor_get, doc=r"""
    An integer property. Indicates the major version number of the USB3 Vision specification this device complies with.
    This is a read only element. It indicates the major version number of the USB3 Vision specification this device complies with.
    """)
    u3vVersionMinor = property(lib_mvIMPACT_acquire.InterfaceModule_u3vVersionMinor_get, doc=r"""
    An integer property. Indicates the minor version number of the USB3 Vision specification this device complies with.
    This is a read only element. It indicates the minor version number of the USB3 Vision specification this device complies with.
    """)
    mvDevicePrimaryApplicationSwitchoverSupported = property(lib_mvIMPACT_acquire.InterfaceModule_mvDevicePrimaryApplicationSwitchoverSupported_get, doc=r"""
    A boolean property. Reports the availability of the primary application switchover feature.
    Reports the availability of the primary application switchover feature.
    """)
    mvDevicePrimaryApplicationSwitchoverEnable = property(lib_mvIMPACT_acquire.InterfaceModule_mvDevicePrimaryApplicationSwitchoverEnable_get, doc=r"""
    A boolean property. Enables or disables primary application switchover.
    Enables or disables primary application switchover.
    """)
    gevApplicationSwitchoverKey = property(lib_mvIMPACT_acquire.InterfaceModule_gevApplicationSwitchoverKey_get, doc=r"""
    An integer property. Controls the key to use to authenticate primary application switchover requests.
    Controls the key to use to authenticate primary application switchover requests. If the device to take over has 'mvDevicePrimaryApplicationSwitchoverEnable' set to true and this key matches the devices internal key control access will be granted.
    """)
    mvDeviceNetworkInterfaceCount = property(lib_mvIMPACT_acquire.InterfaceModule_mvDeviceNetworkInterfaceCount_get, doc=r"""
    An integer property. The number of physical network interfaces supported by this device.
    This is an integer feature. It contains the number of physical network interfaces supported by this device.
    """)
    gevDeviceForceIP = property(lib_mvIMPACT_acquire.InterfaceModule_gevDeviceForceIP_get, doc=r"""
    A method object. Apply the force IP settings (GevDeviceForceIPAddress, GevDeviceForceSubnetMask and GevDeviceForceGateway) in the Device using ForceIP command.
    Apply the force IP settings (GevDeviceForceIPAddress, GevDeviceForceSubnetMask and GevDeviceForceGateway) in the Device using ForceIP command.
    """)
    gevDeviceForceIPAddress = property(lib_mvIMPACT_acquire.InterfaceModule_gevDeviceForceIPAddress_get, doc=r"""
    An integer property. Static IP address to set for the GVCP interface of the selected remote device.
    Static IP address to set for the GVCP interface of the selected remote device.
    """)
    gevDeviceForceSubnetMask = property(lib_mvIMPACT_acquire.InterfaceModule_gevDeviceForceSubnetMask_get, doc=r"""
    An integer property. Static subnet mask to set for the GVCP interface of the selected remote device.
    Static subnet mask to set for the GVCP interface of the selected remote device.
    """)
    gevDeviceForceGateway = property(lib_mvIMPACT_acquire.InterfaceModule_gevDeviceForceGateway_get, doc=r"""
    An integer property. Static gateway IP address to set for the GVCP interface of the selected remote device.
    Static gateway IP address to set for the GVCP interface of the selected remote device.
    """)
    mvDeviceUpdateFirmware = property(lib_mvIMPACT_acquire.InterfaceModule_mvDeviceUpdateFirmware_get, doc=r"""
    A method object. Updates the device's firmware.
    Updates the device using the firmware images embedded into this producer library.
    """)
    actionCommand = property(lib_mvIMPACT_acquire.InterfaceModule_actionCommand_get, doc=r"""
    A method object. Sends the action command
    It either sends an action command unicast packet to the IP address specified by the 'mvActionDestinationIPAddress' property, or broadcasts an action command broadcast packet on the broadcast domain specified by the 'mvActionDestinationIPAddress' property
    """)
    actionDeviceKey = property(lib_mvIMPACT_acquire.InterfaceModule_actionDeviceKey_get, doc=r"""
    An integer property. The device key for the action command
    The device key is one of the three main components that constitute an action command packet. It partly defines which device(s) will positively assert the action command packet.
    """)
    actionGroupKey = property(lib_mvIMPACT_acquire.InterfaceModule_actionGroupKey_get, doc=r"""
    An integer property. The group key for the action command
    The group key is one of the three main components that constitute an action command packet. It partly defines which device(s) will positively assert the action command packet.
    """)
    actionGroupMask = property(lib_mvIMPACT_acquire.InterfaceModule_actionGroupMask_get, doc=r"""
    An integer property. The group mask for the action command
    The group mask is one of the three main components that constitute an action command packet. It partly defines which device(s) will positively assert the action command packet.
    """)
    actionScheduledTimeEnable = property(lib_mvIMPACT_acquire.InterfaceModule_actionScheduledTimeEnable_get, doc=r"""
    A boolean property. Enables or disables action command scheduling
    Action commands can be scheduled to execute at a particular moment in time, defined by the 'mvActionScheduledTime' property. If this is disabled the action command takes place immediately after it is received and asserted by each device.
    """)
    actionScheduledTime = property(lib_mvIMPACT_acquire.InterfaceModule_actionScheduledTime_get, doc=r"""
    An integer property. Sets the time in which the action command will be executed
    Sets the time in which the action command will be executed
    """)
    gevActionDestinationIPAddress = property(lib_mvIMPACT_acquire.InterfaceModule_gevActionDestinationIPAddress_get, doc=r"""
    An integer property. The IP address of the action command recipient
    A valid IP address if the action command shall be unicast. A broadcast subnet if the action command shall be broadcast.
    """)
    eventSelector = property(lib_mvIMPACT_acquire.InterfaceModule_eventSelector_get, doc=r"""
    An enumerated integer property. Selects which Event to signal to the host application.
    Selects which Event to signal to the host application.

    The following string values might be valid for this feature:
    - **AcquisitionTrigger** (Display string: 'Acquisition Trigger'): Device just received a trigger for the Acquisition of one or many Frames.
    - **AcquisitionTriggerMissed** (Display string: 'Acquisition Trigger Missed'): Device just missed a trigger for the Acquisition of one or many Frames.
    - **AcquisitionStart** (Display string: 'Acquisition Start'): Device just started the Acquisition of one or many Frames.
    - **AcquisitionEnd** (Display string: 'Acquisition End'): Device just completed the Acquisition of one or many Frames.
    - **AcquisitionTransferStart** (Display string: 'Acquisition Transfer Start'): Device just started the transfer of one or many Frames.
    - **AcquisitionTransferEnd** (Display string: 'Acquisition Transfer End'): Device just completed the transfer of one or many Frames.
    - **AcquisitionError** (Display string: 'Acquisition Error'): Device just detected an error during the active Acquisition.
    - **FrameBurstStart** (Display string: 'Frame Burst Start'): Device just started the capture of a burst of Frames.
    - **FrameBurstEnd** (Display string: 'Frame Burst End'): Device just completed the capture of a burst of Frames.
    - **FrameTrigger** (Display string: 'Frame Trigger'): Device just received a trigger to start the capture of one Frame.
    - **FrameTriggerMissed** (Display string: 'Frame Trigger Missed'): Device just missed a trigger to start the capture of one Frame.
    - **FrameStart** (Display string: 'Frame Start'): Device just started the capture of one Frame.
    - **FrameEnd** (Display string: 'Frame End'): Device just completed the capture of one Frame.
    - **FrameTransferStart** (Display string: 'Frame Transfer Start'): Device just started the transfer of one Frame.
    - **FrameTransferEnd** (Display string: 'Frame Transfer End'): Device just completed the transfer of one Frame.
    - **LineTrigger** (Display string: 'Line Trigger'): Device just received a trigger to start the capture of one Line.
    - **LineTriggerMissed** (Display string: 'Line Trigger Missed'): Device just missed a trigger to start the capture of one Line.
    - **LineStart** (Display string: 'Line Start'): Device just started the capture of one Line.
    - **LineEnd** (Display string: 'Line End'): Device just completed the capture of one Line.
    - **ExposureStart** (Display string: 'Exposure Start'): Device just started the exposure of one Frame (or Line).
    - **ExposureEnd** (Display string: 'Exposure End'): Device just completed the exposure of one Frame (or Line).
    - **Stream0TransferStart** (Display string: 'Stream 0 Transfer Start'): Device just started the transfer of one or many Blocks.
    - **Stream0TransferEnd** (Display string: 'Stream 0 Transfer End'): Device just completed the transfer of one or many Blocks.
    - **Stream0TransferPause** (Display string: 'Stream 0 Transfer Pause'): Device just paused the transfer.
    - **Stream0TransferResume** (Display string: 'Stream 0 Transfer Resume'): Device just resumed the transfer.
    - **Stream0TransferBlockStart** (Display string: 'Stream 0 Transfer Block Start'): Device just started the transfer of one Block.
    - **Stream0TransferBlockEnd** (Display string: 'Stream 0 Transfer Block End'): Device just completed the transfer of one Block.
    - **Stream0TransferBlockTrigger** (Display string: 'Stream 0 Transfer Block Trigger'): Device just received a trigger to start the transfer of one Block.
    - **Stream0TransferBurstStart** (Display string: 'Stream 0 Transfer Burst Start'): Device just started the transfer of a burst of Blocks.
    - **Stream0TransferBurstEnd** (Display string: 'Stream 0 Transfer Burst End'): Device just completed the transfer of a burst of Blocks.
    - **Stream0TransferOverflow** (Display string: 'Stream 0 Transfer Overflow'): Device transfer queue overflowed.
    - **SequencerSetChange** (Display string: 'Sequencer Set Change'): Device sequencer set has changed.
    - **Counter0Start** (Display string: 'Counter 0 Start'): The event will be generated when counter 0 starts counting.
    - **Counter1Start** (Display string: 'Counter 1 Start'): The event will be generated when counter 1 starts counting.
    - **Counter**#2#Start (Display string: 'Counter #2# Start'): The event will be generated when counter #2# starts counting.
    - **Counter0End** (Display string: 'Counter 0 End'): The event will be generated when counter 0 ends counting.
    - **Counter1End** (Display string: 'Counter 1 End'): The event will be generated when counter 1 ends counting.
    - **Counter**#2#End (Display string: 'Counter #2# End'): The event will be generated when counter #2# ends counting.
    - **Timer0Start** (Display string: 'Timer 0 Start'): The event will be generated when Timer 0 starts counting.
    - **Timer1Start** (Display string: 'Timer 1 Start'): The event will be generated when Timer 1 starts counting.
    - **Timer**#2#Start (Display string: 'Timer #2# Start'): The event will be generated when Timer #2# starts counting.
    - **Timer0End** (Display string: 'Timer 0 End'): The event will be generated when Timer 0 ends counting.
    - **Timer1End** (Display string: 'Timer 1 End'): The event will be generated when Timer 1 ends counting.
    - **Timer**#2#End (Display string: 'Timer #2# End'): The event will be generated when Timer #2# ends counting.
    - **Encoder0Stopped** (Display string: 'Encoder 0 Stopped'): The event will be generated when the Encoder 0 stops for longer than EncoderTimeout.
    - **Encoder1Stopped** (Display string: 'Encoder 1 Stopped'): The event will be generated when the Encoder 1 stops for longer than EncoderTimeout.
    - **Encoder**#2#Stopped (Display string: 'Encoder #2# Stopped'): The event will be generated when the Encoder #2# stops for longer than EncoderTimeout.
    - **Encoder0Restarted** (Display string: 'Encoder 0 Restarted'): The event will be generated when the Encoder 0 restarts moving.
    - **Encoder1Restarted** (Display string: 'Encoder 1 Restarted'): The event will be generated when the Encoder 1 restarts moving.
    - **Encoder**#2#Restarted (Display string: 'Encoder #2# Restarted'): The event will be generated when the Encoder #2# restarts moving.
    - **Line0RisingEdge** (Display string: 'Line 0 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 0.
    - **Line1RisingEdge** (Display string: 'Line 1 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 1.
    - **Line**#2#RisingEdge (Display string: 'Line #2# Rising Edge'): The event will be generated when a Rising Edge is detected on the Line #2#.
    - **Line0FallingEdge** (Display string: 'Line 0 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 0.
    - **Line1FallingEdge** (Display string: 'Line 1 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 1.
    - **Line**#2#FallingEdge (Display string: 'Line #2# Falling Edge'): The event will be generated when a Falling Edge is detected on the Line #2#.
    - **Line0AnyEdge** (Display string: 'Line 0 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 0.
    - **Line1AnyEdge** (Display string: 'Line 1 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 1.
    - **Line**#2#AnyEdge (Display string: 'Line #2# Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line #2#.
    - **LinkTrigger0** (Display string: 'Link Trigger 0'): The event will be generated when a Rising Edge is detected on the LinkTrigger 0.
    - **LinkTrigger1** (Display string: 'Link Trigger 1'): The event will be generated when a Rising Edge is detected on the LinkTrigger 1.
    - **LinkTrigger**#2# (Display string: 'Link Trigger #2#'): The event will be generated when a Rising Edge is detected on the LinkTrigger #2#.
    - **LinkSpeedChange** (Display string: 'Link Speed Change'): The event will be generated when the link speed has changed.
    - **ActionLate** (Display string: 'Action Late'): The event will be generated when a valid scheduled action command is received and is scheduled to be executed at a time that is already past.
    - **Error** (Display string: 'Error'): Device just detected an error during the active Acquisition.
    - **Test** (Display string: 'Test'): The test event will be generated when the device receives the TestEventGenerate command (EventNotification for the Test event is always On).
    - **PrimaryApplicationSwitch** (Display string: 'Primary Application Switch'): The event will be generated when a primary application switchover has been granted (GigE Vision Specific).
    - **Counter2Start** (Display string: 'Counter 2 Start'): The event will be generated when counter 2 starts counting.
    - **Counter3Start** (Display string: 'Counter 3 Start'): The event will be generated when counter 3 starts counting.
    - **Counter4Start** (Display string: 'Counter 4 Start'): The event will be generated when counter 4 starts counting.
    - **Counter5Start** (Display string: 'Counter 5 Start'): The event will be generated when counter 5 starts counting.
    - **Counter6Start** (Display string: 'Counter 6 Start'): The event will be generated when counter 6 starts counting.
    - **Counter7Start** (Display string: 'Counter 7 Start'): The event will be generated when counter 7 starts counting.
    - **Counter8Start** (Display string: 'Counter 8 Start'): The event will be generated when counter 8 starts counting.
    - **Counter9Start** (Display string: 'Counter 9 Start'): The event will be generated when counter 9 starts counting.
    - **Counter10Start** (Display string: 'Counter 10 Start'): The event will be generated when counter 10 starts counting.
    - **Counter11Start** (Display string: 'Counter 11 Start'): The event will be generated when counter 11 starts counting.
    - **Counter12Start** (Display string: 'Counter 12 Start'): The event will be generated when counter 12 starts counting.
    - **Counter13Start** (Display string: 'Counter 13 Start'): The event will be generated when counter 13 starts counting.
    - **Counter14Start** (Display string: 'Counter 14 Start'): The event will be generated when counter 14 starts counting.
    - **Counter15Start** (Display string: 'Counter 15 Start'): The event will be generated when counter 15 starts counting.
    - **Counter2End** (Display string: 'Counter 2 End'): The event will be generated when counter 2 ends counting.
    - **Counter3End** (Display string: 'Counter 3 End'): The event will be generated when counter 3 ends counting.
    - **Counter4End** (Display string: 'Counter 4 End'): The event will be generated when counter 4 ends counting.
    - **Counter5End** (Display string: 'Counter 5 End'): The event will be generated when counter 5 ends counting.
    - **Counter6End** (Display string: 'Counter 6 End'): The event will be generated when counter 6 ends counting.
    - **Counter7End** (Display string: 'Counter 7 End'): The event will be generated when counter 7 ends counting.
    - **Counter8End** (Display string: 'Counter 8 End'): The event will be generated when counter 8 ends counting.
    - **Counter9End** (Display string: 'Counter 9 End'): The event will be generated when counter 9 ends counting.
    - **Counter10End** (Display string: 'Counter 10 End'): The event will be generated when counter 10 ends counting.
    - **Counter11End** (Display string: 'Counter 11 End'): The event will be generated when counter 11 ends counting.
    - **Counter12End** (Display string: 'Counter 12 End'): The event will be generated when counter 12 ends counting.
    - **Counter13End** (Display string: 'Counter 13 End'): The event will be generated when counter 13 ends counting.
    - **Counter14End** (Display string: 'Counter 14 End'): The event will be generated when counter 14 ends counting.
    - **Counter15End** (Display string: 'Counter 15 End'): The event will be generated when counter 15 ends counting.
    - **Timer2Start** (Display string: 'Timer 2 Start'): The event will be generated when Timer 2 starts counting.
    - **Timer3Start** (Display string: 'Timer 3 Start'): The event will be generated when Timer 3 starts counting.
    - **Timer4Start** (Display string: 'Timer 4 Start'): The event will be generated when Timer 4 starts counting.
    - **Timer5Start** (Display string: 'Timer 5 Start'): The event will be generated when Timer 5 starts counting.
    - **Timer6Start** (Display string: 'Timer 6 Start'): The event will be generated when Timer 6 starts counting.
    - **Timer7Start** (Display string: 'Timer 7 Start'): The event will be generated when Timer 7 starts counting.
    - **Timer8Start** (Display string: 'Timer 8 Start'): The event will be generated when Timer 8 starts counting.
    - **Timer9Start** (Display string: 'Timer 9 Start'): The event will be generated when Timer 9 starts counting.
    - **Timer10Start** (Display string: 'Timer 10 Start'): The event will be generated when Timer 10 starts counting.
    - **Timer11Start** (Display string: 'Timer 11 Start'): The event will be generated when Timer 11 starts counting.
    - **Timer12Start** (Display string: 'Timer 12 Start'): The event will be generated when Timer 12 starts counting.
    - **Timer13Start** (Display string: 'Timer 13 Start'): The event will be generated when Timer 13 starts counting.
    - **Timer14Start** (Display string: 'Timer 14 Start'): The event will be generated when Timer 14 starts counting.
    - **Timer15Start** (Display string: 'Timer 15 Start'): The event will be generated when Timer 15 starts counting.
    - **Timer2End** (Display string: 'Timer 2 End'): The event will be generated when Timer 2 ends counting.
    - **Timer3End** (Display string: 'Timer 3 End'): The event will be generated when Timer 3 ends counting.
    - **Timer4End** (Display string: 'Timer 4 End'): The event will be generated when Timer 4 ends counting.
    - **Timer5End** (Display string: 'Timer 5 End'): The event will be generated when Timer 5 ends counting.
    - **Timer6End** (Display string: 'Timer 6 End'): The event will be generated when Timer 6 ends counting.
    - **Timer7End** (Display string: 'Timer 7 End'): The event will be generated when Timer 7 ends counting.
    - **Timer8End** (Display string: 'Timer 8 End'): The event will be generated when Timer 8 ends counting.
    - **Timer9End** (Display string: 'Timer 9 End'): The event will be generated when Timer 9 ends counting.
    - **Timer10End** (Display string: 'Timer 10 End'): The event will be generated when Timer 10 ends counting.
    - **Timer11End** (Display string: 'Timer 11 End'): The event will be generated when Timer 11 ends counting.
    - **Timer12End** (Display string: 'Timer 12 End'): The event will be generated when Timer 12 ends counting.
    - **Timer13End** (Display string: 'Timer 13 End'): The event will be generated when Timer 13 ends counting.
    - **Timer14End** (Display string: 'Timer 14 End'): The event will be generated when Timer 14 ends counting.
    - **Timer15End** (Display string: 'Timer 15 End'): The event will be generated when Timer 15 ends counting.
    - **Encoder2Stopped** (Display string: 'Encoder 2 Stopped'): The event will be generated when the Encoder 2 stops for longer than EncoderTimeout.
    - **Encoder3Stopped** (Display string: 'Encoder 3 Stopped'): The event will be generated when the Encoder 3 stops for longer than EncoderTimeout.
    - **Encoder4Stopped** (Display string: 'Encoder 4 Stopped'): The event will be generated when the Encoder 4 stops for longer than EncoderTimeout.
    - **Encoder5Stopped** (Display string: 'Encoder 5 Stopped'): The event will be generated when the Encoder 5 stops for longer than EncoderTimeout.
    - **Encoder6Stopped** (Display string: 'Encoder 6 Stopped'): The event will be generated when the Encoder 6 stops for longer than EncoderTimeout.
    - **Encoder7Stopped** (Display string: 'Encoder 7 Stopped'): The event will be generated when the Encoder 7 stops for longer than EncoderTimeout.
    - **Encoder8Stopped** (Display string: 'Encoder 8 Stopped'): The event will be generated when the Encoder 8 stops for longer than EncoderTimeout.
    - **Encoder9Stopped** (Display string: 'Encoder 9 Stopped'): The event will be generated when the Encoder 9 stops for longer than EncoderTimeout.
    - **Encoder10Stopped** (Display string: 'Encoder 10 Stopped'): The event will be generated when the Encoder 10 stops for longer than EncoderTimeout.
    - **Encoder11Stopped** (Display string: 'Encoder 11 Stopped'): The event will be generated when the Encoder 11 stops for longer than EncoderTimeout.
    - **Encoder12Stopped** (Display string: 'Encoder 12 Stopped'): The event will be generated when the Encoder 12 stops for longer than EncoderTimeout.
    - **Encoder13Stopped** (Display string: 'Encoder 13 Stopped'): The event will be generated when the Encoder 13 stops for longer than EncoderTimeout.
    - **Encoder14Stopped** (Display string: 'Encoder 14 Stopped'): The event will be generated when the Encoder 14 stops for longer than EncoderTimeout.
    - **Encoder15Stopped** (Display string: 'Encoder 15 Stopped'): The event will be generated when the Encoder 15 stops for longer than EncoderTimeout.
    - **Encoder2Restarted** (Display string: 'Encoder 2 Restarted'): The event will be generated when the Encoder 2 restarts moving.
    - **Encoder3Restarted** (Display string: 'Encoder 3 Restarted'): The event will be generated when the Encoder 3 restarts moving.
    - **Encoder4Restarted** (Display string: 'Encoder 4 Restarted'): The event will be generated when the Encoder 4 restarts moving.
    - **Encoder5Restarted** (Display string: 'Encoder 5 Restarted'): The event will be generated when the Encoder 5 restarts moving.
    - **Encoder6Restarted** (Display string: 'Encoder 6 Restarted'): The event will be generated when the Encoder 6 restarts moving.
    - **Encoder7Restarted** (Display string: 'Encoder 7 Restarted'): The event will be generated when the Encoder 7 restarts moving.
    - **Encoder8Restarted** (Display string: 'Encoder 8 Restarted'): The event will be generated when the Encoder 8 restarts moving.
    - **Encoder9Restarted** (Display string: 'Encoder 9 Restarted'): The event will be generated when the Encoder 9 restarts moving.
    - **Encoder10Restarted** (Display string: 'Encoder 10 Restarted'): The event will be generated when the Encoder 10 restarts moving.
    - **Encoder11Restarted** (Display string: 'Encoder 11 Restarted'): The event will be generated when the Encoder 11 restarts moving.
    - **Encoder12Restarted** (Display string: 'Encoder 12 Restarted'): The event will be generated when the Encoder 12 restarts moving.
    - **Encoder13Restarted** (Display string: 'Encoder 13 Restarted'): The event will be generated when the Encoder 13 restarts moving.
    - **Encoder14Restarted** (Display string: 'Encoder 14 Restarted'): The event will be generated when the Encoder 14 restarts moving.
    - **Encoder15Restarted** (Display string: 'Encoder 15 Restarted'): The event will be generated when the Encoder 15 restarts moving.
    - **Line2RisingEdge** (Display string: 'Line 2 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 2.
    - **Line3RisingEdge** (Display string: 'Line 3 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 3.
    - **Line4RisingEdge** (Display string: 'Line 4 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 4.
    - **Line5RisingEdge** (Display string: 'Line 5 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 5.
    - **Line6RisingEdge** (Display string: 'Line 6 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 6.
    - **Line7RisingEdge** (Display string: 'Line 7 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 7.
    - **Line8RisingEdge** (Display string: 'Line 8 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 8.
    - **Line9RisingEdge** (Display string: 'Line 9 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 9.
    - **Line10RisingEdge** (Display string: 'Line 10 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 10.
    - **Line11RisingEdge** (Display string: 'Line 11 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 11.
    - **Line12RisingEdge** (Display string: 'Line 12 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 12.
    - **Line13RisingEdge** (Display string: 'Line 13 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 13.
    - **Line14RisingEdge** (Display string: 'Line 14 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 14.
    - **Line15RisingEdge** (Display string: 'Line 15 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 15.
    - **Line2FallingEdge** (Display string: 'Line 2 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 2.
    - **Line3FallingEdge** (Display string: 'Line 3 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 3.
    - **Line4FallingEdge** (Display string: 'Line 4 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 4.
    - **Line5FallingEdge** (Display string: 'Line 5 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 5.
    - **Line6FallingEdge** (Display string: 'Line 6 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 6.
    - **Line7FallingEdge** (Display string: 'Line 7 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 7.
    - **Line8FallingEdge** (Display string: 'Line 8 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 8.
    - **Line9FallingEdge** (Display string: 'Line 9 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 9.
    - **Line10FallingEdge** (Display string: 'Line 10 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 10.
    - **Line11FallingEdge** (Display string: 'Line 11 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 11.
    - **Line12FallingEdge** (Display string: 'Line 12 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 12.
    - **Line13FallingEdge** (Display string: 'Line 13 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 13.
    - **Line14FallingEdge** (Display string: 'Line 14 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 14.
    - **Line15FallingEdge** (Display string: 'Line 15 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 15.
    - **Line2AnyEdge** (Display string: 'Line 2 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 2.
    - **Line3AnyEdge** (Display string: 'Line 3 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 3.
    - **Line4AnyEdge** (Display string: 'Line 4 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 4.
    - **Line5AnyEdge** (Display string: 'Line 5 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 5.
    - **Line6AnyEdge** (Display string: 'Line 6 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 6.
    - **Line7AnyEdge** (Display string: 'Line 7 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 7.
    - **Line8AnyEdge** (Display string: 'Line 8 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 8.
    - **Line9AnyEdge** (Display string: 'Line 9 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 9.
    - **Line10AnyEdge** (Display string: 'Line 10 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 10.
    - **Line11AnyEdge** (Display string: 'Line 11 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 11.
    - **Line12AnyEdge** (Display string: 'Line 12 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 12.
    - **Line13AnyEdge** (Display string: 'Line 13 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 13.
    - **Line14AnyEdge** (Display string: 'Line 14 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 14.
    - **Line15AnyEdge** (Display string: 'Line 15 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 15.
    - **Link0Trigger** (Display string: 'Link 0 Trigger')
    - **Link1Trigger** (Display string: 'Link 1 Trigger')
    - **Link2Trigger** (Display string: 'Link 2 Trigger')
    - **Link3Trigger** (Display string: 'Link 3 Trigger')
    - **Link4Trigger** (Display string: 'Link 4 Trigger')
    - **Link5Trigger** (Display string: 'Link 5 Trigger')
    - **Link6Trigger** (Display string: 'Link 6 Trigger')
    - **Link7Trigger** (Display string: 'Link 7 Trigger')
    - **Link8Trigger** (Display string: 'Link 8 Trigger')
    - **Link9Trigger** (Display string: 'Link 9 Trigger')
    - **Link10Trigger** (Display string: 'Link 10 Trigger')
    - **Link11Trigger** (Display string: 'Link 11 Trigger')
    - **Link12Trigger** (Display string: 'Link 12 Trigger')
    - **Link13Trigger** (Display string: 'Link 13 Trigger')
    - **Link14Trigger** (Display string: 'Link 14 Trigger')
    - **Link15Trigger** (Display string: 'Link 15 Trigger')
    - **InterfaceListChanged** (Display string: 'Interface List Changed'): This enumeration value indicates an event that is fired when the list of interfaces has been updated.
    - **InterfaceLost** (Display string: 'Interface Lost'): This enumeration value indicates an event that is raised when the interface connection is lost.
    - **DeviceListChanged** (Display string: 'Device List Changed'): This enumeration value indicates an event that is fired when the list of devices has been updated.
    - **DeviceLost** (Display string: 'Device Lost'): This enumeration value indicates an event that is raised when the local host looses connection to the physical(remote) device.
    - **BufferTooSmall** (Display string: 'Buffer Too Small'): This enumeration value indicates an event that is raised when the buffer was too small to receive the expected amount of data.
    - **BuffersDiscarded** (Display string: 'Buffers Discarded'): This enumeration value indicates an event that is raised when buffers discared by GenTL or device. This event could optionally carry two numeric child data fields EventBuffersDiscardedDeviceCount and EventBuffersDiscardedProducerCount.
    - **BuffersDiscardedDeviceCount** (Display string: 'Buffers Discarded Device Count'): This enumeration value indicates the number of buffers discarded by the device since last fired instance of this event (the producer would get to know about this for example by observing a gap in the block_id sequence).
    - **BuffersDiscardedProducerCount** (Display string: 'Buffers Discarded Producer Count'): This enumeration value indicates the number of buffers discarded by the producer since last fired instance of this event (this would happen e.g. if there are no free buffers available or if given buffer handling mode requires discarding old buffers etc.).

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    eventNotification = property(lib_mvIMPACT_acquire.InterfaceModule_eventNotification_get, doc=r"""
    An enumerated integer property. Activate or deactivate the notification to the host application of the occurrence of the selected Event.
    Activate or deactivate the notification to the host application of the occurrence of the selected Event.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off'): The selected Event notification is disabled.
    - **On** (Display string: 'On'): The selected Event notification is enabled.
    - **Once** (Display string: 'Once'): The selected Event notification is enabled for one event then return to Off state.
    - **GigEVisionEvent** (Display string: 'Gig E Vision Event')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_InterfaceModule

# Register InterfaceModule in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.InterfaceModule_swigregister(InterfaceModule)

class DeviceModule(ComponentCollection):
    r"""
    Category contains items that belong to the device module of the transport layer.
    The Device category contains items that belong to the device module of the transport layer.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::GenICam::DeviceModule** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.DeviceModule_swiginit(self, lib_mvIMPACT_acquire.new_DeviceModule(*args))
    deviceID = property(lib_mvIMPACT_acquire.DeviceModule_deviceID_get, doc=r"""
    A string property. This feature is deprecated (See DeviceSerialNumber).
    Deprecated: 
    This feature is deprecated (See DeviceSerialNumber). It was representing the Device unique identifier (serial number).
    """)
    deviceSerialNumber = property(lib_mvIMPACT_acquire.DeviceModule_deviceSerialNumber_get, doc=r"""
    A string property. Device's serial number.
    Device's serial number. This string is a unique identifier of the device.
    """)
    deviceUserID = property(lib_mvIMPACT_acquire.DeviceModule_deviceUserID_get, doc=r"""
    A string property. User-programmable device identifier.
    User-programmable device identifier.
    """)
    deviceVendorName = property(lib_mvIMPACT_acquire.DeviceModule_deviceVendorName_get, doc=r"""
    A string property. Name of the manufacturer of the device.
    Name of the manufacturer of the device.
    """)
    deviceModelName = property(lib_mvIMPACT_acquire.DeviceModule_deviceModelName_get, doc=r"""
    A string property. Model of the device.
    Model of the device.
    """)
    deviceFamilyName = property(lib_mvIMPACT_acquire.DeviceModule_deviceFamilyName_get, doc=r"""
    A string property. Identifier of the product family of the device.
    Identifier of the product family of the device.
    """)
    deviceVersion = property(lib_mvIMPACT_acquire.DeviceModule_deviceVersion_get, doc=r"""
    A string property. Version of the device.
    Version of the device.
    """)
    deviceManufacturerInfo = property(lib_mvIMPACT_acquire.DeviceModule_deviceManufacturerInfo_get, doc=r"""
    A string property. Manufacturer information about the device.
    Manufacturer information about the device.
    """)
    deviceType = property(lib_mvIMPACT_acquire.DeviceModule_deviceType_get, doc=r"""
    An enumerated integer property. Returns the device type.
    Returns the device type.

    The following string values might be valid for this feature:
    - **Transmitter** (Display string: 'Transmitter'): Data stream transmitter device.
    - **Receiver** (Display string: 'Receiver'): Data stream receiver device.
    - **Transceiver** (Display string: 'Transceiver'): Data stream receiver and transmitter device.
    - **Peripheral** (Display string: 'Peripheral'): Controllable device (with no data stream handling).
    - **Mixed** (Display string: 'Mixed'): This enumeration value indicates that this is a device for a mixed protocol.
    - **Custom** (Display string: 'Custom'): This enumeration value indicates that this is a device for a custom protocol.
    - **GEV** (Display string: 'GigE Vision'): This enumeration value indicates that this is a device for the GigE Vision protocol.
    - **CameraLink** (Display string: 'CameraLink'): This enumeration value indicates that this is a device for the CameraLink protocol.
    - **CoaXPress** (Display string: 'CoaXPress'): This enumeration value indicates that this is a device for the CoaXPress protocol.
    - **CameraLinkHS** (Display string: 'CameraLink HS'): This enumeration value indicates that this is a device for the CameraLink HS protocol.
    - **U3V** (Display string: 'USB3 Vision'): This enumeration value indicates that this is a device for the USB3 Vision protocol.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    deviceDisplayName = property(lib_mvIMPACT_acquire.DeviceModule_deviceDisplayName_get, doc=r"""
    A string property. Indicates user readable name for the remote device.
    This is a read only element. It is a string that indicates user readable name for the remote device model.
    """)
    deviceTimestampFrequency = property(lib_mvIMPACT_acquire.DeviceModule_deviceTimestampFrequency_get, doc=r"""
    An integer property. Indicates the tick-frequency of the timestamp clock of the remote device.
    Indicates the tick-frequency of the timestamp clock of the remote device.
    """)
    deviceAccessStatus = property(lib_mvIMPACT_acquire.DeviceModule_deviceAccessStatus_get, doc=r"""
    An enumerated integer property. Indicates the current access status for the device.
    This is a read only feature. This enumeration gives the device's access status at the moment of the last execution of the DeviceUpdateList command. This value only changes on execution of the DeviceUpdateList command.

    The following string values might be valid for this feature:
    - **Unknown** (Display string: 'Unknown'): This enumeration value indicates that the device accessibility is not known.
    - **ReadWrite** (Display string: 'Read/Write'): This enumeration value indicates that full access to the device is available.
    - **ReadOnly** (Display string: 'Read Only'): This enumeration value indicates that read access to the device is available.
    - **NoAccess** (Display string: 'No Access'): This enumeration value indicates that no access to the device is available.
    - **Busy** (Display string: 'Busy'): This enumeration value indicates that the device is already opened by another entity.
    - **OpenReadWrite** (Display string: 'Open Read Write'): This enumeration value indicates that the device is open in Read/Write mode by this GenTL host.
    - **OpenReadOnly** (Display string: 'Open Read Only'): This enumeration value indicates that the device is open in Read only mode by this GenTL host.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    deviceChunkDataFormat = property(lib_mvIMPACT_acquire.DeviceModule_deviceChunkDataFormat_get, doc=r"""
    An enumerated integer property. Indicates the chunk data format used by the remote device.
    This is a read only feature. This enumeration provides a value that indicates the chunk data format used by the remote device.

    The following string values might be valid for this feature:
    - **None** (Display string: 'None'): This enumeration value indicates that the device does not use chunk data at all.
    - **GigEVision** (Display string: 'GigE Vision'): This enumeration value indicates that the device formats the chunk data using chunk data format defined by GigE Vision specification version 1.x. The chunk data decoding algorithm (chunk adapter) common for the GigE Vision devices can be used.
    - **Custom** (Display string: 'Custom'): This enumeration value indicates that the device formats the chunk data using a custom, non-standard format. Without a-priori additional knowledge about the device and its implementation, the GenTL Consumer should always use the generic chunk adapter to decode the chunk data, not making any assumptions about the internal event data layout..

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    deviceEventDataFormat = property(lib_mvIMPACT_acquire.DeviceModule_deviceEventDataFormat_get, doc=r"""
    An enumerated integer property. Indicates the event data format used by the remote device.
    This is a read only feature. This enumeration provides a value that indicates the event data format used by the remote device.

    The following string values might be valid for this feature:
    - **None** (Display string: 'None'): This enumeration value indicates that the device does not use event data at all.
    - **GigEVision** (Display string: 'GigE Vision'): This enumeration value indicates that the device formats the event data using the event data format defined by GigE Vision specification version 1.x. The event data decoding algorithm (event adapter) common for the GigE Vision devices can be used.
    - **GigEVisionExtendedId** (Display string: 'GigE Vision Extended Id'): This enumeration value indicates that the device formats the event data using the event data format defined by GigE Vision specification version 2.x. The event data decoding algorithm (event adapter) common for the GigE Vision devices can be used.
    - **Custom** (Display string: 'Custom'): This enumeration value indicates that the device formats the event data using a custom, non-standard format. Without a-priori additional knowledge about the device and its implementation, the GenTL Consumer should always use the generic event adapter to decode the event data, not making any assumptions about the internal event data layout..

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    gevDeviceMACAddress = property(lib_mvIMPACT_acquire.DeviceModule_gevDeviceMACAddress_get, doc=r"""
    An integer property. Indicates the 48-bit MAC address of the GVCP interface of the selected remote device.
    This is a read only element. It indicates the 48-bit MAC address of the GVCP interface of the selected remote device.
    """)
    gevDeviceIPAddress = property(lib_mvIMPACT_acquire.DeviceModule_gevDeviceIPAddress_get, doc=r"""
    An integer property. Indicates the current IP address of the GVCP interface of the selected remote device.
    This is a read only element. It indicates the current IP address of the GVCP interface of the selected remote device.
    """)
    gevDeviceSubnetMask = property(lib_mvIMPACT_acquire.DeviceModule_gevDeviceSubnetMask_get, doc=r"""
    An integer property. Indicates the current subnet mask of the GVCP interface of the selected remote device.
    This is a read only element. It indicates the current subnet mask of the GVCP interface of the selected remote device.
    """)
    gevDeviceGateway = property(lib_mvIMPACT_acquire.DeviceModule_gevDeviceGateway_get, doc=r"""
    An integer property. Indicates the current gateway of the GVCP interface of the selected remote device.
    This is a read only element. It indicates the current gateway of the GVCP interface of the selected remote device.
    """)
    gevVersionMajor = property(lib_mvIMPACT_acquire.DeviceModule_gevVersionMajor_get, doc=r"""
    An integer property. Indicates the major version number of the GigE Vision specification this device complies with.
    This is a read only element. It indicates the major version number of the GigE Vision specification this device complies with.
    """)
    gevVersionMinor = property(lib_mvIMPACT_acquire.DeviceModule_gevVersionMinor_get, doc=r"""
    An integer property. Indicates the minor version number of the GigE Vision specification this device complies with.
    This is a read only element. It indicates the minor version number of the GigE Vision specification this device complies with.
    """)
    genCPVersionMajor = property(lib_mvIMPACT_acquire.DeviceModule_genCPVersionMajor_get, doc=r"""
    An integer property. Indicates the major version number of the GenCP specification this device complies with.
    This is a read only element. It indicates the major version number of the GenCP specification this device complies with.
    """)
    genCPVersionMinor = property(lib_mvIMPACT_acquire.DeviceModule_genCPVersionMinor_get, doc=r"""
    An integer property. Indicates the minor version number of the GenCP specification this device complies with.
    This is a read only element. It indicates the minor version number of the GenCP specification this device complies with.
    """)
    u3vVersionMajor = property(lib_mvIMPACT_acquire.DeviceModule_u3vVersionMajor_get, doc=r"""
    An integer property. Indicates the major version number of the USB3 Vision specification this device complies with.
    This is a read only element. It indicates the major version number of the USB3 Vision specification this device complies with.
    """)
    u3vVersionMinor = property(lib_mvIMPACT_acquire.DeviceModule_u3vVersionMinor_get, doc=r"""
    An integer property. Indicates the minor version number of the USB3 Vision specification this device complies with.
    This is a read only element. It indicates the minor version number of the USB3 Vision specification this device complies with.
    """)
    deviceEndianessMechanism = property(lib_mvIMPACT_acquire.DeviceModule_deviceEndianessMechanism_get, doc=r"""
    An enumerated integer property. Identifies the endianess mode to be used for this device.
    This is a read only feature. This enumeration provides a value that indicates the endianess mode to be used for this device.

    The following string values might be valid for this feature:
    - **Legacy** (Display string: 'Legacy'): This enumeration value indicates that this device shall be handled according to GenICam Schema 1.0.
    - **Standard** (Display string: 'Standard'): This enumeration value indicates that this device shall be handled according to GenICam Schema 1.1 and later.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    linkCommandTimeout = property(lib_mvIMPACT_acquire.DeviceModule_linkCommandTimeout_get, doc=r"""
    A floating point property. Specifies application timeout for the control channel communication.
    The feature specifies application timeout for the control channel communication. It defines the application timeout, and it is related to the device feature DeviceLinkCommandTimeout specifying the maximum time for handling a command in the device. Up to DeviceLinkCommandRetryCount attempts with this timeout are made before a command fails with a timout error.
    """)
    linkCommandRetryCount = property(lib_mvIMPACT_acquire.DeviceModule_linkCommandRetryCount_get, doc=r"""
    An integer property. Specifies maximum number of tries before failing the control channel commands.
    This feature specifies maximum number of tries before failing the control channel commands.
    """)
    streamSelector = property(lib_mvIMPACT_acquire.DeviceModule_streamSelector_get, doc=r"""
    An integer property. Selects the stream channel.
    Selects the stream channel.
    """)
    streamID = property(lib_mvIMPACT_acquire.DeviceModule_streamID_get, doc=r"""
    A string property. Device wide unique ID of the selected stream.
    This is a read only element. It is a string that indicates a device wide unique identifier of the selected stream.
    """)
    eventSelector = property(lib_mvIMPACT_acquire.DeviceModule_eventSelector_get, doc=r"""
    An enumerated integer property. Selects which Event to signal to the host application.
    Selects which Event to signal to the host application.

    The following string values might be valid for this feature:
    - **AcquisitionTrigger** (Display string: 'Acquisition Trigger'): Device just received a trigger for the Acquisition of one or many Frames.
    - **AcquisitionTriggerMissed** (Display string: 'Acquisition Trigger Missed'): Device just missed a trigger for the Acquisition of one or many Frames.
    - **AcquisitionStart** (Display string: 'Acquisition Start'): Device just started the Acquisition of one or many Frames.
    - **AcquisitionEnd** (Display string: 'Acquisition End'): Device just completed the Acquisition of one or many Frames.
    - **AcquisitionTransferStart** (Display string: 'Acquisition Transfer Start'): Device just started the transfer of one or many Frames.
    - **AcquisitionTransferEnd** (Display string: 'Acquisition Transfer End'): Device just completed the transfer of one or many Frames.
    - **AcquisitionError** (Display string: 'Acquisition Error'): Device just detected an error during the active Acquisition.
    - **FrameBurstStart** (Display string: 'Frame Burst Start'): Device just started the capture of a burst of Frames.
    - **FrameBurstEnd** (Display string: 'Frame Burst End'): Device just completed the capture of a burst of Frames.
    - **FrameTrigger** (Display string: 'Frame Trigger'): Device just received a trigger to start the capture of one Frame.
    - **FrameTriggerMissed** (Display string: 'Frame Trigger Missed'): Device just missed a trigger to start the capture of one Frame.
    - **FrameStart** (Display string: 'Frame Start'): Device just started the capture of one Frame.
    - **FrameEnd** (Display string: 'Frame End'): Device just completed the capture of one Frame.
    - **FrameTransferStart** (Display string: 'Frame Transfer Start'): Device just started the transfer of one Frame.
    - **FrameTransferEnd** (Display string: 'Frame Transfer End'): Device just completed the transfer of one Frame.
    - **LineTrigger** (Display string: 'Line Trigger'): Device just received a trigger to start the capture of one Line.
    - **LineTriggerMissed** (Display string: 'Line Trigger Missed'): Device just missed a trigger to start the capture of one Line.
    - **LineStart** (Display string: 'Line Start'): Device just started the capture of one Line.
    - **LineEnd** (Display string: 'Line End'): Device just completed the capture of one Line.
    - **ExposureStart** (Display string: 'Exposure Start'): Device just started the exposure of one Frame (or Line).
    - **ExposureEnd** (Display string: 'Exposure End'): Device just completed the exposure of one Frame (or Line).
    - **Stream0TransferStart** (Display string: 'Stream 0 Transfer Start'): Device just started the transfer of one or many Blocks.
    - **Stream0TransferEnd** (Display string: 'Stream 0 Transfer End'): Device just completed the transfer of one or many Blocks.
    - **Stream0TransferPause** (Display string: 'Stream 0 Transfer Pause'): Device just paused the transfer.
    - **Stream0TransferResume** (Display string: 'Stream 0 Transfer Resume'): Device just resumed the transfer.
    - **Stream0TransferBlockStart** (Display string: 'Stream 0 Transfer Block Start'): Device just started the transfer of one Block.
    - **Stream0TransferBlockEnd** (Display string: 'Stream 0 Transfer Block End'): Device just completed the transfer of one Block.
    - **Stream0TransferBlockTrigger** (Display string: 'Stream 0 Transfer Block Trigger'): Device just received a trigger to start the transfer of one Block.
    - **Stream0TransferBurstStart** (Display string: 'Stream 0 Transfer Burst Start'): Device just started the transfer of a burst of Blocks.
    - **Stream0TransferBurstEnd** (Display string: 'Stream 0 Transfer Burst End'): Device just completed the transfer of a burst of Blocks.
    - **Stream0TransferOverflow** (Display string: 'Stream 0 Transfer Overflow'): Device transfer queue overflowed.
    - **SequencerSetChange** (Display string: 'Sequencer Set Change'): Device sequencer set has changed.
    - **Counter0Start** (Display string: 'Counter 0 Start'): The event will be generated when counter 0 starts counting.
    - **Counter1Start** (Display string: 'Counter 1 Start'): The event will be generated when counter 1 starts counting.
    - **Counter**#2#Start (Display string: 'Counter #2# Start'): The event will be generated when counter #2# starts counting.
    - **Counter0End** (Display string: 'Counter 0 End'): The event will be generated when counter 0 ends counting.
    - **Counter1End** (Display string: 'Counter 1 End'): The event will be generated when counter 1 ends counting.
    - **Counter**#2#End (Display string: 'Counter #2# End'): The event will be generated when counter #2# ends counting.
    - **Timer0Start** (Display string: 'Timer 0 Start'): The event will be generated when Timer 0 starts counting.
    - **Timer1Start** (Display string: 'Timer 1 Start'): The event will be generated when Timer 1 starts counting.
    - **Timer**#2#Start (Display string: 'Timer #2# Start'): The event will be generated when Timer #2# starts counting.
    - **Timer0End** (Display string: 'Timer 0 End'): The event will be generated when Timer 0 ends counting.
    - **Timer1End** (Display string: 'Timer 1 End'): The event will be generated when Timer 1 ends counting.
    - **Timer**#2#End (Display string: 'Timer #2# End'): The event will be generated when Timer #2# ends counting.
    - **Encoder0Stopped** (Display string: 'Encoder 0 Stopped'): The event will be generated when the Encoder 0 stops for longer than EncoderTimeout.
    - **Encoder1Stopped** (Display string: 'Encoder 1 Stopped'): The event will be generated when the Encoder 1 stops for longer than EncoderTimeout.
    - **Encoder**#2#Stopped (Display string: 'Encoder #2# Stopped'): The event will be generated when the Encoder #2# stops for longer than EncoderTimeout.
    - **Encoder0Restarted** (Display string: 'Encoder 0 Restarted'): The event will be generated when the Encoder 0 restarts moving.
    - **Encoder1Restarted** (Display string: 'Encoder 1 Restarted'): The event will be generated when the Encoder 1 restarts moving.
    - **Encoder**#2#Restarted (Display string: 'Encoder #2# Restarted'): The event will be generated when the Encoder #2# restarts moving.
    - **Line0RisingEdge** (Display string: 'Line 0 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 0.
    - **Line1RisingEdge** (Display string: 'Line 1 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 1.
    - **Line**#2#RisingEdge (Display string: 'Line #2# Rising Edge'): The event will be generated when a Rising Edge is detected on the Line #2#.
    - **Line0FallingEdge** (Display string: 'Line 0 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 0.
    - **Line1FallingEdge** (Display string: 'Line 1 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 1.
    - **Line**#2#FallingEdge (Display string: 'Line #2# Falling Edge'): The event will be generated when a Falling Edge is detected on the Line #2#.
    - **Line0AnyEdge** (Display string: 'Line 0 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 0.
    - **Line1AnyEdge** (Display string: 'Line 1 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 1.
    - **Line**#2#AnyEdge (Display string: 'Line #2# Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line #2#.
    - **LinkTrigger0** (Display string: 'Link Trigger 0'): The event will be generated when a Rising Edge is detected on the LinkTrigger 0.
    - **LinkTrigger1** (Display string: 'Link Trigger 1'): The event will be generated when a Rising Edge is detected on the LinkTrigger 1.
    - **LinkTrigger**#2# (Display string: 'Link Trigger #2#'): The event will be generated when a Rising Edge is detected on the LinkTrigger #2#.
    - **LinkSpeedChange** (Display string: 'Link Speed Change'): The event will be generated when the link speed has changed.
    - **ActionLate** (Display string: 'Action Late'): The event will be generated when a valid scheduled action command is received and is scheduled to be executed at a time that is already past.
    - **Error** (Display string: 'Error'): Device just detected an error during the active Acquisition.
    - **Test** (Display string: 'Test'): The test event will be generated when the device receives the TestEventGenerate command (EventNotification for the Test event is always On).
    - **PrimaryApplicationSwitch** (Display string: 'Primary Application Switch'): The event will be generated when a primary application switchover has been granted (GigE Vision Specific).
    - **Counter2Start** (Display string: 'Counter 2 Start'): The event will be generated when counter 2 starts counting.
    - **Counter3Start** (Display string: 'Counter 3 Start'): The event will be generated when counter 3 starts counting.
    - **Counter4Start** (Display string: 'Counter 4 Start'): The event will be generated when counter 4 starts counting.
    - **Counter5Start** (Display string: 'Counter 5 Start'): The event will be generated when counter 5 starts counting.
    - **Counter6Start** (Display string: 'Counter 6 Start'): The event will be generated when counter 6 starts counting.
    - **Counter7Start** (Display string: 'Counter 7 Start'): The event will be generated when counter 7 starts counting.
    - **Counter8Start** (Display string: 'Counter 8 Start'): The event will be generated when counter 8 starts counting.
    - **Counter9Start** (Display string: 'Counter 9 Start'): The event will be generated when counter 9 starts counting.
    - **Counter10Start** (Display string: 'Counter 10 Start'): The event will be generated when counter 10 starts counting.
    - **Counter11Start** (Display string: 'Counter 11 Start'): The event will be generated when counter 11 starts counting.
    - **Counter12Start** (Display string: 'Counter 12 Start'): The event will be generated when counter 12 starts counting.
    - **Counter13Start** (Display string: 'Counter 13 Start'): The event will be generated when counter 13 starts counting.
    - **Counter14Start** (Display string: 'Counter 14 Start'): The event will be generated when counter 14 starts counting.
    - **Counter15Start** (Display string: 'Counter 15 Start'): The event will be generated when counter 15 starts counting.
    - **Counter2End** (Display string: 'Counter 2 End'): The event will be generated when counter 2 ends counting.
    - **Counter3End** (Display string: 'Counter 3 End'): The event will be generated when counter 3 ends counting.
    - **Counter4End** (Display string: 'Counter 4 End'): The event will be generated when counter 4 ends counting.
    - **Counter5End** (Display string: 'Counter 5 End'): The event will be generated when counter 5 ends counting.
    - **Counter6End** (Display string: 'Counter 6 End'): The event will be generated when counter 6 ends counting.
    - **Counter7End** (Display string: 'Counter 7 End'): The event will be generated when counter 7 ends counting.
    - **Counter8End** (Display string: 'Counter 8 End'): The event will be generated when counter 8 ends counting.
    - **Counter9End** (Display string: 'Counter 9 End'): The event will be generated when counter 9 ends counting.
    - **Counter10End** (Display string: 'Counter 10 End'): The event will be generated when counter 10 ends counting.
    - **Counter11End** (Display string: 'Counter 11 End'): The event will be generated when counter 11 ends counting.
    - **Counter12End** (Display string: 'Counter 12 End'): The event will be generated when counter 12 ends counting.
    - **Counter13End** (Display string: 'Counter 13 End'): The event will be generated when counter 13 ends counting.
    - **Counter14End** (Display string: 'Counter 14 End'): The event will be generated when counter 14 ends counting.
    - **Counter15End** (Display string: 'Counter 15 End'): The event will be generated when counter 15 ends counting.
    - **Timer2Start** (Display string: 'Timer 2 Start'): The event will be generated when Timer 2 starts counting.
    - **Timer3Start** (Display string: 'Timer 3 Start'): The event will be generated when Timer 3 starts counting.
    - **Timer4Start** (Display string: 'Timer 4 Start'): The event will be generated when Timer 4 starts counting.
    - **Timer5Start** (Display string: 'Timer 5 Start'): The event will be generated when Timer 5 starts counting.
    - **Timer6Start** (Display string: 'Timer 6 Start'): The event will be generated when Timer 6 starts counting.
    - **Timer7Start** (Display string: 'Timer 7 Start'): The event will be generated when Timer 7 starts counting.
    - **Timer8Start** (Display string: 'Timer 8 Start'): The event will be generated when Timer 8 starts counting.
    - **Timer9Start** (Display string: 'Timer 9 Start'): The event will be generated when Timer 9 starts counting.
    - **Timer10Start** (Display string: 'Timer 10 Start'): The event will be generated when Timer 10 starts counting.
    - **Timer11Start** (Display string: 'Timer 11 Start'): The event will be generated when Timer 11 starts counting.
    - **Timer12Start** (Display string: 'Timer 12 Start'): The event will be generated when Timer 12 starts counting.
    - **Timer13Start** (Display string: 'Timer 13 Start'): The event will be generated when Timer 13 starts counting.
    - **Timer14Start** (Display string: 'Timer 14 Start'): The event will be generated when Timer 14 starts counting.
    - **Timer15Start** (Display string: 'Timer 15 Start'): The event will be generated when Timer 15 starts counting.
    - **Timer2End** (Display string: 'Timer 2 End'): The event will be generated when Timer 2 ends counting.
    - **Timer3End** (Display string: 'Timer 3 End'): The event will be generated when Timer 3 ends counting.
    - **Timer4End** (Display string: 'Timer 4 End'): The event will be generated when Timer 4 ends counting.
    - **Timer5End** (Display string: 'Timer 5 End'): The event will be generated when Timer 5 ends counting.
    - **Timer6End** (Display string: 'Timer 6 End'): The event will be generated when Timer 6 ends counting.
    - **Timer7End** (Display string: 'Timer 7 End'): The event will be generated when Timer 7 ends counting.
    - **Timer8End** (Display string: 'Timer 8 End'): The event will be generated when Timer 8 ends counting.
    - **Timer9End** (Display string: 'Timer 9 End'): The event will be generated when Timer 9 ends counting.
    - **Timer10End** (Display string: 'Timer 10 End'): The event will be generated when Timer 10 ends counting.
    - **Timer11End** (Display string: 'Timer 11 End'): The event will be generated when Timer 11 ends counting.
    - **Timer12End** (Display string: 'Timer 12 End'): The event will be generated when Timer 12 ends counting.
    - **Timer13End** (Display string: 'Timer 13 End'): The event will be generated when Timer 13 ends counting.
    - **Timer14End** (Display string: 'Timer 14 End'): The event will be generated when Timer 14 ends counting.
    - **Timer15End** (Display string: 'Timer 15 End'): The event will be generated when Timer 15 ends counting.
    - **Encoder2Stopped** (Display string: 'Encoder 2 Stopped'): The event will be generated when the Encoder 2 stops for longer than EncoderTimeout.
    - **Encoder3Stopped** (Display string: 'Encoder 3 Stopped'): The event will be generated when the Encoder 3 stops for longer than EncoderTimeout.
    - **Encoder4Stopped** (Display string: 'Encoder 4 Stopped'): The event will be generated when the Encoder 4 stops for longer than EncoderTimeout.
    - **Encoder5Stopped** (Display string: 'Encoder 5 Stopped'): The event will be generated when the Encoder 5 stops for longer than EncoderTimeout.
    - **Encoder6Stopped** (Display string: 'Encoder 6 Stopped'): The event will be generated when the Encoder 6 stops for longer than EncoderTimeout.
    - **Encoder7Stopped** (Display string: 'Encoder 7 Stopped'): The event will be generated when the Encoder 7 stops for longer than EncoderTimeout.
    - **Encoder8Stopped** (Display string: 'Encoder 8 Stopped'): The event will be generated when the Encoder 8 stops for longer than EncoderTimeout.
    - **Encoder9Stopped** (Display string: 'Encoder 9 Stopped'): The event will be generated when the Encoder 9 stops for longer than EncoderTimeout.
    - **Encoder10Stopped** (Display string: 'Encoder 10 Stopped'): The event will be generated when the Encoder 10 stops for longer than EncoderTimeout.
    - **Encoder11Stopped** (Display string: 'Encoder 11 Stopped'): The event will be generated when the Encoder 11 stops for longer than EncoderTimeout.
    - **Encoder12Stopped** (Display string: 'Encoder 12 Stopped'): The event will be generated when the Encoder 12 stops for longer than EncoderTimeout.
    - **Encoder13Stopped** (Display string: 'Encoder 13 Stopped'): The event will be generated when the Encoder 13 stops for longer than EncoderTimeout.
    - **Encoder14Stopped** (Display string: 'Encoder 14 Stopped'): The event will be generated when the Encoder 14 stops for longer than EncoderTimeout.
    - **Encoder15Stopped** (Display string: 'Encoder 15 Stopped'): The event will be generated when the Encoder 15 stops for longer than EncoderTimeout.
    - **Encoder2Restarted** (Display string: 'Encoder 2 Restarted'): The event will be generated when the Encoder 2 restarts moving.
    - **Encoder3Restarted** (Display string: 'Encoder 3 Restarted'): The event will be generated when the Encoder 3 restarts moving.
    - **Encoder4Restarted** (Display string: 'Encoder 4 Restarted'): The event will be generated when the Encoder 4 restarts moving.
    - **Encoder5Restarted** (Display string: 'Encoder 5 Restarted'): The event will be generated when the Encoder 5 restarts moving.
    - **Encoder6Restarted** (Display string: 'Encoder 6 Restarted'): The event will be generated when the Encoder 6 restarts moving.
    - **Encoder7Restarted** (Display string: 'Encoder 7 Restarted'): The event will be generated when the Encoder 7 restarts moving.
    - **Encoder8Restarted** (Display string: 'Encoder 8 Restarted'): The event will be generated when the Encoder 8 restarts moving.
    - **Encoder9Restarted** (Display string: 'Encoder 9 Restarted'): The event will be generated when the Encoder 9 restarts moving.
    - **Encoder10Restarted** (Display string: 'Encoder 10 Restarted'): The event will be generated when the Encoder 10 restarts moving.
    - **Encoder11Restarted** (Display string: 'Encoder 11 Restarted'): The event will be generated when the Encoder 11 restarts moving.
    - **Encoder12Restarted** (Display string: 'Encoder 12 Restarted'): The event will be generated when the Encoder 12 restarts moving.
    - **Encoder13Restarted** (Display string: 'Encoder 13 Restarted'): The event will be generated when the Encoder 13 restarts moving.
    - **Encoder14Restarted** (Display string: 'Encoder 14 Restarted'): The event will be generated when the Encoder 14 restarts moving.
    - **Encoder15Restarted** (Display string: 'Encoder 15 Restarted'): The event will be generated when the Encoder 15 restarts moving.
    - **Line2RisingEdge** (Display string: 'Line 2 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 2.
    - **Line3RisingEdge** (Display string: 'Line 3 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 3.
    - **Line4RisingEdge** (Display string: 'Line 4 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 4.
    - **Line5RisingEdge** (Display string: 'Line 5 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 5.
    - **Line6RisingEdge** (Display string: 'Line 6 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 6.
    - **Line7RisingEdge** (Display string: 'Line 7 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 7.
    - **Line8RisingEdge** (Display string: 'Line 8 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 8.
    - **Line9RisingEdge** (Display string: 'Line 9 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 9.
    - **Line10RisingEdge** (Display string: 'Line 10 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 10.
    - **Line11RisingEdge** (Display string: 'Line 11 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 11.
    - **Line12RisingEdge** (Display string: 'Line 12 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 12.
    - **Line13RisingEdge** (Display string: 'Line 13 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 13.
    - **Line14RisingEdge** (Display string: 'Line 14 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 14.
    - **Line15RisingEdge** (Display string: 'Line 15 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 15.
    - **Line2FallingEdge** (Display string: 'Line 2 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 2.
    - **Line3FallingEdge** (Display string: 'Line 3 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 3.
    - **Line4FallingEdge** (Display string: 'Line 4 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 4.
    - **Line5FallingEdge** (Display string: 'Line 5 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 5.
    - **Line6FallingEdge** (Display string: 'Line 6 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 6.
    - **Line7FallingEdge** (Display string: 'Line 7 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 7.
    - **Line8FallingEdge** (Display string: 'Line 8 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 8.
    - **Line9FallingEdge** (Display string: 'Line 9 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 9.
    - **Line10FallingEdge** (Display string: 'Line 10 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 10.
    - **Line11FallingEdge** (Display string: 'Line 11 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 11.
    - **Line12FallingEdge** (Display string: 'Line 12 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 12.
    - **Line13FallingEdge** (Display string: 'Line 13 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 13.
    - **Line14FallingEdge** (Display string: 'Line 14 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 14.
    - **Line15FallingEdge** (Display string: 'Line 15 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 15.
    - **Line2AnyEdge** (Display string: 'Line 2 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 2.
    - **Line3AnyEdge** (Display string: 'Line 3 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 3.
    - **Line4AnyEdge** (Display string: 'Line 4 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 4.
    - **Line5AnyEdge** (Display string: 'Line 5 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 5.
    - **Line6AnyEdge** (Display string: 'Line 6 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 6.
    - **Line7AnyEdge** (Display string: 'Line 7 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 7.
    - **Line8AnyEdge** (Display string: 'Line 8 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 8.
    - **Line9AnyEdge** (Display string: 'Line 9 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 9.
    - **Line10AnyEdge** (Display string: 'Line 10 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 10.
    - **Line11AnyEdge** (Display string: 'Line 11 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 11.
    - **Line12AnyEdge** (Display string: 'Line 12 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 12.
    - **Line13AnyEdge** (Display string: 'Line 13 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 13.
    - **Line14AnyEdge** (Display string: 'Line 14 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 14.
    - **Line15AnyEdge** (Display string: 'Line 15 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 15.
    - **Link0Trigger** (Display string: 'Link 0 Trigger')
    - **Link1Trigger** (Display string: 'Link 1 Trigger')
    - **Link2Trigger** (Display string: 'Link 2 Trigger')
    - **Link3Trigger** (Display string: 'Link 3 Trigger')
    - **Link4Trigger** (Display string: 'Link 4 Trigger')
    - **Link5Trigger** (Display string: 'Link 5 Trigger')
    - **Link6Trigger** (Display string: 'Link 6 Trigger')
    - **Link7Trigger** (Display string: 'Link 7 Trigger')
    - **Link8Trigger** (Display string: 'Link 8 Trigger')
    - **Link9Trigger** (Display string: 'Link 9 Trigger')
    - **Link10Trigger** (Display string: 'Link 10 Trigger')
    - **Link11Trigger** (Display string: 'Link 11 Trigger')
    - **Link12Trigger** (Display string: 'Link 12 Trigger')
    - **Link13Trigger** (Display string: 'Link 13 Trigger')
    - **Link14Trigger** (Display string: 'Link 14 Trigger')
    - **Link15Trigger** (Display string: 'Link 15 Trigger')
    - **InterfaceListChanged** (Display string: 'Interface List Changed'): This enumeration value indicates an event that is fired when the list of interfaces has been updated.
    - **InterfaceLost** (Display string: 'Interface Lost'): This enumeration value indicates an event that is raised when the interface connection is lost.
    - **DeviceListChanged** (Display string: 'Device List Changed'): This enumeration value indicates an event that is fired when the list of devices has been updated.
    - **DeviceLost** (Display string: 'Device Lost'): This enumeration value indicates an event that is raised when the local host looses connection to the physical(remote) device.
    - **BufferTooSmall** (Display string: 'Buffer Too Small'): This enumeration value indicates an event that is raised when the buffer was too small to receive the expected amount of data.
    - **BuffersDiscarded** (Display string: 'Buffers Discarded'): This enumeration value indicates an event that is raised when buffers discared by GenTL or device. This event could optionally carry two numeric child data fields EventBuffersDiscardedDeviceCount and EventBuffersDiscardedProducerCount.
    - **BuffersDiscardedDeviceCount** (Display string: 'Buffers Discarded Device Count'): This enumeration value indicates the number of buffers discarded by the device since last fired instance of this event (the producer would get to know about this for example by observing a gap in the block_id sequence).
    - **BuffersDiscardedProducerCount** (Display string: 'Buffers Discarded Producer Count'): This enumeration value indicates the number of buffers discarded by the producer since last fired instance of this event (this would happen e.g. if there are no free buffers available or if given buffer handling mode requires discarding old buffers etc.).

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    eventNotification = property(lib_mvIMPACT_acquire.DeviceModule_eventNotification_get, doc=r"""
    An enumerated integer property. Activate or deactivate the notification to the host application of the occurrence of the selected Event.
    Activate or deactivate the notification to the host application of the occurrence of the selected Event.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off'): The selected Event notification is disabled.
    - **On** (Display string: 'On'): The selected Event notification is enabled.
    - **Once** (Display string: 'Once'): The selected Event notification is enabled for one event then return to Off state.
    - **GigEVisionEvent** (Display string: 'Gig E Vision Event')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_DeviceModule

# Register DeviceModule in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.DeviceModule_swigregister(DeviceModule)

class DataStreamModule(ComponentCollection):
    r"""
    Category that contains items that belong to the data stream module of the transport layer.
    The DataStream category contains items that belong to the data stream module of the transport layer.
    """

    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"""
         Constructs a new **mvIMPACT::acquire::GenICam::DataStreamModule** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type index: int
        :param index: [in] The *index* of the instance this object shall be created for. Passing an invalid index will raise an exception.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.DataStreamModule_swiginit(self, lib_mvIMPACT_acquire.new_DataStreamModule(*args))
    streamID = property(lib_mvIMPACT_acquire.DataStreamModule_streamID_get, doc=r"""
    A string property. Device wide unique ID of the selected stream.
    This is a read only element. It is a string that indicates a device wide unique identifier of the selected stream.
    """)
    streamType = property(lib_mvIMPACT_acquire.DataStreamModule_streamType_get, doc=r"""
    An enumerated integer property. Identifies the stream technology of the GenTL Producer implementation.
    This is a read only feature. This enumeration provides a value that indicates stream technology of the GenTL Producer implementation.

    The following string values might be valid for this feature:
    - **Mixed** (Display string: 'Mixed'): This enumeration value indicates that this is a data stream for a mixed protocol.
    - **Custom** (Display string: 'Custom'): This enumeration value indicates that this is a data stream for a custom protocol.
    - **GEV** (Display string: 'GigE Vision'): This enumeration value indicates that this is a data stream for the GigE Vision protocol.
    - **CameraLink** (Display string: 'CameraLink'): This enumeration value indicates that this is a data stream for the CameraLink protocol.
    - **CoaXPress** (Display string: 'CoaXPress'): This enumeration value indicates that this is a data stream for the CoaXPress protocol.
    - **CameraLinkHS** (Display string: 'CameraLink HS'): This enumeration value indicates that this is a data stream for the CameraLink HS protocol.
    - **U3V** (Display string: 'USB3 Vision'): This enumeration value indicates that this is a data stream for the USB3 Vision protocol.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    mvStreamDriverTechnology = property(lib_mvIMPACT_acquire.DataStreamModule_mvStreamDriverTechnology_get, doc=r"""
    A string property. The underlying driver technology used by this stream.
    This is a read only element. It is a string that contains the underlying driver technology used by this stream.
    """)
    mvAutoJoinMulticastGroups = property(lib_mvIMPACT_acquire.DataStreamModule_mvAutoJoinMulticastGroups_get, doc=r"""
    A boolean property. This feature controls whether the host automatically joins the multicast group(s) of the camera(s) it configures.
    This feature controls whether the host automatically joins the multicast group(s) of the camera(s) it configures.
    """)
    mvResendActive = property(lib_mvIMPACT_acquire.DataStreamModule_mvResendActive_get, doc=r"""
    A boolean property. This feature controls if the stream will issue packet resend requests.
    This feature controls if the stream will issue packet resend requests.
    """)
    mvResendMode = property(lib_mvIMPACT_acquire.DataStreamModule_mvResendMode_get, doc=r"""
    An integer property. Indicates the mode the internal resend algorithm is working in. This feature is a bit mask. The bits have the following meaning (LSB to MSB): Request Resends when a new block starts and the current one has missing packets(0x01)(not recommended for LAG), Request Resends when a new block starts and the current one has no trailer so far(0x02)(not recommended for LAG), Request Resends when more than 'ResendThreshold' packets have been received since a missing packet has been detected(0x04), Request Resends whenever 'mvResendResponseTimeout' did elapse for the previous still incomplete buffer(0x08), Request Resends whenever 'mvResendResponseTimeout' did elapse for the current still incomplete buffer(0x10), Request Resends whenever a packet is considered as missing(0x20)(not recommended for LAG), Request Resends whenever a block start has been missing(e.g. because no capture buffer was available at the time the block did start)(0x40)
    Indicates the mode the internal resend algorithm is working in. This feature is a bit mask. The bits have the following meaning (LSB to MSB): Request Resends when a new block starts and the current one has missing packets(0x01)(not recommended for LAG), Request Resends when a new block starts and the current one has no trailer so far(0x02)(not recommended for LAG), Request Resends when more than 'ResendThreshold' packets have been received since a missing packet has been detected(0x04), Request Resends whenever 'mvResendResponseTimeout' did elapse for the previous still incomplete buffer(0x08), Request Resends whenever 'mvResendResponseTimeout' did elapse for the current still incomplete buffer(0x10), Request Resends whenever a packet is considered as missing(0x20)(not recommended for LAG), Request Resends whenever a block start has been missing(e.g. because no capture buffer was available at the time the block did start)(0x40)
    """)
    mvResendBatchingActive = property(lib_mvIMPACT_acquire.DataStreamModule_mvResendBatchingActive_get, doc=r"""
    A boolean property. This feature controls if the stream will issue batched packet resend requests if it detects several consecutive missing packets.
    This feature controls if the stream will issue batched packet resend requests if it detects several consecutive missing packets.
    """)
    mvResendCaptureWindowSize = property(lib_mvIMPACT_acquire.DataStreamModule_mvResendCaptureWindowSize_get, doc=r"""
    An integer property. Indicates the width of the capture window.
    This feature indicates the width of the capture window in packets.
    """)
    mvResendThreshold = property(lib_mvIMPACT_acquire.DataStreamModule_mvResendThreshold_get, doc=r"""
    An integer property. Indicates the resend threshold within the capture window.
    This feature indicates the resend threshold within the capture window. If current packet ID and first missing packet ID are mvResendThreshold IDs apart the stream will issue a resend request.
    """)
    mvResendRequestMax = property(lib_mvIMPACT_acquire.DataStreamModule_mvResendRequestMax_get, doc=r"""
    An integer property. Indicates the maximum number of resend requests per packet to send to the device until the packet is considered as lost.
    This feature indicates the maximum number of resend requests per packet to send to the device until the packet is considered as lost.
    """)
    mvResendRequestCredits = property(lib_mvIMPACT_acquire.DataStreamModule_mvResendRequestCredits_get, doc=r"""
    A floating point property. Indicates the maximum number of resend requests in percent of payload packets per buffer to send to the device until the packet is considered as lost.
    This feature indicates the maximum number of resend requests in percent of payload packets per buffer to send to the device until the packet is considered as lost.
    """)
    mvResendResponseTimeout = property(lib_mvIMPACT_acquire.DataStreamModule_mvResendResponseTimeout_get, doc=r"""
    An integer property. This feature controls the resend response timeout in milliseconds.
    This float value sets the resend response timeout in milliseconds. Whenever a requested packet does not arrive within this timer period it will be requested again until mvResendRequestMax resend requests for this packet have been issued.
    """)
    mvResendsPerTimeout = property(lib_mvIMPACT_acquire.DataStreamModule_mvResendsPerTimeout_get, doc=r"""
    An integer property. Indicates the number of packets to be requested whenever the resend response timeout elapses.
    This feature indicates the number of packets to be requested whenever the resend response timeout elapses.
    """)
    mvResendFeaturesLocked = property(lib_mvIMPACT_acquire.DataStreamModule_mvResendFeaturesLocked_get, doc=r"""
    An integer property. Used by the driver to lock critical resend related parameters during the acquisition.
    Used by the driver to lock critical resend related parameters during the acquisition.
    """)
    streamAnnouncedBufferCount = property(lib_mvIMPACT_acquire.DataStreamModule_streamAnnouncedBufferCount_get, doc=r"""
    An integer property. Number of announced (known) buffers on this stream. This value is volatile. It may change if additional buffers are announced and/or buffers are revoked by the GenTL Consumer.
    This is a read-only feature. It indicates the number of announced (known) buffers on this stream. This value is volatile. It may change if additional buffers are announced and/or buffers are revoked by the GenTL Consumer.
    """)
    streamBufferHandlingMode = property(lib_mvIMPACT_acquire.DataStreamModule_streamBufferHandlingMode_get, doc=r"""
    An enumerated integer property. Allows to select the buffer handling mode for the stream.
    This enumeration allows the selection of the buffer handling mode for the stream.

    The following string values might be valid for this feature:
    - **OldestFirst** (Display string: 'OldestFirst'): This enumeration value indicates that this stream is using the default acquisition mode.

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    streamAnnounceBufferMinimum = property(lib_mvIMPACT_acquire.DataStreamModule_streamAnnounceBufferMinimum_get, doc=r"""
    An integer property. Minimal number of buffers to announce to enable selected acquisition mode.
    This feature indicates the minimal number of buffers to announce to enable selected acquisition mode.
    """)
    mvStreamAnnounceBufferMaximum = property(lib_mvIMPACT_acquire.DataStreamModule_mvStreamAnnounceBufferMaximum_get, doc=r"""
    An integer property. Maximal number of buffers to announce to enable selected acquisition mode.
    This feature indicates the maximal number of buffers to announce to enable selected acquisition mode.
    """)
    streamDeliveredFrameCount = property(lib_mvIMPACT_acquire.DataStreamModule_streamDeliveredFrameCount_get, doc=r"""
    An integer property. Number of delivered frames since last acquisition start.
    This feature indicates the number of delivered frames since last acquisition start. It is not reset until the stream is closed.
    """)
    streamLostFrameCount = property(lib_mvIMPACT_acquire.DataStreamModule_streamLostFrameCount_get, doc=r"""
    An integer property. Number of lost frames due to queue underrun.
    This feature indicates the number of lost frames due to queue underrun. This number is initialized with zero at the time the stream is opened and incremented every time the data could not be acquired because there was no buffer in the input buffer pool. It is not reset until the stream is closed.
    """)
    streamInputBufferCount = property(lib_mvIMPACT_acquire.DataStreamModule_streamInputBufferCount_get, doc=r"""
    An integer property. Number of buffers in the input buffer pool plus the buffers(s) currently being filled.
    This feature indicates the number of buffers in the input buffer pool plus the buffers(s) currently being filled.
    """)
    streamOutputBufferCount = property(lib_mvIMPACT_acquire.DataStreamModule_streamOutputBufferCount_get, doc=r"""
    An integer property. Number of buffers in the output buffer queue.
    This feature indicates the number of buffers in the output buffer queue.
    """)
    streamStartedFrameCount = property(lib_mvIMPACT_acquire.DataStreamModule_streamStartedFrameCount_get, doc=r"""
    An integer property. Number of frames started in the acquisition engine.
    This feature indicates the number of frames started in the acquisition engine. This number is incremented every time in case of a new buffer is started and then to be filled (data written to) regardless even if the buffer is later delivered to the user or discarded for any reason. This number is initialized with 0 at the time the stream is opened. It is not reset until the stream is closed.
    """)
    payloadSize = property(lib_mvIMPACT_acquire.DataStreamModule_payloadSize_get, doc=r"""
    An integer property. Provides the number of bytes transferred for each data buffer or chunk on the stream channel.
    Provides the number of bytes transferred for each data buffer or chunk on the stream channel. This includes any end-of-line, end-of-frame statistics or other stamp data. This is the total size of data payload for a data block.
    """)
    streamIsGrabbing = property(lib_mvIMPACT_acquire.DataStreamModule_streamIsGrabbing_get, doc=r"""
    A boolean property. Flag indicating whether the acquisition engine is started or not.
    This feature indicates whether the acquisition engine is started or not. This is independent from the acquisition status of the remote device.
    """)
    streamChunkCountMaximum = property(lib_mvIMPACT_acquire.DataStreamModule_streamChunkCountMaximum_get, doc=r"""
    An integer property. Maximum number of chunks to be expected in a buffer (can be used to allocate the array for the DSGetBufferChunkData function).
    Maximum number of chunks to be expected in a buffer (can be used to allocate the array for the DSGetBufferChunkData function).
    """)
    streamBufferAlignment = property(lib_mvIMPACT_acquire.DataStreamModule_streamBufferAlignment_get, doc=r"""
    An integer property. Alignment size in bytes of the buffers passed to DSAnnounceBuffer.
    This feature indicates the alignment size in bytes of the buffers passed to DSAnnounceBuffer. If a buffer is passed to DSAnnounceBuffer which is not aligned according to the alignment size it is up to the Producer to either reject the buffer and return a GC_ERR_INVALID_BUFFER error code or to cope with a potential overhead and use the unaligned buffer as is.
    """)
    eventSelector = property(lib_mvIMPACT_acquire.DataStreamModule_eventSelector_get, doc=r"""
    An enumerated integer property. Selects which Event to signal to the host application.
    Selects which Event to signal to the host application.

    The following string values might be valid for this feature:
    - **AcquisitionTrigger** (Display string: 'Acquisition Trigger'): Device just received a trigger for the Acquisition of one or many Frames.
    - **AcquisitionTriggerMissed** (Display string: 'Acquisition Trigger Missed'): Device just missed a trigger for the Acquisition of one or many Frames.
    - **AcquisitionStart** (Display string: 'Acquisition Start'): Device just started the Acquisition of one or many Frames.
    - **AcquisitionEnd** (Display string: 'Acquisition End'): Device just completed the Acquisition of one or many Frames.
    - **AcquisitionTransferStart** (Display string: 'Acquisition Transfer Start'): Device just started the transfer of one or many Frames.
    - **AcquisitionTransferEnd** (Display string: 'Acquisition Transfer End'): Device just completed the transfer of one or many Frames.
    - **AcquisitionError** (Display string: 'Acquisition Error'): Device just detected an error during the active Acquisition.
    - **FrameBurstStart** (Display string: 'Frame Burst Start'): Device just started the capture of a burst of Frames.
    - **FrameBurstEnd** (Display string: 'Frame Burst End'): Device just completed the capture of a burst of Frames.
    - **FrameTrigger** (Display string: 'Frame Trigger'): Device just received a trigger to start the capture of one Frame.
    - **FrameTriggerMissed** (Display string: 'Frame Trigger Missed'): Device just missed a trigger to start the capture of one Frame.
    - **FrameStart** (Display string: 'Frame Start'): Device just started the capture of one Frame.
    - **FrameEnd** (Display string: 'Frame End'): Device just completed the capture of one Frame.
    - **FrameTransferStart** (Display string: 'Frame Transfer Start'): Device just started the transfer of one Frame.
    - **FrameTransferEnd** (Display string: 'Frame Transfer End'): Device just completed the transfer of one Frame.
    - **LineTrigger** (Display string: 'Line Trigger'): Device just received a trigger to start the capture of one Line.
    - **LineTriggerMissed** (Display string: 'Line Trigger Missed'): Device just missed a trigger to start the capture of one Line.
    - **LineStart** (Display string: 'Line Start'): Device just started the capture of one Line.
    - **LineEnd** (Display string: 'Line End'): Device just completed the capture of one Line.
    - **ExposureStart** (Display string: 'Exposure Start'): Device just started the exposure of one Frame (or Line).
    - **ExposureEnd** (Display string: 'Exposure End'): Device just completed the exposure of one Frame (or Line).
    - **Stream0TransferStart** (Display string: 'Stream 0 Transfer Start'): Device just started the transfer of one or many Blocks.
    - **Stream0TransferEnd** (Display string: 'Stream 0 Transfer End'): Device just completed the transfer of one or many Blocks.
    - **Stream0TransferPause** (Display string: 'Stream 0 Transfer Pause'): Device just paused the transfer.
    - **Stream0TransferResume** (Display string: 'Stream 0 Transfer Resume'): Device just resumed the transfer.
    - **Stream0TransferBlockStart** (Display string: 'Stream 0 Transfer Block Start'): Device just started the transfer of one Block.
    - **Stream0TransferBlockEnd** (Display string: 'Stream 0 Transfer Block End'): Device just completed the transfer of one Block.
    - **Stream0TransferBlockTrigger** (Display string: 'Stream 0 Transfer Block Trigger'): Device just received a trigger to start the transfer of one Block.
    - **Stream0TransferBurstStart** (Display string: 'Stream 0 Transfer Burst Start'): Device just started the transfer of a burst of Blocks.
    - **Stream0TransferBurstEnd** (Display string: 'Stream 0 Transfer Burst End'): Device just completed the transfer of a burst of Blocks.
    - **Stream0TransferOverflow** (Display string: 'Stream 0 Transfer Overflow'): Device transfer queue overflowed.
    - **SequencerSetChange** (Display string: 'Sequencer Set Change'): Device sequencer set has changed.
    - **Counter0Start** (Display string: 'Counter 0 Start'): The event will be generated when counter 0 starts counting.
    - **Counter1Start** (Display string: 'Counter 1 Start'): The event will be generated when counter 1 starts counting.
    - **Counter**#2#Start (Display string: 'Counter #2# Start'): The event will be generated when counter #2# starts counting.
    - **Counter0End** (Display string: 'Counter 0 End'): The event will be generated when counter 0 ends counting.
    - **Counter1End** (Display string: 'Counter 1 End'): The event will be generated when counter 1 ends counting.
    - **Counter**#2#End (Display string: 'Counter #2# End'): The event will be generated when counter #2# ends counting.
    - **Timer0Start** (Display string: 'Timer 0 Start'): The event will be generated when Timer 0 starts counting.
    - **Timer1Start** (Display string: 'Timer 1 Start'): The event will be generated when Timer 1 starts counting.
    - **Timer**#2#Start (Display string: 'Timer #2# Start'): The event will be generated when Timer #2# starts counting.
    - **Timer0End** (Display string: 'Timer 0 End'): The event will be generated when Timer 0 ends counting.
    - **Timer1End** (Display string: 'Timer 1 End'): The event will be generated when Timer 1 ends counting.
    - **Timer**#2#End (Display string: 'Timer #2# End'): The event will be generated when Timer #2# ends counting.
    - **Encoder0Stopped** (Display string: 'Encoder 0 Stopped'): The event will be generated when the Encoder 0 stops for longer than EncoderTimeout.
    - **Encoder1Stopped** (Display string: 'Encoder 1 Stopped'): The event will be generated when the Encoder 1 stops for longer than EncoderTimeout.
    - **Encoder**#2#Stopped (Display string: 'Encoder #2# Stopped'): The event will be generated when the Encoder #2# stops for longer than EncoderTimeout.
    - **Encoder0Restarted** (Display string: 'Encoder 0 Restarted'): The event will be generated when the Encoder 0 restarts moving.
    - **Encoder1Restarted** (Display string: 'Encoder 1 Restarted'): The event will be generated when the Encoder 1 restarts moving.
    - **Encoder**#2#Restarted (Display string: 'Encoder #2# Restarted'): The event will be generated when the Encoder #2# restarts moving.
    - **Line0RisingEdge** (Display string: 'Line 0 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 0.
    - **Line1RisingEdge** (Display string: 'Line 1 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 1.
    - **Line**#2#RisingEdge (Display string: 'Line #2# Rising Edge'): The event will be generated when a Rising Edge is detected on the Line #2#.
    - **Line0FallingEdge** (Display string: 'Line 0 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 0.
    - **Line1FallingEdge** (Display string: 'Line 1 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 1.
    - **Line**#2#FallingEdge (Display string: 'Line #2# Falling Edge'): The event will be generated when a Falling Edge is detected on the Line #2#.
    - **Line0AnyEdge** (Display string: 'Line 0 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 0.
    - **Line1AnyEdge** (Display string: 'Line 1 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 1.
    - **Line**#2#AnyEdge (Display string: 'Line #2# Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line #2#.
    - **LinkTrigger0** (Display string: 'Link Trigger 0'): The event will be generated when a Rising Edge is detected on the LinkTrigger 0.
    - **LinkTrigger1** (Display string: 'Link Trigger 1'): The event will be generated when a Rising Edge is detected on the LinkTrigger 1.
    - **LinkTrigger**#2# (Display string: 'Link Trigger #2#'): The event will be generated when a Rising Edge is detected on the LinkTrigger #2#.
    - **LinkSpeedChange** (Display string: 'Link Speed Change'): The event will be generated when the link speed has changed.
    - **ActionLate** (Display string: 'Action Late'): The event will be generated when a valid scheduled action command is received and is scheduled to be executed at a time that is already past.
    - **Error** (Display string: 'Error'): Device just detected an error during the active Acquisition.
    - **Test** (Display string: 'Test'): The test event will be generated when the device receives the TestEventGenerate command (EventNotification for the Test event is always On).
    - **PrimaryApplicationSwitch** (Display string: 'Primary Application Switch'): The event will be generated when a primary application switchover has been granted (GigE Vision Specific).
    - **Counter2Start** (Display string: 'Counter 2 Start'): The event will be generated when counter 2 starts counting.
    - **Counter3Start** (Display string: 'Counter 3 Start'): The event will be generated when counter 3 starts counting.
    - **Counter4Start** (Display string: 'Counter 4 Start'): The event will be generated when counter 4 starts counting.
    - **Counter5Start** (Display string: 'Counter 5 Start'): The event will be generated when counter 5 starts counting.
    - **Counter6Start** (Display string: 'Counter 6 Start'): The event will be generated when counter 6 starts counting.
    - **Counter7Start** (Display string: 'Counter 7 Start'): The event will be generated when counter 7 starts counting.
    - **Counter8Start** (Display string: 'Counter 8 Start'): The event will be generated when counter 8 starts counting.
    - **Counter9Start** (Display string: 'Counter 9 Start'): The event will be generated when counter 9 starts counting.
    - **Counter10Start** (Display string: 'Counter 10 Start'): The event will be generated when counter 10 starts counting.
    - **Counter11Start** (Display string: 'Counter 11 Start'): The event will be generated when counter 11 starts counting.
    - **Counter12Start** (Display string: 'Counter 12 Start'): The event will be generated when counter 12 starts counting.
    - **Counter13Start** (Display string: 'Counter 13 Start'): The event will be generated when counter 13 starts counting.
    - **Counter14Start** (Display string: 'Counter 14 Start'): The event will be generated when counter 14 starts counting.
    - **Counter15Start** (Display string: 'Counter 15 Start'): The event will be generated when counter 15 starts counting.
    - **Counter2End** (Display string: 'Counter 2 End'): The event will be generated when counter 2 ends counting.
    - **Counter3End** (Display string: 'Counter 3 End'): The event will be generated when counter 3 ends counting.
    - **Counter4End** (Display string: 'Counter 4 End'): The event will be generated when counter 4 ends counting.
    - **Counter5End** (Display string: 'Counter 5 End'): The event will be generated when counter 5 ends counting.
    - **Counter6End** (Display string: 'Counter 6 End'): The event will be generated when counter 6 ends counting.
    - **Counter7End** (Display string: 'Counter 7 End'): The event will be generated when counter 7 ends counting.
    - **Counter8End** (Display string: 'Counter 8 End'): The event will be generated when counter 8 ends counting.
    - **Counter9End** (Display string: 'Counter 9 End'): The event will be generated when counter 9 ends counting.
    - **Counter10End** (Display string: 'Counter 10 End'): The event will be generated when counter 10 ends counting.
    - **Counter11End** (Display string: 'Counter 11 End'): The event will be generated when counter 11 ends counting.
    - **Counter12End** (Display string: 'Counter 12 End'): The event will be generated when counter 12 ends counting.
    - **Counter13End** (Display string: 'Counter 13 End'): The event will be generated when counter 13 ends counting.
    - **Counter14End** (Display string: 'Counter 14 End'): The event will be generated when counter 14 ends counting.
    - **Counter15End** (Display string: 'Counter 15 End'): The event will be generated when counter 15 ends counting.
    - **Timer2Start** (Display string: 'Timer 2 Start'): The event will be generated when Timer 2 starts counting.
    - **Timer3Start** (Display string: 'Timer 3 Start'): The event will be generated when Timer 3 starts counting.
    - **Timer4Start** (Display string: 'Timer 4 Start'): The event will be generated when Timer 4 starts counting.
    - **Timer5Start** (Display string: 'Timer 5 Start'): The event will be generated when Timer 5 starts counting.
    - **Timer6Start** (Display string: 'Timer 6 Start'): The event will be generated when Timer 6 starts counting.
    - **Timer7Start** (Display string: 'Timer 7 Start'): The event will be generated when Timer 7 starts counting.
    - **Timer8Start** (Display string: 'Timer 8 Start'): The event will be generated when Timer 8 starts counting.
    - **Timer9Start** (Display string: 'Timer 9 Start'): The event will be generated when Timer 9 starts counting.
    - **Timer10Start** (Display string: 'Timer 10 Start'): The event will be generated when Timer 10 starts counting.
    - **Timer11Start** (Display string: 'Timer 11 Start'): The event will be generated when Timer 11 starts counting.
    - **Timer12Start** (Display string: 'Timer 12 Start'): The event will be generated when Timer 12 starts counting.
    - **Timer13Start** (Display string: 'Timer 13 Start'): The event will be generated when Timer 13 starts counting.
    - **Timer14Start** (Display string: 'Timer 14 Start'): The event will be generated when Timer 14 starts counting.
    - **Timer15Start** (Display string: 'Timer 15 Start'): The event will be generated when Timer 15 starts counting.
    - **Timer2End** (Display string: 'Timer 2 End'): The event will be generated when Timer 2 ends counting.
    - **Timer3End** (Display string: 'Timer 3 End'): The event will be generated when Timer 3 ends counting.
    - **Timer4End** (Display string: 'Timer 4 End'): The event will be generated when Timer 4 ends counting.
    - **Timer5End** (Display string: 'Timer 5 End'): The event will be generated when Timer 5 ends counting.
    - **Timer6End** (Display string: 'Timer 6 End'): The event will be generated when Timer 6 ends counting.
    - **Timer7End** (Display string: 'Timer 7 End'): The event will be generated when Timer 7 ends counting.
    - **Timer8End** (Display string: 'Timer 8 End'): The event will be generated when Timer 8 ends counting.
    - **Timer9End** (Display string: 'Timer 9 End'): The event will be generated when Timer 9 ends counting.
    - **Timer10End** (Display string: 'Timer 10 End'): The event will be generated when Timer 10 ends counting.
    - **Timer11End** (Display string: 'Timer 11 End'): The event will be generated when Timer 11 ends counting.
    - **Timer12End** (Display string: 'Timer 12 End'): The event will be generated when Timer 12 ends counting.
    - **Timer13End** (Display string: 'Timer 13 End'): The event will be generated when Timer 13 ends counting.
    - **Timer14End** (Display string: 'Timer 14 End'): The event will be generated when Timer 14 ends counting.
    - **Timer15End** (Display string: 'Timer 15 End'): The event will be generated when Timer 15 ends counting.
    - **Encoder2Stopped** (Display string: 'Encoder 2 Stopped'): The event will be generated when the Encoder 2 stops for longer than EncoderTimeout.
    - **Encoder3Stopped** (Display string: 'Encoder 3 Stopped'): The event will be generated when the Encoder 3 stops for longer than EncoderTimeout.
    - **Encoder4Stopped** (Display string: 'Encoder 4 Stopped'): The event will be generated when the Encoder 4 stops for longer than EncoderTimeout.
    - **Encoder5Stopped** (Display string: 'Encoder 5 Stopped'): The event will be generated when the Encoder 5 stops for longer than EncoderTimeout.
    - **Encoder6Stopped** (Display string: 'Encoder 6 Stopped'): The event will be generated when the Encoder 6 stops for longer than EncoderTimeout.
    - **Encoder7Stopped** (Display string: 'Encoder 7 Stopped'): The event will be generated when the Encoder 7 stops for longer than EncoderTimeout.
    - **Encoder8Stopped** (Display string: 'Encoder 8 Stopped'): The event will be generated when the Encoder 8 stops for longer than EncoderTimeout.
    - **Encoder9Stopped** (Display string: 'Encoder 9 Stopped'): The event will be generated when the Encoder 9 stops for longer than EncoderTimeout.
    - **Encoder10Stopped** (Display string: 'Encoder 10 Stopped'): The event will be generated when the Encoder 10 stops for longer than EncoderTimeout.
    - **Encoder11Stopped** (Display string: 'Encoder 11 Stopped'): The event will be generated when the Encoder 11 stops for longer than EncoderTimeout.
    - **Encoder12Stopped** (Display string: 'Encoder 12 Stopped'): The event will be generated when the Encoder 12 stops for longer than EncoderTimeout.
    - **Encoder13Stopped** (Display string: 'Encoder 13 Stopped'): The event will be generated when the Encoder 13 stops for longer than EncoderTimeout.
    - **Encoder14Stopped** (Display string: 'Encoder 14 Stopped'): The event will be generated when the Encoder 14 stops for longer than EncoderTimeout.
    - **Encoder15Stopped** (Display string: 'Encoder 15 Stopped'): The event will be generated when the Encoder 15 stops for longer than EncoderTimeout.
    - **Encoder2Restarted** (Display string: 'Encoder 2 Restarted'): The event will be generated when the Encoder 2 restarts moving.
    - **Encoder3Restarted** (Display string: 'Encoder 3 Restarted'): The event will be generated when the Encoder 3 restarts moving.
    - **Encoder4Restarted** (Display string: 'Encoder 4 Restarted'): The event will be generated when the Encoder 4 restarts moving.
    - **Encoder5Restarted** (Display string: 'Encoder 5 Restarted'): The event will be generated when the Encoder 5 restarts moving.
    - **Encoder6Restarted** (Display string: 'Encoder 6 Restarted'): The event will be generated when the Encoder 6 restarts moving.
    - **Encoder7Restarted** (Display string: 'Encoder 7 Restarted'): The event will be generated when the Encoder 7 restarts moving.
    - **Encoder8Restarted** (Display string: 'Encoder 8 Restarted'): The event will be generated when the Encoder 8 restarts moving.
    - **Encoder9Restarted** (Display string: 'Encoder 9 Restarted'): The event will be generated when the Encoder 9 restarts moving.
    - **Encoder10Restarted** (Display string: 'Encoder 10 Restarted'): The event will be generated when the Encoder 10 restarts moving.
    - **Encoder11Restarted** (Display string: 'Encoder 11 Restarted'): The event will be generated when the Encoder 11 restarts moving.
    - **Encoder12Restarted** (Display string: 'Encoder 12 Restarted'): The event will be generated when the Encoder 12 restarts moving.
    - **Encoder13Restarted** (Display string: 'Encoder 13 Restarted'): The event will be generated when the Encoder 13 restarts moving.
    - **Encoder14Restarted** (Display string: 'Encoder 14 Restarted'): The event will be generated when the Encoder 14 restarts moving.
    - **Encoder15Restarted** (Display string: 'Encoder 15 Restarted'): The event will be generated when the Encoder 15 restarts moving.
    - **Line2RisingEdge** (Display string: 'Line 2 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 2.
    - **Line3RisingEdge** (Display string: 'Line 3 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 3.
    - **Line4RisingEdge** (Display string: 'Line 4 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 4.
    - **Line5RisingEdge** (Display string: 'Line 5 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 5.
    - **Line6RisingEdge** (Display string: 'Line 6 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 6.
    - **Line7RisingEdge** (Display string: 'Line 7 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 7.
    - **Line8RisingEdge** (Display string: 'Line 8 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 8.
    - **Line9RisingEdge** (Display string: 'Line 9 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 9.
    - **Line10RisingEdge** (Display string: 'Line 10 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 10.
    - **Line11RisingEdge** (Display string: 'Line 11 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 11.
    - **Line12RisingEdge** (Display string: 'Line 12 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 12.
    - **Line13RisingEdge** (Display string: 'Line 13 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 13.
    - **Line14RisingEdge** (Display string: 'Line 14 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 14.
    - **Line15RisingEdge** (Display string: 'Line 15 Rising Edge'): The event will be generated when a Rising Edge is detected on the Line 15.
    - **Line2FallingEdge** (Display string: 'Line 2 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 2.
    - **Line3FallingEdge** (Display string: 'Line 3 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 3.
    - **Line4FallingEdge** (Display string: 'Line 4 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 4.
    - **Line5FallingEdge** (Display string: 'Line 5 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 5.
    - **Line6FallingEdge** (Display string: 'Line 6 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 6.
    - **Line7FallingEdge** (Display string: 'Line 7 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 7.
    - **Line8FallingEdge** (Display string: 'Line 8 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 8.
    - **Line9FallingEdge** (Display string: 'Line 9 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 9.
    - **Line10FallingEdge** (Display string: 'Line 10 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 10.
    - **Line11FallingEdge** (Display string: 'Line 11 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 11.
    - **Line12FallingEdge** (Display string: 'Line 12 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 12.
    - **Line13FallingEdge** (Display string: 'Line 13 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 13.
    - **Line14FallingEdge** (Display string: 'Line 14 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 14.
    - **Line15FallingEdge** (Display string: 'Line 15 Falling Edge'): The event will be generated when a Falling Edge is detected on the Line 15.
    - **Line2AnyEdge** (Display string: 'Line 2 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 2.
    - **Line3AnyEdge** (Display string: 'Line 3 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 3.
    - **Line4AnyEdge** (Display string: 'Line 4 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 4.
    - **Line5AnyEdge** (Display string: 'Line 5 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 5.
    - **Line6AnyEdge** (Display string: 'Line 6 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 6.
    - **Line7AnyEdge** (Display string: 'Line 7 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 7.
    - **Line8AnyEdge** (Display string: 'Line 8 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 8.
    - **Line9AnyEdge** (Display string: 'Line 9 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 9.
    - **Line10AnyEdge** (Display string: 'Line 10 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 10.
    - **Line11AnyEdge** (Display string: 'Line 11 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 11.
    - **Line12AnyEdge** (Display string: 'Line 12 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 12.
    - **Line13AnyEdge** (Display string: 'Line 13 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 13.
    - **Line14AnyEdge** (Display string: 'Line 14 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 14.
    - **Line15AnyEdge** (Display string: 'Line 15 Any Edge'): The event will be generated when a Falling or Rising Edge is detected on the Line 15.
    - **Link0Trigger** (Display string: 'Link 0 Trigger')
    - **Link1Trigger** (Display string: 'Link 1 Trigger')
    - **Link2Trigger** (Display string: 'Link 2 Trigger')
    - **Link3Trigger** (Display string: 'Link 3 Trigger')
    - **Link4Trigger** (Display string: 'Link 4 Trigger')
    - **Link5Trigger** (Display string: 'Link 5 Trigger')
    - **Link6Trigger** (Display string: 'Link 6 Trigger')
    - **Link7Trigger** (Display string: 'Link 7 Trigger')
    - **Link8Trigger** (Display string: 'Link 8 Trigger')
    - **Link9Trigger** (Display string: 'Link 9 Trigger')
    - **Link10Trigger** (Display string: 'Link 10 Trigger')
    - **Link11Trigger** (Display string: 'Link 11 Trigger')
    - **Link12Trigger** (Display string: 'Link 12 Trigger')
    - **Link13Trigger** (Display string: 'Link 13 Trigger')
    - **Link14Trigger** (Display string: 'Link 14 Trigger')
    - **Link15Trigger** (Display string: 'Link 15 Trigger')
    - **InterfaceListChanged** (Display string: 'Interface List Changed'): This enumeration value indicates an event that is fired when the list of interfaces has been updated.
    - **InterfaceLost** (Display string: 'Interface Lost'): This enumeration value indicates an event that is raised when the interface connection is lost.
    - **DeviceListChanged** (Display string: 'Device List Changed'): This enumeration value indicates an event that is fired when the list of devices has been updated.
    - **DeviceLost** (Display string: 'Device Lost'): This enumeration value indicates an event that is raised when the local host looses connection to the physical(remote) device.
    - **BufferTooSmall** (Display string: 'Buffer Too Small'): This enumeration value indicates an event that is raised when the buffer was too small to receive the expected amount of data.
    - **BuffersDiscarded** (Display string: 'Buffers Discarded'): This enumeration value indicates an event that is raised when buffers discared by GenTL or device. This event could optionally carry two numeric child data fields EventBuffersDiscardedDeviceCount and EventBuffersDiscardedProducerCount.
    - **BuffersDiscardedDeviceCount** (Display string: 'Buffers Discarded Device Count'): This enumeration value indicates the number of buffers discarded by the device since last fired instance of this event (the producer would get to know about this for example by observing a gap in the block_id sequence).
    - **BuffersDiscardedProducerCount** (Display string: 'Buffers Discarded Producer Count'): This enumeration value indicates the number of buffers discarded by the producer since last fired instance of this event (this would happen e.g. if there are no free buffers available or if given buffer handling mode requires discarding old buffers etc.).

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    eventNotification = property(lib_mvIMPACT_acquire.DataStreamModule_eventNotification_get, doc=r"""
    An enumerated integer property. Activate or deactivate the notification to the host application of the occurrence of the selected Event.
    Activate or deactivate the notification to the host application of the occurrence of the selected Event.

    The following string values might be valid for this feature:
    - **Off** (Display string: 'Off'): The selected Event notification is disabled.
    - **On** (Display string: 'On'): The selected Event notification is enabled.
    - **Once** (Display string: 'Once'): The selected Event notification is enabled for one event then return to Off state.
    - **GigEVisionEvent** (Display string: 'Gig E Vision Event')

    Notes: Depending on the device some of these values might not be supported and especially when working with third party devices there might be custom values which are not listed here.
    To get a complete and reliable list of supported values at runtime an application should therefore call **mvIMPACT::acquire::EnumPropertyI::getTranslationDictStrings()** or one of the other functions dealing with translation dictionaries for enumerated properties.
    """)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_DataStreamModule

# Register DataStreamModule in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.DataStreamModule_swigregister(DataStreamModule)

rtmFullResolution = lib_mvIMPACT_acquire.rtmFullResolution
r""" Request transmission of an image in full resolution."""
sspCounterDuration_Counter1 = lib_mvIMPACT_acquire.sspCounterDuration_Counter1
r""" Requests the CounterDuration[CounterSelector=Counter1] property to be modified in a user selected sequencer set."""
sspCounterDuration_Counter2 = lib_mvIMPACT_acquire.sspCounterDuration_Counter2
r""" Requests the CounterDuration[CounterSelector=Counter2] property to be modified in a user selected sequencer set."""
sspCounterDuration_Counter3 = lib_mvIMPACT_acquire.sspCounterDuration_Counter3
r""" Requests the CounterDuration[CounterSelector=Counter3] property to be modified in a user selected sequencer set."""
sspCounterDuration_Counter4 = lib_mvIMPACT_acquire.sspCounterDuration_Counter4
r""" Requests the CounterDuration[CounterSelector=Counter4] property to be modified in a user selected sequencer set."""
sspCounterDuration_Counter5 = lib_mvIMPACT_acquire.sspCounterDuration_Counter5
r""" Requests the CounterDuration[CounterSelector=Counter5] property to be modified in a user selected sequencer set."""
sspCounterDuration_Counter6 = lib_mvIMPACT_acquire.sspCounterDuration_Counter6
r""" Requests the CounterDuration[CounterSelector=Counter6] property to be modified in a user selected sequencer set."""
sspCounterDuration_Counter7 = lib_mvIMPACT_acquire.sspCounterDuration_Counter7
r""" Requests the CounterDuration[CounterSelector=Counter7] property to be modified in a user selected sequencer set."""
sspCounterDuration_Counter8 = lib_mvIMPACT_acquire.sspCounterDuration_Counter8
r""" Requests the CounterDuration[CounterSelector=Counter8] property to be modified in a user selected sequencer set."""
sspExposureTime = lib_mvIMPACT_acquire.sspExposureTime
r""" Requests the ``ExposureTime`` property to be modified in a user selected sequencer set."""
sspGain_AnalogAll = lib_mvIMPACT_acquire.sspGain_AnalogAll
r""" Requests the Gain[GainSelector=AnalogAll] property to be modified in a user selected sequencer set."""
sspGain_AnalogRed = lib_mvIMPACT_acquire.sspGain_AnalogRed
r""" Requests the Gain[GainSelector=AnalogRed] property to be modified in a user selected sequencer set."""
sspGain_AnalogGreen = lib_mvIMPACT_acquire.sspGain_AnalogGreen
r""" Requests the Gain[GainSelector=AnalogGreen] property to be modified in a user selected sequencer set."""
sspGain_AnalogBlue = lib_mvIMPACT_acquire.sspGain_AnalogBlue
r""" Requests the Gain[GainSelector=AnalogBlue] property to be modified in a user selected sequencer set."""
sspGain_AnalogTap1 = lib_mvIMPACT_acquire.sspGain_AnalogTap1
r""" Requests the Gain[GainSelector=AnalogTap1] property to be modified in a user selected sequencer set."""
sspGain_AnalogTap2 = lib_mvIMPACT_acquire.sspGain_AnalogTap2
r""" Requests the Gain[GainSelector=AnalogTap2] property to be modified in a user selected sequencer set."""
sspGain_AnalogTap3 = lib_mvIMPACT_acquire.sspGain_AnalogTap3
r""" Requests the Gain[GainSelector=AnalogTap3] property to be modified in a user selected sequencer set."""
sspGain_AnalogTap4 = lib_mvIMPACT_acquire.sspGain_AnalogTap4
r""" Requests the Gain[GainSelector=AnalogTap4] property to be modified in a user selected sequencer set."""
sspOffsetX = lib_mvIMPACT_acquire.sspOffsetX
r"""
     Requests the OffsetX property to be modified in a user selected sequencer set.
    Since: 2.34.0, requires firmware version >= 2.35
    """
sspOffsetY = lib_mvIMPACT_acquire.sspOffsetY
r"""
     Requests the OffsetY property to be modified in a user selected sequencer set.
    Since: 2.34.0, requires firmware version >= 2.35
    """
sspWidth = lib_mvIMPACT_acquire.sspWidth
r"""
     Requests the Width property to be modified in a user selected sequencer set.
    Since: 2.36.0, requires firmware version >= 2.36
    """
sspHeight = lib_mvIMPACT_acquire.sspHeight
r"""
     Requests the Height property to be modified in a user selected sequencer set.
    Since: 2.36.0, requires firmware version >= 2.36
    """
class CustomCommandGenerator(object):
    r"""
     Contains convenience functions to control features understood by a devices custom command interpreter.
    Contains convenience functions to control features understood by a devices custom command interpreter.
    Notes: Creating an instance of this class will only succeed when the device associated with this object
    supports the **mvIMPACT::acquire::GenICam::mvCustomData.mvCustomCommandBuffer** feature. If the
    feature is not supported an exception will be raised!

    This class will allow to create various special commands understood by **MATRIX VISION GmbH** devices.
    For example an application can modify parameters in a running sequencer program without stopping the
    acquisition engine and/or the sequencer program
    (see **mvIMPACT::acquire::GenICam::SequencerControl** and the corresponding use cases for details).
    This allows changes to be applied much faster than with a conventional approach which would work like this:
    If: DOXYGEN_CPP_DOCUMENTATION {

    .. code-block:: c++

         mvIMPACT::acquire::GenICam::AcquisitionControl ac( getDevicePointerFromSomewhere() );
         mvIMPACT::acquire::GenICam::SequencerControl sc( getDevicePointerFromSomewhere() );
         sc.sequencerMode.writeS( "Off" );
         sc.sequencerConfigurationMode.writeS( "On" );
         sc.sequencerSetSelector.write( 2 );
         sc.sequencerSetLoad.call(); // needed as otherwise other parameters in the set might get changed as well.
         ac.exposureTime.write( 20000 );
         sc.sequencerSetSave.call();
         sc.sequencerConfigurationMode.writeS( "Off" );
         sc.sequencerMode.writeS( "On" );
    }Else if: DOXYGEN_JAVA_DOCUMENTATION {

    .. code-block:: c++

         AcquisitionControl ac = new AcquisitionControl( getDevicePointerFromSomewhere() );
         SequencerControl sc = new SequencerControl( getDevicePointerFromSomewhere() );
         sc.getSequencerMode().writeS( "Off" );
         sc.getSequencerConfigurationMode().writeS( "On" );
         sc.getSequencerSetSelector().write( 2 );
         sc.getSequencerSetLoad().call(); // needed as otherwise other parameters in the set might get changed as well.
         ac.getExposureTime().write( 20000 );
         sc.getSequencerSetSave().call();
         sc.getSequencerConfigurationMode().writeS( "Off" );
         sc.getSequencerMode().writeS( "On" );
    }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

    .. code-block:: c++

         ac = acquire.AcquisitionControl(getDeviceReferenceFromSomewhere())
         sc = acquire.SequencerControl(getDeviceReferenceFromSomewhere())
         sc.sequencerMode.writeS("Off")
         sc.sequencerConfigurationMode.writeS("On")
         sc.sequencerSetSelector.write(2)
         sc.sequencerSetLoad.call() # needed as otherwise other parameters in the set might get changed as well.
         ac.exposureTime.write(20000)
         sc.sequencerSetSave.call()
         sc.sequencerConfigurationMode.writeS("Off")
         sc.sequencerMode.writeS("On")
    }

    A single parameter in a defined sequencer set can be modified much faster at runtime like this:

    If: DOXYGEN_CPP_DOCUMENTATION {

    .. code-block:: c++

         mvIMPACT::acquire::GenICam::CustomCommandGenerator ccg( getDevicePointerFromSomewhere() );
         // change the exposure time in sequencer set 2 to 30000 us.
         ccg.modifySequencerSetValue( 2, sspExposureTime, 30000 );
    }Else if: DOXYGEN_JAVA_DOCUMENTATION {

    .. code-block:: c++

         CustomCommandGenerator ccg = new CustomCommandGenerator( getDevicePointerFromSomewhere() );
         // change the exposure time in sequencer set 2 to 30000 us.
         ccg.modifySequencerSetValue( 2, TSequencerSetParameter.sspExposureTime, 30000 );
    }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

    .. code-block:: c++

         ccg = acquire.CustomCommandGenerator(getDeviceReferenceFromSomewhere())
         # change the exposure time in sequencer set 2 to 30000 us.
         ccg.modifySequencerSetValue(2, acquire.sspExposureTime, 30000)
    }

    In a real world application the instance of **mvIMPACT::acquire::GenICam::CustomCommandGenerator** should be a member of a class
    or stored elsewhere as constructing objects from the **mvIMPACT::acquire::GenICam** namespace is taking time so this shouldn't be done for each command
    that shall be sent!

    This class uses an internal command buffer which allows an application to send multiple change commands in a single packet.
    This can be achieved like this:

    If: DOXYGEN_CPP_DOCUMENTATION {

    .. code-block:: c++

         mvIMPACT::acquire::GenICam::CustomCommandGenerator ccg( getDevicePointerFromSomewhere() );
         // queue 2 parameter change requests
         // change the AnalogAll gain in sequencer set 0 to 3.14 dB.
         ccg.queueSequencerSetValueModification( 0, sspGain_AnalogAll, 3.14 );
         // change the exposure time in sequencer set 1 to 20000 us.
         ccg.queueSequencerSetValueModification( 1, sspExposureTime, 20000 );
         // send the 2 modifications in a single package
         ccg.sendCommandBuffer();
    }Else if: DOXYGEN_JAVA_DOCUMENTATION {

    .. code-block:: c++

         CustomCommandGenerator ccg = new CustomCommandGenerator( getDevicePointerFromSomewhere() );
         // queue 2 parameter change requests
         // change the AnalogAll gain in sequencer set 0 to 3.14 dB.
         ccg.queueSequencerSetValueModification( 0, TSequencerSetParameter.sspGain_AnalogAll, 3.14 );
         // change the exposure time in sequencer set 1 to 20000 us.
         ccg.queueSequencerSetValueModification( 1, TSequencerSetParameter.sspExposureTime, 20000 );
         // send the 2 modifications in a single package
         ccg.sendCommandBuffer();
    }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

    .. code-block:: c++

         ccg = acquire.CustomCommandGenerator(getDeviceReferenceFromSomewhere())
         # queue 2 parameter change requests
         # change the AnalogAll gain in sequencer set 0 to 3.14 dB.
         ccg.queueSequencerSetValueModification(0, acquire.sspGain_AnalogAll, 3.14)
         # change the exposure time in sequencer set 1 to 20000 us.
         ccg.queueSequencerSetValueModification(1, acquire.sspExposureTime, 20000)
         # send the 2 modifications in a single package
         ccg.sendCommandBuffer()
    }

    The command queue NEVER overflows. When no more data can be stored in the queue before queuing the next parameter
    change all the pending changes will be transmitted to the device. Calling **mvIMPACT::acquire::GenICam::CustomCommandGenerator.queueSequencerSetValueModification**
    and **mvIMPACT::acquire::GenICam::CustomCommandGenerator.sendCommandBuffer** directly afterwards is equivalent to call
    **mvIMPACT::acquire::GenICam::CustomCommandGenerator.modifySequencerSetValue**. So the previous example can also be rewritten like this:

    If: DOXYGEN_CPP_DOCUMENTATION {

    .. code-block:: c++

         mvIMPACT::acquire::GenICam::CustomCommandGenerator ccg( getDevicePointerFromSomewhere() );
         // queue 2 parameter change requests
         // change the AnalogAll gain in sequencer set 0 to 3.14 dB.
         ccg.queueSequencerSetValueModification( 0, sspGain_AnalogAll, 3.14 );
         // change the exposure time in sequencer set 1 to 20000 us and send both requests to the device in a single packet.
         ccg.modifySequencerSetValue( 1, sspExposureTime, 20000 );
    }Else if: DOXYGEN_JAVA_DOCUMENTATION {

    .. code-block:: c++

         CustomCommandGenerator ccg = new CustomCommandGenerator( getDevicePointerFromSomewhere() );
         // queue 2 parameter change requests
         // change the AnalogAll gain in sequencer set 0 to 3.14 dB.
         ccg.queueSequencerSetValueModification( 0, TSequencerSetParameter.sspGain_AnalogAll, 3.14 );
         // change the exposure time in sequencer set 1 to 20000 us and send both requests to the device in a single packet.
         ccg.modifySequencerSetValue( 1, TSequencerSetParameter.sspExposureTime, 20000 );
    }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

    .. code-block:: c++

         ccg = acquire.CustomCommandGenerator(getDeviceReferenceFromSomewhere ())
         # queue 2 parameter change requests
         # change the AnalogAll gain in sequencer set 0 to 3.14 dB.
         ccg.queueSequencerSetValueModification(0, acquire.sspGain_AnalogAll, 3.14)
         # change the exposure time in sequencer set 1 to 20000 us and send both requests to the device in a single packet.
         ccg.modifySequencerSetValue(1, acquire.sspExposureTime, 20000)
    }

    Because there can never be an overflow of the command queue even this code is valid:
    If: DOXYGEN_CPP_DOCUMENTATION {

    .. code-block:: c++

         for( int i = 0; i  100; i += 2 )
         {
           // if the command buffer is full everything should be sent to the device thus no error should be returned here
           ccg.queueSequencerSetValueModification( i % 5, sspCounterDuration_Counter1, i * 100 );
           ccg.queueSequencerSetValueModification( i % 5, sspExposureTime, ac.exposureTime.getMinValue() + static_castdouble( i * 10 ) );
         }
    }Else if: DOXYGEN_JAVA_DOCUMENTATION {

    .. code-block:: c++

         for( int i = 0; i  100; i += 2 )
         {
           // if the command buffer is full everything should be sent to the device thus no error should be returned here
           ccg.queueSequencerSetValueModification( i % 5, TSequencerSetParameter.sspCounterDuration_Counter1, i * 100 );
           ccg.queueSequencerSetValueModification( i % 5, TSequencerSetParameter.sspExposureTime, ac.getExposureTime().getMinValue() + ( i * 10.0 ) );
         }
    }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

    .. code-block:: c++

         for i in range(0, 100, 2):
            # if the command buffer is full everything should be sent to the device thus no error should be returned here
            ccg.queueSequencerSetValueModification(i % 5, acquire.sspCounterDuration_Counter1, i * 100)
            ccg.queueSequencerSetValueModification(i % 5, acquire.sspExposureTime, ac.exposureTime.getMinValue() + (i * 10))
    }

    Apart from modifying sequencer sets at runtime some **MATRIX VISION GmbH** devices support the so called Smart Frame Recall feature.
    For more information about the feature itself please refer to the corresponding use case in the product documentation. There is also a C++ example
    called **GenICamSmartFrameRecallUsage.cpp** which can be read to get a first glimpse. The source code and the documentation of this example can be found in the C++
    version of this documentation. The **mvIMPACT::acquire::GenICam::CustomCommandGenerator** provides functions to request a full resolution
    version of an image based on a **mvIMPACT::acquire::Request** object containing an image with
    reduced resolution passed to it (internally the relevant piece of information is the timestamp of the image to request). To request an image an
    application can call one of the various versions of the **mvIMPACT::acquire::GenICam::CustomCommandGenerator.requestTransmission** functions.

    If: DOXYGEN_CPP_DOCUMENTATION {

    .. code-block:: c++

        int getNextRandomValue( int min, int max )
        {
          return ( rand() % ( max - min ) ) + min;
        }
        //...

        // switch on the smart frame recall feature
        mvIMPACT::acquire::GenICam::AcquisitionControl ac( pDev );
        ac.mvSmartFrameRecallEnable.write( bTrue );
        // more code
        Request* pRequest = getRequestFromSomewhere();
        // request the transmission of an arbitrary ROI of this image in full resolution
        int w = getNextRandomValue( 1, pRequest-imageWidth.read() );
        int h = getNextRandomValue( 1, pRequest-imageHeight.read() );
        int x = getNextRandomValue( 0, pRequest-imageWidth.read() - w );
        int y = getNextRandomValue( 0, pRequest-imageHeight.read() - h );
        ccg.requestTransmission( pRequest, x, y, w, h, rtmFullResolution );
    }Else if: DOXYGEN_JAVA_DOCUMENTATION {

    .. code-block:: c++

         import java.util.concurrent.ThreadLocalRandom; // for random number!

         // ... more code, class definition, etc.

         public static int getNextRandomValue( int min, int max )
         {
           return ThreadLocalRandom.current().nextInt( min, max + 1 );
         }

         // ... more code, function body, etc.

          CustomCommandGenerator ccg = new CustomCommandGenerator( pDev );
         //...

         // switch on the smart frame recall feature
         AcquisitionControl ac = new AcquisitionControl( pDev );
         ac.getMvSmartFrameRecallEnable().write( TBoolean.bTrue );
         // more code
         Request pRequest = getRequestFromSomewhere();
         // request the transmission of an arbitrary ROI of this image in full resolution
         int w = getNextRandomValue( 1, pRequest.getImageWidth().read() );
         int h = getNextRandomValue( 1, pRequest.getImageHeight().read() );
         int x = getNextRandomValue( 0, pRequest.getImageWidth().read() - w );
         int y = getNextRandomValue( 0, pRequest.getImageHeight().read() - h );
         ccg.requestTransmission( pRequest, x, y, w, h, TRequestTransmissionMode.rtmFullResolution );
    }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

    .. code-block:: c++

         def getNextRandomValue(min, max):
            value = min + int((max - min + 1) * random.uniform(0, 1))
            if(value  min):
                return min
            if(value  max):
                return max
            return value
         ...
         # switch on the smart frame recall feature
         ac = acquire.AcquisitionControl( pDev )
         ac.mvSmartFrameRecallEnable.write( acquire.bTrue )
         # more code
         pRequest = getRequestFromSomewhere()
         # request the transmission of an arbitrary ROI of this image in full resolution
         w = getNextRandomValue(1, pRequest.getImageWidth.read())
         h = getNextRandomValue(1, pRequest.getImageHeight.read())
         x = getNextRandomValue(0, pRequest.getImageWidth.read() - w)
         y = getNextRandomValue(0, pRequest.getImageHeight.read() - h)
         ccg.requestTransmission(pRequest, x, y, w, h, acquire.rtmFullResolution)
    }

    To allow the application to distinguish easily between images belonging to the reduced data stream and the ones that have been explicitly requested
    by the application the **mvIMPACT::acquire::Request.chunkmvCustomIdentifier** can be used. When requesting a full resolution ROI the application can
    tag the requested images with a custom identifier. This identifier is later returned in the chunk data of the image. The following example demonstrates
    how to use this feature:

    If: DOXYGEN_CPP_DOCUMENTATION {

    .. code-block:: c++

        // switch on the smart frame recall feature
        mvIMPACT::acquire::GenICam::AcquisitionControl ac( pDev );
        ac.mvSmartFrameRecallEnable.write( bTrue );
        // the chunk mode must be switched on to use chunk data for processing:
        mvIMPACT::acquire::GenICam::ChunkDataControl cdc( getDevicePointerFromSomewhere() );
        cdc.chunkModeActive.write( bTrue );
        cdc.chunkSelector.writeS("Image");
        cdc.chunkEnable.write( bTrue );
        // enable the 'mvCustomIdentifier' chunk
        cdc.chunkSelector.writeS("mvCustomIdentifier");
        cdc.chunkEnable.write( bTrue );
        // more code ...
        Request* pRequest = getRequestFromSomewhere();
        uint customID = 42;
        if( pRequest-chunkmvCustomIdentifier.read() == 0 )
        {
          // As the 'mvCustomIdentifier' is 0 this is a frame from the normal stream
          Rect r;
          if( doesImageContainInteresstingData( r ) )
          {
            // request the transmission of the interesting ROI this image in full resolution
            ccg.requestTransmission( pRequest, r.x, r.y, r.w, r.h, rtmFullResolution, customID );
          }
        }
        else if( pRequest-chunkmvCustomIdentifier.read() == static_castint64_type( customID ) )
        {
          // As the 'mvCustomIdentifier' is 'customID' this is a frame explicitly requested by the application
          processImage( pRequest );
        }
        else
        {
          // some other ID (this however must have been set by the application as well)
        }
        // normal 'unlocking' code for requests should reside here!!
        // more code...
    }Else if: DOXYGEN_JAVA_DOCUMENTATION {

    .. code-block:: c++

         CustomCommandGenerator ccg = new CustomCommandGenerator( getDevicePointerFromSomewhere() );
         // switch on the smart frame recall feature
         AcquisitionControl ac = new AcquisitionControl( getDevicePointerFromSomewhere() );
         ac.getMvSmartFrameRecallEnable().write( TBoolean.bTrue );
         // the chunk mode must be switched on to use chunk data for processing:
         ChunkDataControl cdc = new ChunkDataControl( getDevicePointerFromSomewhere() );
         cdc.getChunkModeActive().write( TBoolean.bTrue );
         cdc.getChunkSelector().writeS("Image");
         cdc.getChunkEnable().write( TBoolean.bTrue );
         // enable the 'mvCustomIdentifier' chunk
         cdc.getChunkSelector().writeS( "mvCustomIdentifier" );
         cdc.getChunkEnable().write( TBoolean.bTrue );
         // more code ...
         long customID = 42;
         Request pRequest = getRequestFromSomewhere();
         if( pRequest.getChunkmvCustomIdentifier().read() == 0 )
         {
           // As the 'mvCustomIdentifier' is 0 this is a frame from the normal stream
           Rectangle r = new Rectangle();
           if( doesImageContainInteresstingData( r ) )
           {
             // request the transmission of the interesting ROI this image in full resolution
             ccg.requestTransmission( pRequest, r.x, r.y, r.w, r.h, TRequestTransmissionMode.rtmFullResolution, customID );
           }
         }
         else if( pRequest.getChunkmvCustomIdentifier.read() == customID )
         {
           // As the 'mvCustomIdentifier' is 'customID' this is a frame explicitly requested by the application
           processImage( pRequest );
         }
         else
         {
           // some other ID (this however must have been set by the application as well)
         }
         // normal 'unlocking' code for requests should reside here!!
         // more code...
    }Else if: DOXYGEN_PYTHON_DOCUMENTATION {

    .. code-block:: c++

         ccg = acquire.CustomCommandGenerator(getDeviceReferenceFromSomewhere())
         # switch on the smart frame recall feature
         ac = acquire.AcquisitionControl(getDeviceReferenceFromSomewhere())
         ac.mvSmartFrameRecallEnable.write(acquire.bTrue)
         # the chunk mode must be switched on to use chunk data for processing:
         cdc = acquire.ChunkDataControl(getDeviceReferenceFromSomewhere())
         cdc.chunkModeActive.write(acquire.bTrue)
         cdc.chunkSelector.writeS("Image")
         cdc.chunkEnable.write(acquire.bTrue)
         # enable the 'mvCustomIdentifier' chunk
         cdc.chunkSelector.writeS("mvCustomIdentifier")
         cdc.chunkEnable.write(acquire.bTrue)
         # more code ...
         pRequest = getRequestFromSomewhere()
         customID = 42
         if pRequest.chunkmvCustomIdentifier.read() == 0:
          # As the 'mvCustomIdentifier' is 0 this is a frame from the normal stream
          Rect r # assuming this to be a valid Python class for a rectangle
          if doesImageContainInteresstingData(r):
            # request the transmission of the interesting ROI this image in full resolution
            ccg.requestTransmission(pRequest, r.x, r.y, r.w, r.h, acquire.rtmFullResolution, customID)
         elif pRequest.chunkmvCustomIdentifier.read() == customID:
           # As the 'mvCustomIdentifier' is 'customID' this is a frame explicitly requested by the application
           processImage(pRequest)
         else:
           # some other ID (this however must have been set by the application as well)
         # normal 'unlocking' code for requests should reside here!!
         # more code...
    }

    Since: 2.18.0
    """

    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"""
         Constructs a new **mvIMPACT::acquire::GenICam::CustomCommandGenerator** object.
        :type pDev: :py:class:`Device`
        :param pDev: [in] A pointer to a **mvIMPACT::acquire::Device** object obtained from a **mvIMPACT::acquire::DeviceManager** object.
        :type settingName: string
        :param settingName: [in] The name of the driver internal setting to access with this instance. A list of valid setting names can be obtained by a call to **mvIMPACT::acquire::FunctionInterface::getAvailableSettings**, new settings can be created with the function **mvIMPACT::acquire::FunctionInterface::createSetting**
        """
        lib_mvIMPACT_acquire.CustomCommandGenerator_swiginit(self, lib_mvIMPACT_acquire.new_CustomCommandGenerator(*args))

    def discardCommandBuffer(self):
        r"""
         Discards all pending custom commands to the device.
        This function will discard all pending custom commands. After calling this function
        the pending command queue will be empty an can be filled with new commands.

        Since: 2.18.0

        :rtype: void
        :return: 
            - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
            - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.
        """
        return lib_mvIMPACT_acquire.CustomCommandGenerator_discardCommandBuffer(self)

    def queueTransmissionRequest(self, *args):
        r"""
        *Overload 1:*
         Request the transmission of an image with a certain timestamp in a different mode/ROI.
        If **mvIMPACT::acquire::GenICam::AcquisitionControl::mvSmartFrameRecallEnable** is set to **mvIMPACT::acquire::bTrue** this
        function can be used to request the transmission of the image currently associated with ``pRequest`` in a different mode/resolution.
        One use case would be to transmit every image taken by the sensor with a very coarse resolution e.g. by setting the properties
        **mvIMPACT::acquire::GenICam::ImageFormatControl::decimationHorizontal** and/or **mvIMPACT::acquire::GenICam::ImageFormatControl::decimationVertical**
        to values greater than 1. When then an algorithm finds something interesting within an image this function can be used to request the transmission
        of the very same image in full resolution for detailed processing.

        Since: 2.18.1

        :rtype: int
        :return: 
            - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
            - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.

        :type timestamp_us: int
        :param timestamp_us: [in] The timestamp of the **mvIMPACT::acquire::Request** object shall be transmitted again.
        :type offsetX: int
        :param offsetX: [in] The X-offset of the ROI of the image that shall be transmitted within the current image.
        :type offsetY: int
        :param offsetY: [in] The Y-offset of the ROI of the image that shall be transmitted within the current image.
        :type width: int
        :param width: [in] The width of the ROI of the image that shall be transmitted within the current image.
        :type height: int
        :param height: [in] The height of the ROI of the image that shall be transmitted within the current image.
        :type mode: int
        :param mode: [in] The mode in which this image shall be transmitted.
        :type identifier: int
        :param identifier: [in] A user defined identifier that shall be attached to the image that will be sent as a result of calling this function. This value will be written into the **mvIMPACT::acquire::Request::chunkmvCustomIdentifier** property so in order to actually benefit from this parameter the corresponding chunk must be enabled. See **mvIMPACT::acquire::GenICam::ChunkDataControl** for details.

        |

        *Overload 2:*
         Request the transmission of an image currently associated with the Request object in a different mode/ROI.
        If **mvIMPACT::acquire::GenICam::AcquisitionControl::mvSmartFrameRecallEnable** is set to **mvIMPACT::acquire::bTrue** this
        function can be used to request the transmission of the image currently associated with ``pRequest`` in a different mode/resolution.
        One use case would be to transmit every image taken by the sensor with a very coarse resolution e.g. by setting the properties
        **mvIMPACT::acquire::GenICam::ImageFormatControl::decimationHorizontal** and/or **mvIMPACT::acquire::GenICam::ImageFormatControl::decimationVertical**
        to values greater than 1. When then an algorithm finds something interesting within an image this function can be used to request the transmission
        of the very same image in full resolution for detailed processing.

        Since: 2.18.1

        :rtype: int
        :return: 
            - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
            - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.

        :type pRequest: :py:class:`Request`
        :param pRequest: [in] A pointer to a **mvIMPACT::acquire::Request** object currently associated with the image that shall be transmitted again.
        :type offsetX: int
        :param offsetX: [in] The X-offset of the ROI of the image that shall be transmitted within the current image.
        :type offsetY: int
        :param offsetY: [in] The Y-offset of the ROI of the image that shall be transmitted within the current image.
        :type width: int
        :param width: [in] The width of the ROI of the image that shall be transmitted within the current image.
        :type height: int
        :param height: [in] The height of the ROI of the image that shall be transmitted within the current image.
        :type mode: int
        :param mode: [in] The mode in which this image shall be transmitted.
        :type identifier: int
        :param identifier: [in] A user defined identifier that shall be attached to the image that will be sent as a result of calling this function. This value will be written into the **mvIMPACT::acquire::Request::chunkmvCustomIdentifier** property so in order to actually benefit from this parameter the corresponding chunk must be enabled. See **mvIMPACT::acquire::GenICam::ChunkDataControl** for details.

        |

        *Overload 3:*
         Request the transmission of an image currently associated with the Request object in a different mode/ROI.
        If **mvIMPACT::acquire::GenICam::AcquisitionControl::mvSmartFrameRecallEnable** is set to **mvIMPACT::acquire::bTrue** this
        function can be used to request the transmission of the image currently associated with ``pRequest`` in a different mode/resolution.
        One use case would be to transmit every image taken by the sensor with a very coarse resolution e.g. by setting the properties
        **mvIMPACT::acquire::GenICam::ImageFormatControl::decimationHorizontal** and/or **mvIMPACT::acquire::GenICam::ImageFormatControl::decimationVertical**
        to values greater than 1. When then an algorithm finds something interesting within an image this function can be used to request the transmission
        of the very same image in full resolution for detailed processing.

        Since: 2.18.1

        :rtype: int
        :return: 
            - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
            - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.

        :type pRequest: :py:class:`Request`
        :param pRequest: [in] A pointer to a **mvIMPACT::acquire::Request** object currently associated with the image that shall be transmitted again.
        :type offsetX: int
        :param offsetX: [in] The X-offset of the ROI of the image that shall be transmitted within the current image.
        :type offsetY: int
        :param offsetY: [in] The Y-offset of the ROI of the image that shall be transmitted within the current image.
        :type width: int
        :param width: [in] The width of the ROI of the image that shall be transmitted within the current image.
        :type height: int
        :param height: [in] The height of the ROI of the image that shall be transmitted within the current image.
        :type mode: int
        :param mode: [in] The mode in which this image shall be transmitted.
        :param identifier: [in] A user defined identifier that shall be attached to the image that will be sent as a result of calling this function. This value will be written into the **mvIMPACT::acquire::Request::chunkmvCustomIdentifier** property so in order to actually benefit from this parameter the corresponding chunk must be enabled. See **mvIMPACT::acquire::GenICam::ChunkDataControl** for details.

        |

        *Overload 4:*
         Request the transmission of an image currently associated with the Request object in a different mode/ROI.
        If **mvIMPACT::acquire::GenICam::AcquisitionControl::mvSmartFrameRecallEnable** is set to **mvIMPACT::acquire::bTrue** this
        function can be used to request the transmission of the image currently associated with ``pRequest`` in a different mode/resolution.
        One use case would be to transmit every image taken by the sensor with a very coarse resolution e.g. by setting the properties
        **mvIMPACT::acquire::GenICam::ImageFormatControl::decimationHorizontal** and/or **mvIMPACT::acquire::GenICam::ImageFormatControl::decimationVertical**
        to values greater than 1. When then an algorithm finds something interesting within an image this function can be used to request the transmission
        of the very same image in full resolution for detailed processing.

        Since: 2.18.1

        :rtype: int
        :return: 
            - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
            - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.

        :type pRequest: :py:class:`Request`
        :param pRequest: [in] A pointer to a **mvIMPACT::acquire::Request** object currently associated with the image that shall be transmitted again.
        :type offsetX: int
        :param offsetX: [in] The X-offset of the ROI of the image that shall be transmitted within the current image.
        :type offsetY: int
        :param offsetY: [in] The Y-offset of the ROI of the image that shall be transmitted within the current image.
        :type width: int
        :param width: [in] The width of the ROI of the image that shall be transmitted within the current image.
        :type height: int
        :param height: [in] The height of the ROI of the image that shall be transmitted within the current image.
        :param mode: [in] The mode in which this image shall be transmitted.
        :param identifier: [in] A user defined identifier that shall be attached to the image that will be sent as a result of calling this function. This value will be written into the **mvIMPACT::acquire::Request::chunkmvCustomIdentifier** property so in order to actually benefit from this parameter the corresponding chunk must be enabled. See **mvIMPACT::acquire::GenICam::ChunkDataControl** for details.

        |

        *Overload 5:*
         Request the transmission of an image currently associated with the Request object in full resolution.
        If **mvIMPACT::acquire::GenICam::AcquisitionControl::mvSmartFrameRecallEnable** is set to **mvIMPACT::acquire::bTrue** this
        function can be used to queue the transmission request of the image currently associated with ``pRequest`` in full resolution.
        One use case would be to transmit every image taken by the sensor with a very coarse resolution e.g. by setting the properties
        **mvIMPACT::acquire::GenICam::ImageFormatControl::decimationHorizontal** and/or **mvIMPACT::acquire::GenICam::ImageFormatControl::decimationVertical**
        to values greater than 1. When then an algorithm finds something interesting within an image this function can be used to request the transmission
        of the very same image in full resolution for detailed processing.

        The actual transmission request will not be sent to the device until **mvIMPACT::acquire::GenICam::CustomCommandGenerator::sendCommandBuffer**
        is called. With this function multiple commands can be sent to a device at once. When the new
        command does not fit inside the internal command queue any more all pending commands will be sent
        to the device before the new one is put into the queue.

        See also: 
        **mvIMPACT::acquire::GenICam::CustomCommandGenerator::sendCommandBuffer**

        Since: 2.18.1

        :rtype: int
        :return: 
            - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
            - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.

        :type pRequest: :py:class:`Request`
        :param pRequest: [in] A pointer to a **mvIMPACT::acquire::Request** object currently associated with the image that shall be transmitted again.
        :type identifier: int
        :param identifier: [in] A user defined identifier that shall be attached to the image that will be sent as a result of calling this function. This value will be written into the **mvIMPACT::acquire::Request::chunkmvCustomIdentifier** property so in order to actually benefit from this parameter the corresponding chunk must be enabled. See **mvIMPACT::acquire::GenICam::ChunkDataControl** for details.

        |

        *Overload 6:*
         Request the transmission of an image currently associated with the Request object in full resolution.
        If **mvIMPACT::acquire::GenICam::AcquisitionControl::mvSmartFrameRecallEnable** is set to **mvIMPACT::acquire::bTrue** this
        function can be used to queue the transmission request of the image currently associated with ``pRequest`` in full resolution.
        One use case would be to transmit every image taken by the sensor with a very coarse resolution e.g. by setting the properties
        **mvIMPACT::acquire::GenICam::ImageFormatControl::decimationHorizontal** and/or **mvIMPACT::acquire::GenICam::ImageFormatControl::decimationVertical**
        to values greater than 1. When then an algorithm finds something interesting within an image this function can be used to request the transmission
        of the very same image in full resolution for detailed processing.

        The actual transmission request will not be sent to the device until **mvIMPACT::acquire::GenICam::CustomCommandGenerator::sendCommandBuffer**
        is called. With this function multiple commands can be sent to a device at once. When the new
        command does not fit inside the internal command queue any more all pending commands will be sent
        to the device before the new one is put into the queue.

        See also: 
        **mvIMPACT::acquire::GenICam::CustomCommandGenerator::sendCommandBuffer**

        Since: 2.18.1

        :rtype: int
        :return: 
            - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
            - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.

        :type pRequest: :py:class:`Request`
        :param pRequest: [in] A pointer to a **mvIMPACT::acquire::Request** object currently associated with the image that shall be transmitted again.
        :param identifier: [in] A user defined identifier that shall be attached to the image that will be sent as a result of calling this function. This value will be written into the **mvIMPACT::acquire::Request::chunkmvCustomIdentifier** property so in order to actually benefit from this parameter the corresponding chunk must be enabled. See **mvIMPACT::acquire::GenICam::ChunkDataControl** for details.
        """
        return lib_mvIMPACT_acquire.CustomCommandGenerator_queueTransmissionRequest(self, *args)

    def requestTransmission(self, *args):
        r"""
        *Overload 1:*
         Request the transmission of an image with a certain timestamp in a different mode/ROI.
        This is a convenience function combining a call to **mvIMPACT::acquire::GenICam::CustomCommandGenerator::queueTransmissionRequest**
        directly followed by a call to **mvIMPACT::acquire::GenICam::CustomCommandGenerator::sendCommandBuffer**. Commands which have been
        queued before and have not yet been sent will be sent as well when calling this function.

        If **mvIMPACT::acquire::GenICam::AcquisitionControl::mvSmartFrameRecallEnable** is set to **mvIMPACT::acquire::bTrue** this
        function can be used to request the transmission of the image currently associated with ``pRequest`` in a different mode/resolution.
        One use case would be to transmit every image taken by the sensor with a very coarse resolution e.g. by setting the properties
        **mvIMPACT::acquire::GenICam::ImageFormatControl::decimationHorizontal** and/or **mvIMPACT::acquire::GenICam::ImageFormatControl::decimationVertical**
        to values greater than 1. When then an algorithm finds something interesting within an image this function can be used to request the transmission
        of the very same image in full resolution for detailed processing.

        Since: 2.18.1

        :rtype: int
        :return: 
            - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
            - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.

        :type timestamp_us: int
        :param timestamp_us: [in] The timestamp of the **mvIMPACT::acquire::Request** object shall be transmitted again.
        :type offsetX: int
        :param offsetX: [in] The X-offset of the ROI of the image that shall be transmitted within the current image.
        :type offsetY: int
        :param offsetY: [in] The Y-offset of the ROI of the image that shall be transmitted within the current image.
        :type width: int
        :param width: [in] The width of the ROI of the image that shall be transmitted within the current image.
        :type height: int
        :param height: [in] The height of the ROI of the image that shall be transmitted within the current image.
        :type mode: int
        :param mode: [in] The mode in which this image shall be transmitted.
        :type identifier: int
        :param identifier: [in] A user defined identifier that shall be attached to the image that will be sent as a result of calling this function. This value will be written into the **mvIMPACT::acquire::Request::chunkmvCustomIdentifier** property so in order to actually benefit from this parameter the corresponding chunk must be enabled. See **mvIMPACT::acquire::GenICam::ChunkDataControl** for details.

        |

        *Overload 2:*
         Request the transmission of an image currently associated with the Request object in a different mode/ROI.
        This is a convenience function combining a call to **mvIMPACT::acquire::GenICam::CustomCommandGenerator::queueTransmissionRequest**
        directly followed by a call to **mvIMPACT::acquire::GenICam::CustomCommandGenerator::sendCommandBuffer**. Commands which have been
        queued before and have not yet been sent will be sent as well when calling this function.

        If **mvIMPACT::acquire::GenICam::AcquisitionControl::mvSmartFrameRecallEnable** is set to **mvIMPACT::acquire::bTrue** this
        function can be used to request the transmission of the image currently associated with ``pRequest`` in a different mode/resolution.
        One use case would be to transmit every image taken by the sensor with a very coarse resolution e.g. by setting the properties
        **mvIMPACT::acquire::GenICam::ImageFormatControl::decimationHorizontal** and/or **mvIMPACT::acquire::GenICam::ImageFormatControl::decimationVertical**
        to values greater than 1. When then an algorithm finds something interesting within an image this function can be used to request the transmission
        of the very same image in full resolution for detailed processing.

        Since: 2.18.0

        :rtype: int
        :return: 
            - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
            - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.

        :type pRequest: :py:class:`Request`
        :param pRequest: [in] A pointer to a **mvIMPACT::acquire::Request** object currently associated with the image that shall be transmitted again.
        :type offsetX: int
        :param offsetX: [in] The X-offset of the ROI of the image that shall be transmitted within the current image.
        :type offsetY: int
        :param offsetY: [in] The Y-offset of the ROI of the image that shall be transmitted within the current image.
        :type width: int
        :param width: [in] The width of the ROI of the image that shall be transmitted within the current image.
        :type height: int
        :param height: [in] The height of the ROI of the image that shall be transmitted within the current image.
        :type mode: int
        :param mode: [in] The mode in which this image shall be transmitted.
        :type identifier: int
        :param identifier: [in] A user defined identifier that shall be attached to the image that will be sent as a result of calling this function. This value will be written into the **mvIMPACT::acquire::Request::chunkmvCustomIdentifier** property so in order to actually benefit from this parameter the corresponding chunk must be enabled. See **mvIMPACT::acquire::GenICam::ChunkDataControl** for details.

        |

        *Overload 3:*
         Request the transmission of an image currently associated with the Request object in a different mode/ROI.
        This is a convenience function combining a call to **mvIMPACT::acquire::GenICam::CustomCommandGenerator::queueTransmissionRequest**
        directly followed by a call to **mvIMPACT::acquire::GenICam::CustomCommandGenerator::sendCommandBuffer**. Commands which have been
        queued before and have not yet been sent will be sent as well when calling this function.

        If **mvIMPACT::acquire::GenICam::AcquisitionControl::mvSmartFrameRecallEnable** is set to **mvIMPACT::acquire::bTrue** this
        function can be used to request the transmission of the image currently associated with ``pRequest`` in a different mode/resolution.
        One use case would be to transmit every image taken by the sensor with a very coarse resolution e.g. by setting the properties
        **mvIMPACT::acquire::GenICam::ImageFormatControl::decimationHorizontal** and/or **mvIMPACT::acquire::GenICam::ImageFormatControl::decimationVertical**
        to values greater than 1. When then an algorithm finds something interesting within an image this function can be used to request the transmission
        of the very same image in full resolution for detailed processing.

        Since: 2.18.0

        :rtype: int
        :return: 
            - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
            - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.

        :type pRequest: :py:class:`Request`
        :param pRequest: [in] A pointer to a **mvIMPACT::acquire::Request** object currently associated with the image that shall be transmitted again.
        :type offsetX: int
        :param offsetX: [in] The X-offset of the ROI of the image that shall be transmitted within the current image.
        :type offsetY: int
        :param offsetY: [in] The Y-offset of the ROI of the image that shall be transmitted within the current image.
        :type width: int
        :param width: [in] The width of the ROI of the image that shall be transmitted within the current image.
        :type height: int
        :param height: [in] The height of the ROI of the image that shall be transmitted within the current image.
        :type mode: int
        :param mode: [in] The mode in which this image shall be transmitted.
        :param identifier: [in] A user defined identifier that shall be attached to the image that will be sent as a result of calling this function. This value will be written into the **mvIMPACT::acquire::Request::chunkmvCustomIdentifier** property so in order to actually benefit from this parameter the corresponding chunk must be enabled. See **mvIMPACT::acquire::GenICam::ChunkDataControl** for details.

        |

        *Overload 4:*
         Request the transmission of an image currently associated with the Request object in a different mode/ROI.
        This is a convenience function combining a call to **mvIMPACT::acquire::GenICam::CustomCommandGenerator::queueTransmissionRequest**
        directly followed by a call to **mvIMPACT::acquire::GenICam::CustomCommandGenerator::sendCommandBuffer**. Commands which have been
        queued before and have not yet been sent will be sent as well when calling this function.

        If **mvIMPACT::acquire::GenICam::AcquisitionControl::mvSmartFrameRecallEnable** is set to **mvIMPACT::acquire::bTrue** this
        function can be used to request the transmission of the image currently associated with ``pRequest`` in a different mode/resolution.
        One use case would be to transmit every image taken by the sensor with a very coarse resolution e.g. by setting the properties
        **mvIMPACT::acquire::GenICam::ImageFormatControl::decimationHorizontal** and/or **mvIMPACT::acquire::GenICam::ImageFormatControl::decimationVertical**
        to values greater than 1. When then an algorithm finds something interesting within an image this function can be used to request the transmission
        of the very same image in full resolution for detailed processing.

        Since: 2.18.0

        :rtype: int
        :return: 
            - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
            - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.

        :type pRequest: :py:class:`Request`
        :param pRequest: [in] A pointer to a **mvIMPACT::acquire::Request** object currently associated with the image that shall be transmitted again.
        :type offsetX: int
        :param offsetX: [in] The X-offset of the ROI of the image that shall be transmitted within the current image.
        :type offsetY: int
        :param offsetY: [in] The Y-offset of the ROI of the image that shall be transmitted within the current image.
        :type width: int
        :param width: [in] The width of the ROI of the image that shall be transmitted within the current image.
        :type height: int
        :param height: [in] The height of the ROI of the image that shall be transmitted within the current image.
        :param mode: [in] The mode in which this image shall be transmitted.
        :param identifier: [in] A user defined identifier that shall be attached to the image that will be sent as a result of calling this function. This value will be written into the **mvIMPACT::acquire::Request::chunkmvCustomIdentifier** property so in order to actually benefit from this parameter the corresponding chunk must be enabled. See **mvIMPACT::acquire::GenICam::ChunkDataControl** for details.

        |

        *Overload 5:*
         Request the transmission of an image currently associated with the Request object in full resolution.
        This is a convenience function combining a call to **mvIMPACT::acquire::GenICam::CustomCommandGenerator::queueTransmissionRequest**
        directly followed by a call to **mvIMPACT::acquire::GenICam::CustomCommandGenerator::sendCommandBuffer**. Commands which have been
        queued before and have not yet been sent will be sent as well when calling this function.

        If **mvIMPACT::acquire::GenICam::AcquisitionControl::mvSmartFrameRecallEnable** is set to **mvIMPACT::acquire::bTrue** this
        function can be used to request the transmission of the image currently associated with ``pRequest`` in full resolution.
        One use case would be to transmit every image taken by the sensor with a very coarse resolution e.g. by setting the properties
        **mvIMPACT::acquire::GenICam::ImageFormatControl::decimationHorizontal** and/or **mvIMPACT::acquire::GenICam::ImageFormatControl::decimationVertical**
        to values greater than 1. When then an algorithm finds something interesting within an image this function can be used to request the transmission
        of the very same image in full resolution for detailed processing.

        Since: 2.18.0

        :rtype: int
        :return: 
            - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
            - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.

        :type pRequest: :py:class:`Request`
        :param pRequest: [in] A pointer to a **mvIMPACT::acquire::Request** object currently associated with the image that shall be transmitted again.
        :type identifier: int
        :param identifier: [in] A user defined identifier that shall be attached to the image that will be sent as a result of calling this function. This value will be written into the **mvIMPACT::acquire::Request::chunkmvCustomIdentifier** property so in order to actually benefit from this parameter the corresponding chunk must be enabled. See **mvIMPACT::acquire::GenICam::ChunkDataControl** for details.

        |

        *Overload 6:*
         Request the transmission of an image currently associated with the Request object in full resolution.
        This is a convenience function combining a call to **mvIMPACT::acquire::GenICam::CustomCommandGenerator::queueTransmissionRequest**
        directly followed by a call to **mvIMPACT::acquire::GenICam::CustomCommandGenerator::sendCommandBuffer**. Commands which have been
        queued before and have not yet been sent will be sent as well when calling this function.

        If **mvIMPACT::acquire::GenICam::AcquisitionControl::mvSmartFrameRecallEnable** is set to **mvIMPACT::acquire::bTrue** this
        function can be used to request the transmission of the image currently associated with ``pRequest`` in full resolution.
        One use case would be to transmit every image taken by the sensor with a very coarse resolution e.g. by setting the properties
        **mvIMPACT::acquire::GenICam::ImageFormatControl::decimationHorizontal** and/or **mvIMPACT::acquire::GenICam::ImageFormatControl::decimationVertical**
        to values greater than 1. When then an algorithm finds something interesting within an image this function can be used to request the transmission
        of the very same image in full resolution for detailed processing.

        Since: 2.18.0

        :rtype: int
        :return: 
            - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
            - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.

        :type pRequest: :py:class:`Request`
        :param pRequest: [in] A pointer to a **mvIMPACT::acquire::Request** object currently associated with the image that shall be transmitted again.
        :param identifier: [in] A user defined identifier that shall be attached to the image that will be sent as a result of calling this function. This value will be written into the **mvIMPACT::acquire::Request::chunkmvCustomIdentifier** property so in order to actually benefit from this parameter the corresponding chunk must be enabled. See **mvIMPACT::acquire::GenICam::ChunkDataControl** for details.
        """
        return lib_mvIMPACT_acquire.CustomCommandGenerator_requestTransmission(self, *args)

    def modifySequencerSetValue(self, *args):
        r"""
        *Overload 1:*
         Modifies a value of a certain sequencer set at runtime.
        This is a convenience function combining a call to **mvIMPACT::acquire::GenICam::CustomCommandGenerator::queueSequencerSetValueModification**
        directly followed by a call to **mvIMPACT::acquire::GenICam::CustomCommandGenerator::sendCommandBuffer**. Commands which have been
        queued before and have not yet been sent will be sent as well when calling this function.

        Since: 2.18.0

        :rtype: int
        :return: 
            - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
            - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.

        :type sequencerSet: int
        :param sequencerSet: The index of the sequencer set to modify.
        :type parameter: int
        :param parameter: The parameter within the selected sequencer set to modify.
        :type value: int
        :param value: The new value the selected parameter within the selected sequencer set shall be set to.

        |

        *Overload 2:*
         Modifies a value of a certain sequencer set at runtime.
        This is a convenience function combining a call to **mvIMPACT::acquire::GenICam::CustomCommandGenerator::queueSequencerSetValueModification**
        directly followed by a call to **mvIMPACT::acquire::GenICam::CustomCommandGenerator::sendCommandBuffer**. Commands which have been
        queued before and have not yet been sent will be sent as well when calling this function.

        Since: 2.18.0

        :rtype: int
        :return: 
            - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
            - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.

        :type sequencerSet: int
        :param sequencerSet: The index of the sequencer set to modify.
        :type parameter: int
        :param parameter: The parameter within the selected sequencer set to modify.
        :type value: float
        :param value: The new value the selected parameter within the selected sequencer set shall be set to.
        """
        return lib_mvIMPACT_acquire.CustomCommandGenerator_modifySequencerSetValue(self, *args)

    def queueSequencerSetValueModification(self, *args):
        r"""
        *Overload 1:*
         Queues the modification of a value of a certain sequencer set at runtime.
        This function queues a single parameter modification of a selected sequencer set. The actual
        modification will not become effective until **mvIMPACT::acquire::GenICam::CustomCommandGenerator::sendCommandBuffer**
        is called. With this function multiple modifications can be sent to a device at once. When the new
        command does not fit inside the internal command queue any more all pending commands will be sent
        to the device before the new one is put into the queue.

        See also: 
        **mvIMPACT::acquire::GenICam::CustomCommandGenerator::sendCommandBuffer**

        Since: 2.18.0

        :rtype: int
        :return: 
            - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
            - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.

        :type sequencerSet: int
        :param sequencerSet: The index of the sequencer set to modify.
        :type parameter: int
        :param parameter: The parameter within the selected sequencer set to modify.
        :type value: int
        :param value: The new value the selected parameter within the selected sequencer set shall be set to.

        |

        *Overload 2:*
         Queues the modification of a value of a certain sequencer set at runtime.
        This function queues a single parameter modification of a selected sequencer set. The actual
        modification will not become effective until **mvIMPACT::acquire::GenICam::CustomCommandGenerator::sendCommandBuffer**
        is called. With this function multiple modifications can be sent to a device at once. When the new
        command does not fit inside the internal command queue any more all pending commands will be sent
        to the device before the new one is put into the queue.

        See also: 
        **mvIMPACT::acquire::GenICam::CustomCommandGenerator::sendCommandBuffer**

        Since: 2.18.0

        :rtype: int
        :return: 
            - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
            - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.

        :type sequencerSet: int
        :param sequencerSet: The index of the sequencer set to modify.
        :type parameter: int
        :param parameter: The parameter within the selected sequencer set to modify.
        :type value: float
        :param value: The new value the selected parameter within the selected sequencer set shall be set to.
        """
        return lib_mvIMPACT_acquire.CustomCommandGenerator_queueSequencerSetValueModification(self, *args)

    def sendCommandBuffer(self):
        r"""
         Applies all pending custom commands to the device.
        This function will send all pending custom commands to a device. After calling this function
        the pending command queue will be empty an can be filled with new commands. Calling this function
        multiple times without queuing new commands after each send will have no effect!

        Since: 2.18.0

        :rtype: int
        :return: 
            - **mvIMPACT::acquire::DMR_NO_ERROR** if successful.
            - A negative error code of type **mvIMPACT::acquire::TDMR_ERROR** otherwise.
        """
        return lib_mvIMPACT_acquire.CustomCommandGenerator_sendCommandBuffer(self)

    def commandBufferSize(self):
        r"""
         Returns the size of the command buffer for this device in bytes.
        Since: 2.18.0

        :rtype: int
        :return: The size of the command buffer for this device in bytes.
        """
        return lib_mvIMPACT_acquire.CustomCommandGenerator_commandBufferSize(self)

    def commandBufferSizeUsed(self):
        r"""
         Returns the amount of bytes of the command buffer currently used(thus the amount of bytes that await sending) for this device in bytes.
        Since: 2.18.0

        :rtype: int
        :return: The amount of bytes of the command buffer currently used(thus the amount of bytes that await sending) for this device in bytes.
        """
        return lib_mvIMPACT_acquire.CustomCommandGenerator_commandBufferSizeUsed(self)
    __swig_destroy__ = lib_mvIMPACT_acquire.delete_CustomCommandGenerator

# Register CustomCommandGenerator in lib_mvIMPACT_acquire:
lib_mvIMPACT_acquire.CustomCommandGenerator_swigregister(CustomCommandGenerator)



