from __future__ import annotations
import pxr.Vt._vt
import typing
import Boost.Python

__all__ = [
    "AllTrue",
    "AnyTrue",
    "Bool",
    "BoolArray",
    "BoolArrayFromBuffer",
    "Cat",
    "CharArray",
    "CharArrayFromBuffer",
    "Double",
    "DoubleArray",
    "DoubleArrayFromBuffer",
    "DualQuatdArray",
    "DualQuatdArrayFromBuffer",
    "DualQuatfArray",
    "DualQuatfArrayFromBuffer",
    "DualQuathArray",
    "DualQuathArrayFromBuffer",
    "Equal",
    "Float",
    "FloatArray",
    "FloatArrayFromBuffer",
    "Greater",
    "GreaterOrEqual",
    "Half",
    "HalfArray",
    "HalfArrayFromBuffer",
    "Int",
    "Int64",
    "Int64Array",
    "Int64ArrayFromBuffer",
    "IntArray",
    "IntArrayFromBuffer",
    "IntervalArray",
    "Less",
    "LessOrEqual",
    "Long",
    "Matrix2dArray",
    "Matrix2dArrayFromBuffer",
    "Matrix2fArray",
    "Matrix2fArrayFromBuffer",
    "Matrix3dArray",
    "Matrix3dArrayFromBuffer",
    "Matrix3fArray",
    "Matrix3fArrayFromBuffer",
    "Matrix4dArray",
    "Matrix4dArrayFromBuffer",
    "Matrix4fArray",
    "Matrix4fArrayFromBuffer",
    "NotEqual",
    "QuatdArray",
    "QuatdArrayFromBuffer",
    "QuaternionArray",
    "QuatfArray",
    "QuatfArrayFromBuffer",
    "QuathArray",
    "QuathArrayFromBuffer",
    "Range1dArray",
    "Range1dArrayFromBuffer",
    "Range1fArray",
    "Range1fArrayFromBuffer",
    "Range2dArray",
    "Range2dArrayFromBuffer",
    "Range2fArray",
    "Range2fArrayFromBuffer",
    "Range3dArray",
    "Range3dArrayFromBuffer",
    "Range3fArray",
    "Range3fArrayFromBuffer",
    "Rect2iArray",
    "Rect2iArrayFromBuffer",
    "Short",
    "ShortArray",
    "ShortArrayFromBuffer",
    "StringArray",
    "Token",
    "TokenArray",
    "UChar",
    "UCharArray",
    "UCharArrayFromBuffer",
    "UInt",
    "UInt64",
    "UInt64Array",
    "UInt64ArrayFromBuffer",
    "UIntArray",
    "UIntArrayFromBuffer",
    "ULong",
    "UShort",
    "UShortArray",
    "UShortArrayFromBuffer",
    "Vec2dArray",
    "Vec2dArrayFromBuffer",
    "Vec2fArray",
    "Vec2fArrayFromBuffer",
    "Vec2hArray",
    "Vec2hArrayFromBuffer",
    "Vec2iArray",
    "Vec2iArrayFromBuffer",
    "Vec3dArray",
    "Vec3dArrayFromBuffer",
    "Vec3fArray",
    "Vec3fArrayFromBuffer",
    "Vec3hArray",
    "Vec3hArrayFromBuffer",
    "Vec3iArray",
    "Vec3iArrayFromBuffer",
    "Vec4dArray",
    "Vec4dArrayFromBuffer",
    "Vec4fArray",
    "Vec4fArrayFromBuffer",
    "Vec4hArray",
    "Vec4hArrayFromBuffer",
    "Vec4iArray",
    "Vec4iArrayFromBuffer"
]


class BoolArray(Boost.Python.instance):
    """
    An array of type bool.
    """
    _isVtArray = True
    pass
class CharArray(Boost.Python.instance):
    """
    An array of type char.
    """
    _isVtArray = True
    pass
class DoubleArray(Boost.Python.instance):
    """
    An array of type double.
    """
    _isVtArray = True
    pass
class DualQuatdArray(Boost.Python.instance):
    """
    An array of type GfDualQuatd.
    """
    _isVtArray = True
    pass
class DualQuatfArray(Boost.Python.instance):
    """
    An array of type GfDualQuatf.
    """
    _isVtArray = True
    pass
class DualQuathArray(Boost.Python.instance):
    """
    An array of type GfDualQuath.
    """
    _isVtArray = True
    pass
class FloatArray(Boost.Python.instance):
    """
    An array of type float.
    """
    _isVtArray = True
    pass
class HalfArray(Boost.Python.instance):
    """
    An array of type pxr_half::half.
    """
    _isVtArray = True
    pass
class Int64Array(Boost.Python.instance):
    """
    An array of type __int64.
    """
    _isVtArray = True
    pass
class IntArray(Boost.Python.instance):
    """
    An array of type int.
    """
    _isVtArray = True
    pass
class IntervalArray(Boost.Python.instance):
    """
    An array of type GfInterval.
    """
    _isVtArray = True
    pass
class Matrix2dArray(Boost.Python.instance):
    """
    An array of type GfMatrix2d.
    """
    _isVtArray = True
    pass
class Matrix2fArray(Boost.Python.instance):
    """
    An array of type GfMatrix2f.
    """
    _isVtArray = True
    pass
class Matrix3dArray(Boost.Python.instance):
    """
    An array of type GfMatrix3d.
    """
    _isVtArray = True
    pass
class Matrix3fArray(Boost.Python.instance):
    """
    An array of type GfMatrix3f.
    """
    _isVtArray = True
    pass
class Matrix4dArray(Boost.Python.instance):
    """
    An array of type GfMatrix4d.
    """
    _isVtArray = True
    pass
class Matrix4fArray(Boost.Python.instance):
    """
    An array of type GfMatrix4f.
    """
    _isVtArray = True
    pass
class QuatdArray(Boost.Python.instance):
    """
    An array of type GfQuatd.
    """
    _isVtArray = True
    pass
class QuaternionArray(Boost.Python.instance):
    """
    An array of type GfQuaternion.
    """
    _isVtArray = True
    pass
class QuatfArray(Boost.Python.instance):
    """
    An array of type GfQuatf.
    """
    _isVtArray = True
    pass
class QuathArray(Boost.Python.instance):
    """
    An array of type GfQuath.
    """
    _isVtArray = True
    pass
class Range1dArray(Boost.Python.instance):
    """
    An array of type GfRange1d.
    """
    _isVtArray = True
    pass
class Range1fArray(Boost.Python.instance):
    """
    An array of type GfRange1f.
    """
    _isVtArray = True
    pass
class Range2dArray(Boost.Python.instance):
    """
    An array of type GfRange2d.
    """
    _isVtArray = True
    pass
class Range2fArray(Boost.Python.instance):
    """
    An array of type GfRange2f.
    """
    _isVtArray = True
    pass
class Range3dArray(Boost.Python.instance):
    """
    An array of type GfRange3d.
    """
    _isVtArray = True
    pass
class Range3fArray(Boost.Python.instance):
    """
    An array of type GfRange3f.
    """
    _isVtArray = True
    pass
class Rect2iArray(Boost.Python.instance):
    """
    An array of type GfRect2i.
    """
    _isVtArray = True
    pass
class ShortArray(Boost.Python.instance):
    """
    An array of type short.
    """
    _isVtArray = True
    pass
class StringArray(Boost.Python.instance):
    """
    An array of type string.
    """
    _isVtArray = True
    pass
class TokenArray(Boost.Python.instance):
    """
    An array of type TfToken.
    """
    _isVtArray = True
    pass
class UCharArray(Boost.Python.instance):
    """
    An array of type unsigned char.
    """
    _isVtArray = True
    pass
class UInt64Array(Boost.Python.instance):
    """
    An array of type unsigned __int64.
    """
    _isVtArray = True
    pass
class UIntArray(Boost.Python.instance):
    """
    An array of type unsigned int.
    """
    _isVtArray = True
    pass
class UShortArray(Boost.Python.instance):
    """
    An array of type unsigned short.
    """
    _isVtArray = True
    pass
class Vec2dArray(Boost.Python.instance):
    """
    An array of type GfVec2d.
    """
    _isVtArray = True
    pass
class Vec2fArray(Boost.Python.instance):
    """
    An array of type GfVec2f.
    """
    _isVtArray = True
    pass
class Vec2hArray(Boost.Python.instance):
    """
    An array of type GfVec2h.
    """
    _isVtArray = True
    pass
class Vec2iArray(Boost.Python.instance):
    """
    An array of type GfVec2i.
    """
    _isVtArray = True
    pass
class Vec3dArray(Boost.Python.instance):
    """
    An array of type GfVec3d.
    """
    _isVtArray = True
    pass
class Vec3fArray(Boost.Python.instance):
    """
    An array of type GfVec3f.
    """
    _isVtArray = True
    pass
class Vec3hArray(Boost.Python.instance):
    """
    An array of type GfVec3h.
    """
    _isVtArray = True
    pass
class Vec3iArray(Boost.Python.instance):
    """
    An array of type GfVec3i.
    """
    _isVtArray = True
    pass
class Vec4dArray(Boost.Python.instance):
    """
    An array of type GfVec4d.
    """
    _isVtArray = True
    pass
class Vec4fArray(Boost.Python.instance):
    """
    An array of type GfVec4f.
    """
    _isVtArray = True
    pass
class Vec4hArray(Boost.Python.instance):
    """
    An array of type GfVec4h.
    """
    _isVtArray = True
    pass
class Vec4iArray(Boost.Python.instance):
    """
    An array of type GfVec4i.
    """
    _isVtArray = True
    pass
class _ValueWrapper(Boost.Python.instance):
    pass
def AllTrue(*args, **kwargs) -> None:
    pass
def AnyTrue(*args, **kwargs) -> None:
    pass
def Bool(value) -> _ValueWrapper:
    """
    value : bool

    Use this function to specify a value with the explicit C++ type bool when calling a C++ wrapped function that expects a VtValue. (There are some C++ types that have no equivalents in Python, such as short.)
    """
def BoolArrayFromBuffer(*args, **kwargs) -> None:
    pass
def Cat(*args, **kwargs) -> None:
    pass
def CharArrayFromBuffer(*args, **kwargs) -> None:
    pass
def Double(value) -> _ValueWrapper:
    """
    value : double

    Use this function to specify a value with the explicit C++ type double when calling a C++ wrapped function that expects a VtValue. (There are some C++ types that have no equivalents in Python, such as short.)
    """
def DoubleArrayFromBuffer(*args, **kwargs) -> None:
    pass
def DualQuatdArrayFromBuffer(*args, **kwargs) -> None:
    pass
def DualQuatfArrayFromBuffer(*args, **kwargs) -> None:
    pass
def DualQuathArrayFromBuffer(*args, **kwargs) -> None:
    pass
def Equal(*args, **kwargs) -> None:
    pass
def Float(value) -> _ValueWrapper:
    """
    value : float

    Use this function to specify a value with the explicit C++ type float when calling a C++ wrapped function that expects a VtValue. (There are some C++ types that have no equivalents in Python, such as short.)
    """
def FloatArrayFromBuffer(*args, **kwargs) -> None:
    pass
def Greater(*args, **kwargs) -> None:
    pass
def GreaterOrEqual(*args, **kwargs) -> None:
    pass
def Half(value) -> _ValueWrapper:
    """
    value : half

    Use this function to specify a value with the explicit C++ type GfHalf when calling a C++ wrapped function that expects a VtValue. (There are some C++ types that have no equivalents in Python, such as short.)
    """
def HalfArrayFromBuffer(*args, **kwargs) -> None:
    pass
def Int(value) -> _ValueWrapper:
    """
    value : int

    Use this function to specify a value with the explicit C++ type int when calling a C++ wrapped function that expects a VtValue. (There are some C++ types that have no equivalents in Python, such as short.)
    """
def Int64(value) -> _ValueWrapper:
    """
    value : int64_t

    Use this function to specify a value with the explicit C++ type int64_t when calling a C++ wrapped function that expects a VtValue. (There are some C++ types that have no equivalents in Python, such as short.)
    """
def Int64ArrayFromBuffer(*args, **kwargs) -> None:
    pass
def IntArrayFromBuffer(*args, **kwargs) -> None:
    pass
def Less(*args, **kwargs) -> None:
    pass
def LessOrEqual(*args, **kwargs) -> None:
    pass
def Long(value) -> _ValueWrapper:
    """
    value : long

    Use this function to specify a value with the explicit C++ type long when calling a C++ wrapped function that expects a VtValue. (There are some C++ types that have no equivalents in Python, such as short.)
    """
def Matrix2dArrayFromBuffer(*args, **kwargs) -> None:
    pass
def Matrix2fArrayFromBuffer(*args, **kwargs) -> None:
    pass
def Matrix3dArrayFromBuffer(*args, **kwargs) -> None:
    pass
def Matrix3fArrayFromBuffer(*args, **kwargs) -> None:
    pass
def Matrix4dArrayFromBuffer(*args, **kwargs) -> None:
    pass
def Matrix4fArrayFromBuffer(*args, **kwargs) -> None:
    pass
def NotEqual(*args, **kwargs) -> None:
    pass
def QuatdArrayFromBuffer(*args, **kwargs) -> None:
    pass
def QuatfArrayFromBuffer(*args, **kwargs) -> None:
    pass
def QuathArrayFromBuffer(*args, **kwargs) -> None:
    pass
def Range1dArrayFromBuffer(*args, **kwargs) -> None:
    pass
def Range1fArrayFromBuffer(*args, **kwargs) -> None:
    pass
def Range2dArrayFromBuffer(*args, **kwargs) -> None:
    pass
def Range2fArrayFromBuffer(*args, **kwargs) -> None:
    pass
def Range3dArrayFromBuffer(*args, **kwargs) -> None:
    pass
def Range3fArrayFromBuffer(*args, **kwargs) -> None:
    pass
def Rect2iArrayFromBuffer(*args, **kwargs) -> None:
    pass
def Short(value) -> _ValueWrapper:
    """
    value : short

    Use this function to specify a value with the explicit C++ type short when calling a C++ wrapped function that expects a VtValue. (There are some C++ types that have no equivalents in Python, such as short.)
    """
def ShortArrayFromBuffer(*args, **kwargs) -> None:
    pass
def Token(*args, **kwargs) -> None:
    """
    value : TfToken

    Use this function to specify a value with the explicit C++ type TfToken when calling a C++ wrapped function that expects a VtValue. (There are some C++ types that have no equivalents in Python, such as short.)
    """
def UChar(value) -> _ValueWrapper:
    """
    value : unsigned char

    Use this function to specify a value with the explicit C++ type unsigned char when calling a C++ wrapped function that expects a VtValue. (There are some C++ types that have no equivalents in Python, such as short.)
    """
def UCharArrayFromBuffer(*args, **kwargs) -> None:
    pass
def UInt(value) -> _ValueWrapper:
    """
    value : unsigned int

    Use this function to specify a value with the explicit C++ type unsigned int when calling a C++ wrapped function that expects a VtValue. (There are some C++ types that have no equivalents in Python, such as short.)
    """
def UInt64(value) -> _ValueWrapper:
    """
    value : uint64_t

    Use this function to specify a value with the explicit C++ type uint64_t when calling a C++ wrapped function that expects a VtValue. (There are some C++ types that have no equivalents in Python, such as short.)
    """
def UInt64ArrayFromBuffer(*args, **kwargs) -> None:
    pass
def UIntArrayFromBuffer(*args, **kwargs) -> None:
    pass
def ULong(value) -> _ValueWrapper:
    """
    value : unsigned long

    Use this function to specify a value with the explicit C++ type unsigned long when calling a C++ wrapped function that expects a VtValue. (There are some C++ types that have no equivalents in Python, such as short.)
    """
def UShort(value) -> _ValueWrapper:
    """
    value : unsigned short

    Use this function to specify a value with the explicit C++ type unsigned short when calling a C++ wrapped function that expects a VtValue. (There are some C++ types that have no equivalents in Python, such as short.)
    """
def UShortArrayFromBuffer(*args, **kwargs) -> None:
    pass
def Vec2dArrayFromBuffer(*args, **kwargs) -> None:
    pass
def Vec2fArrayFromBuffer(*args, **kwargs) -> None:
    pass
def Vec2hArrayFromBuffer(*args, **kwargs) -> None:
    pass
def Vec2iArrayFromBuffer(*args, **kwargs) -> None:
    pass
def Vec3dArrayFromBuffer(*args, **kwargs) -> None:
    pass
def Vec3fArrayFromBuffer(*args, **kwargs) -> None:
    pass
def Vec3hArrayFromBuffer(*args, **kwargs) -> None:
    pass
def Vec3iArrayFromBuffer(*args, **kwargs) -> None:
    pass
def Vec4dArrayFromBuffer(*args, **kwargs) -> None:
    pass
def Vec4fArrayFromBuffer(*args, **kwargs) -> None:
    pass
def Vec4hArrayFromBuffer(*args, **kwargs) -> None:
    pass
def Vec4iArrayFromBuffer(*args, **kwargs) -> None:
    pass
def _ReturnDictionary(*args, **kwargs) -> None:
    pass
def _test_Ident(*args, **kwargs) -> None:
    pass
def _test_Str(*args, **kwargs) -> None:
    pass
def _test_ValueTypeName(*args, **kwargs) -> None:
    pass
__MFB_FULL_PACKAGE_NAME = 'vt'
