cl30

const (
	// False is the Bool value representing "false".
	False Bool = C.CL_FALSE
	// True is the Bool value representing "true".
	True Bool = C.CL_TRUE
)

const (
	// BufferCreateTypeRegion describes a buffer object that represents a specific region in buffer.
	//
	// Creation data type: BufferRegion
	// Since: 1.1
	BufferCreateTypeRegion BufferCreateType = C.CL_BUFFER_CREATE_TYPE_REGION
)

const (
	// BuildNoneStatus is the build status returned if no BuildProgram(), CompileProgram(), or LinkProgram() has been
	// performed on the specified program object for device.
	BuildNoneStatus BuildStatus = C.CL_BUILD_NONE
	// BuildSuccessStatus is the build status returned if BuildProgram(), CompileProgram(), or LinkProgram() -
	// whichever was performed last on the specified program object for device - was successful.
	BuildSuccessStatus BuildStatus = C.CL_BUILD_SUCCESS
	// BuildErrorStatus is the build status returned if BuildProgram(), CompileProgram(), or LinkProgram() -
	// whichever was performed last on the specified program object for device - generated an error.
	BuildErrorStatus BuildStatus = C.CL_BUILD_ERROR
	// BuildInProgressStatus is the build status returned if BuildProgram(), CompileProgram(), or LinkProgram() -
	// whichever was performed last on the specified program object for device - has not finished.
	BuildInProgressStatus BuildStatus = C.CL_BUILD_IN_PROGRESS
)

const (
	ChannelOrderR         ChannelOrder = C.CL_R
	ChannelOrderA         ChannelOrder = C.CL_A
	ChannelOrderRg        ChannelOrder = C.CL_RG
	ChannelOrderRa        ChannelOrder = C.CL_RA
	ChannelOrderRgb       ChannelOrder = C.CL_RGB
	ChannelOrderRgba      ChannelOrder = C.CL_RGBA
	ChannelOrderBgra      ChannelOrder = C.CL_BGRA
	ChannelOrderArgb      ChannelOrder = C.CL_ARGB
	ChannelOrderIntensity ChannelOrder = C.CL_INTENSITY
	ChannelOrderLuminance ChannelOrder = C.CL_LUMINANCE

	ChannelOrderRx   ChannelOrder = C.CL_Rx
	ChannelOrderRgx  ChannelOrder = C.CL_RGx
	ChannelOrderRgbx ChannelOrder = C.CL_RGBx

	ChannelOrderDepth   ChannelOrder = C.CL_DEPTH
	ChannelOrderStencil ChannelOrder = C.CL_DEPTH_STENCIL

	ChannelOrderSrgb  ChannelOrder = C.CL_sRGB
	ChannelOrderSrgbx ChannelOrder = C.CL_sRGBx
	ChannelOrderSrgba ChannelOrder = C.CL_sRGBA
	ChannelOrderSbgra ChannelOrder = C.CL_sBGRA
	ChannelOrderAbgr  ChannelOrder = C.CL_ABGR
)

const (
	ChannelTypeSnormInt8      ChannelType = C.CL_SNORM_INT8
	ChannelTypeSnormInt16     ChannelType = C.CL_SNORM_INT16
	ChannelTypeUnormInt8      ChannelType = C.CL_UNORM_INT8
	ChannelTypeUnormInt16     ChannelType = C.CL_UNORM_INT16
	ChannelTypeUnormShort565  ChannelType = C.CL_UNORM_SHORT_565
	ChannelTypeUnormShort555  ChannelType = C.CL_UNORM_SHORT_555
	ChannelTypeUnormInt101010 ChannelType = C.CL_UNORM_INT_101010
	ChannelTypeSignedInt8     ChannelType = C.CL_SIGNED_INT8
	ChannelTypeSignedInt16    ChannelType = C.CL_SIGNED_INT16
	ChannelTypeSignedInt32    ChannelType = C.CL_SIGNED_INT32
	ChannelTypeUnsignedInt8   ChannelType = C.CL_UNSIGNED_INT8
	ChannelTypeUnsignedInt16  ChannelType = C.CL_UNSIGNED_INT16
	ChannelTypeUnsignedInt32  ChannelType = C.CL_UNSIGNED_INT32
	ChannelTypeHalfFloat      ChannelType = C.CL_HALF_FLOAT
	ChannelTypeFloat          ChannelType = C.CL_FLOAT

	ChannelTypeUnormInt24 ChannelType = C.CL_UNORM_INT24

	ChannelTypeUnormInt1010102 ChannelType = C.CL_UNORM_INT_101010_2
)

const (
	// QueueContextInfo returns the context specified when the command-queue is created.
	//
	// Returned type: Context
	QueueContextInfo CommandQueueInfoName = C.CL_QUEUE_CONTEXT
	// QueueDeviceInfo returns the device specified when the command-queue is created
	//
	// Returned type: DeviceID
	QueueDeviceInfo CommandQueueInfoName = C.CL_QUEUE_DEVICE
	// QueueReferenceCountInfo returns the command-queue reference count.
	//
	// Note: The reference count returned should be considered immediately stale. It is unsuitable for
	// general use in applications. This feature is provided for identifying memory leaks.
	//
	// Returned type: uint32
	QueueReferenceCountInfo CommandQueueInfoName = C.CL_QUEUE_REFERENCE_COUNT
	// QueuePropertiesInfo returns the currently specified properties for the command-queue.
	// These properties are specified by the value associated with the QueuePropertiesProperty passed in properties
	// argument in CreateCommandQueueWithProperties(), or the value of the properties argument in CreateCommandQueue().
	//
	// Returned type: uint64
	QueuePropertiesInfo CommandQueueInfoName = C.CL_QUEUE_PROPERTIES
	// QueuePropertiesArrayInfo returns the properties argument specified in CreateCommandQueueWithProperties().
	//
	// Returned type: []uint64
	// Since: 3.0
	QueuePropertiesArrayInfo CommandQueueInfoName = C.CL_QUEUE_PROPERTIES_ARRAY
	// QueueSizeInfo returns the size of the device command-queue. To be considered valid for this query,
	// the command-queue must be a device command-queue.
	//
	// Returned type: uint32
	// Since: 2.0
	QueueSizeInfo CommandQueueInfoName = C.CL_QUEUE_SIZE
	// QueueDeviceDefaultInfo returns the current default command-queue for the underlying device.
	//
	// Returned type: CommandQueue
	// Since: 2.1
	QueueDeviceDefaultInfo CommandQueueInfoName = C.CL_QUEUE_DEVICE_DEFAULT
)

const (
	// QueueOutOfOrderExecModeEnable determines whether the commands queued in the command-queue are executed
	// in-order or out-of-order. If set, the commands in the command-queue are executed out-of-order.
	// Otherwise, commands are executed in-order.
	QueueOutOfOrderExecModeEnable CommandQueuePropertiesFlags = C.CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE
	// QueueProfilingEnable enables or disables profiling of commands in the command-queue. If set,
	// the profiling of commands is enabled. Otherwise, profiling of commands is disabled.
	QueueProfilingEnable CommandQueuePropertiesFlags = C.CL_QUEUE_PROFILING_ENABLE
	// QueueOnDevice indicates that this is a device queue. If QueueOnDevice is set, QueueOutOfOrderExecModeEnable
	// must also be set. Only out-of-order device queues are supported.
	//
	// Since: 2.0
	QueueOnDevice CommandQueuePropertiesFlags = C.CL_QUEUE_ON_DEVICE
	// QueueOnDeviceDefault indicates that this is the default device queue.
	// This can only be used with QueueOnDevice.
	//
	// Since: 2.0
	QueueOnDeviceDefault CommandQueuePropertiesFlags = C.CL_QUEUE_ON_DEVICE_DEFAULT
)

const (
	// ContextReferenceCountInfo returns the context reference count.
	//
	// Note: The reference count returned should be considered immediately stale. It is unsuitable for
	// general use in applications. This feature is provided for identifying memory leaks.
	//
	// Returned type: uint32
	ContextReferenceCountInfo ContextInfoName = C.CL_CONTEXT_REFERENCE_COUNT
	// ContextDevicesInfo returns the list of devices and sub-devices in context.
	//
	// Returned type: []DeviceID
	ContextDevicesInfo ContextInfoName = C.CL_CONTEXT_DEVICES
	// ContextNumDevicesInfo returns the number of devices in context.
	//
	// Returned type: uint32
	// Since: 1.1
	ContextNumDevicesInfo ContextInfoName = C.CL_CONTEXT_NUM_DEVICES
	// ContextPropertiesInfo returns the properties argument specified in CreateContext() or CreateContextFromType().
	//
	// The returned list is the concatenated list of all the properties provided at creation.
	// This list also includes the terminating zero value.
	//
	// Returned type: []uintptr
	ContextPropertiesInfo ContextInfoName = C.CL_CONTEXT_PROPERTIES
)

const (
	// DeviceAffinityDomainNuma splits the device into sub-devices comprised of compute units that share a NUMA node.
	//
	// Since: 1.2
	DeviceAffinityDomainNuma DeviceAffinityDomainFlags = C.CL_DEVICE_AFFINITY_DOMAIN_NUMA
	// DeviceAffinityDomainL4Cache splits the device into sub-devices comprised of compute units that share a
	// level 4 data cache.
	//
	// Since: 1.2
	DeviceAffinityDomainL4Cache DeviceAffinityDomainFlags = C.CL_DEVICE_AFFINITY_DOMAIN_L4_CACHE
	// DeviceAffinityDomainL3Cache splits the device into sub-devices comprised of compute units that share a
	// level 3 data cache.
	//
	// Since: 1.2
	DeviceAffinityDomainL3Cache DeviceAffinityDomainFlags = C.CL_DEVICE_AFFINITY_DOMAIN_L3_CACHE
	// DeviceAffinityDomainL2Cache splits the device into sub-devices comprised of compute units that share a
	// level 2 data cache.
	//
	// Since: 1.2
	DeviceAffinityDomainL2Cache DeviceAffinityDomainFlags = C.CL_DEVICE_AFFINITY_DOMAIN_L2_CACHE
	// DeviceAffinityDomainL1Cache splits the device into sub-devices comprised of compute units that share a
	// level 1 data cache.
	//
	// Since: 1.2
	DeviceAffinityDomainL1Cache DeviceAffinityDomainFlags = C.CL_DEVICE_AFFINITY_DOMAIN_L1_CACHE
	// DeviceAffinityDomainNextPartitionable splits the device along the next partitionable affinity domain.
	// The implementation shall find the first level along which the device or sub-device may be further subdivided
	// in the order NUMA, L4, L3, L2, L1, and partition the device into sub-devices comprised of compute units that
	// share memory subsystems at this level.
	//
	// Determine what happened by calling DeviceInfo() with DevicePartitionTypeInfo on the sub-devices.
	//
	// Since: 1.2
	DeviceAffinityDomainNextPartitionable DeviceAffinityDomainFlags = C.CL_DEVICE_AFFINITY_DOMAIN_NEXT_PARTITIONABLE
)

const (
	// DeviceAtomicOrderRelaxed identifies support for the relaxed memory order.
	//
	// Since: 3.0
	DeviceAtomicOrderRelaxed DeviceAtomicCapabilitiesFlags = C.CL_DEVICE_ATOMIC_ORDER_RELAXED
	// DeviceAtomicOrderAcqRel identifies support for the "acquire", "release", and "acquire-release" memory orders.
	//
	// Since: 3.0
	DeviceAtomicOrderAcqRel DeviceAtomicCapabilitiesFlags = C.CL_DEVICE_ATOMIC_ORDER_ACQ_REL
	// DeviceAtomicOrderSeqCst identifies support for the sequentially consistent memory order.
	//
	// Since: 3.0
	DeviceAtomicOrderSeqCst DeviceAtomicCapabilitiesFlags = C.CL_DEVICE_ATOMIC_ORDER_SEQ_CST
	// DeviceAtomicScopeWorkItem identifies support for memory ordering constraints that apply to a single work-item.
	//
	// Note that this flag does not provide meaning for atomic memory operations, but only for atomic fence operations
	// in certain circumstances, refer to the Memory Scope section of the OpenCL C specification.
	//
	// Since: 3.0
	DeviceAtomicScopeWorkItem DeviceAtomicCapabilitiesFlags = C.CL_DEVICE_ATOMIC_SCOPE_WORK_ITEM
	// DeviceAtomicScopeWorkGroup identifies support for memory ordering constraints that apply to all work-items
	// in a work-group.
	//
	// Since: 3.0
	DeviceAtomicScopeWorkGroup DeviceAtomicCapabilitiesFlags = C.CL_DEVICE_ATOMIC_SCOPE_WORK_GROUP
	// DeviceAtomicScopeDevice identifies support for memory ordering constraints that apply to all work-items
	// executing on the device.
	//
	// Since: 3.0
	DeviceAtomicScopeDevice DeviceAtomicCapabilitiesFlags = C.CL_DEVICE_ATOMIC_SCOPE_DEVICE
	// DeviceAtomicScopeAllDevices identifies support for memory ordering constraints that apply to all work-items
	// executing across all devices that can share SVM memory with each other and the host process.
	//
	// Since: 3.0
	DeviceAtomicScopeAllDevices DeviceAtomicCapabilitiesFlags = C.CL_DEVICE_ATOMIC_SCOPE_ALL_DEVICES
)

const (
	// DeviceQueueSupported identifies that the device supports device-side enqueue and on-device queues.
	//
	// Since: 3.0
	DeviceQueueSupported DeviceDeviceEnqueueCapabilitiesFlags = C.CL_DEVICE_QUEUE_SUPPORTED
	// DeviceQueueReplaceableDefault identifies that the device supports a replaceable default on-device queue.
	//
	// Since: 3.0
	DeviceQueueReplaceableDefault DeviceDeviceEnqueueCapabilitiesFlags = C.CL_DEVICE_QUEUE_REPLACEABLE_DEFAULT
)

const (
	// ExecKernel identifies that the OpenCL device can execute OpenCL kernels.
	ExecKernel DeviceExecCapabilitiesFlags = C.CL_EXEC_KERNEL
	// ExecNativeKernel identifies that the OpenCL device can execute native kernels.
	ExecNativeKernel DeviceExecCapabilitiesFlags = C.CL_EXEC_NATIVE_KERNEL
)

const (
	// FpDenorm identifies denorms are supported.
	FpDenorm DeviceFpConfigFlags = C.CL_FP_DENORM
	// FpInfNan identifies INF and quiet NaNs are supported.
	FpInfNan DeviceFpConfigFlags = C.CL_FP_INF_NAN
	// FpRoundToNearest identifies round to nearest even rounding mode supported.
	FpRoundToNearest DeviceFpConfigFlags = C.CL_FP_ROUND_TO_NEAREST
	// FpRoundToZero identifies round to zero rounding mode supported.
	FpRoundToZero DeviceFpConfigFlags = C.CL_FP_ROUND_TO_ZERO
	// FpRoundToInf identifies round to positive and negative infinity rounding modes supported.
	FpRoundToInf DeviceFpConfigFlags = C.CL_FP_ROUND_TO_INF
	// FpFma identifies IEEE754-2008 fused multiply-add is supported.
	FpFma DeviceFpConfigFlags = C.CL_FP_FMA
	// FpSoftFloat identifies basic floating-point operations (such as addition, subtraction, multiplication)
	// are implemented in software.
	//
	// Since: 1.1
	FpSoftFloat DeviceFpConfigFlags = C.CL_FP_SOFT_FLOAT
	// FpCorrectlyRoundedDivideSqrt identifies divide and sqrt are correctly rounded as defined by the IEEE754
	// specification.
	//
	// Since: 1.2
	FpCorrectlyRoundedDivideSqrt DeviceFpConfigFlags = C.CL_FP_CORRECTLY_ROUNDED_DIVIDE_SQRT
)

const (
	// DeviceAddressBitsInfo specify the default compute device address space size of the global address space specified
	// as an unsigned integer value in bits. Currently supported values are 32 or 64 bits.
	//
	// Returned type: uint32
	DeviceAddressBitsInfo DeviceInfoName = C.CL_DEVICE_ADDRESS_BITS
	// DeviceAtomicFenceCapabilitiesInfo describes the various memory orders and scopes that the device supports for
	// atomic fence operations. This is a bit-field that has the same set of possible values as described for
	// DeviceAtomicMemoryCapabilitiesInfo.
	//
	// Because atomic scopes are hierarchical, a device that supports a wide scope must also support all narrower
	// scopes, except for the work-item scope, which is a special case.
	//
	// Returned type: DeviceAtomicCapabilitiesFlags
	// Since: 3.0
	DeviceAtomicFenceCapabilitiesInfo DeviceInfoName = C.CL_DEVICE_ATOMIC_FENCE_CAPABILITIES
	// DeviceAtomicMemoryCapabilitiesInfo describes the various memory orders and scopes that the device supports for
	// atomic memory operations.
	//
	// Because atomic scopes are hierarchical, a device that supports a wide scope must also support all narrower
	// scopes, except for the work-item scope, which is a special case.
	//
	// Returned type: DeviceAtomicCapabilitiesFlags
	// Since: 3.0
	DeviceAtomicMemoryCapabilitiesInfo DeviceInfoName = C.CL_DEVICE_ATOMIC_MEMORY_CAPABILITIES
	// DeviceAvailableInfo is true if the device is available and false otherwise. A device is considered to be
	// available if the device can be expected to successfully execute commands enqueued to the device.
	//
	// Returned type: Bool
	DeviceAvailableInfo DeviceInfoName = C.CL_DEVICE_AVAILABLE
	// DeviceBuiltInKernelsInfo represents a semicolon separated list of built-in kernels supported by the device.
	// An empty string is returned if no built-in kernels are supported by the device.
	//
	// Returned type: string
	// Since: 1.2
	DeviceBuiltInKernelsInfo DeviceInfoName = C.CL_DEVICE_BUILT_IN_KERNELS
	// DeviceCompilerAvailableInfo is False if the implementation does not have a compiler available to compile the
	// program source. It is True if the compiler is available.
	//
	// This can be False for the embedded platform profile only.
	//
	// Returned type: Bool
	DeviceCompilerAvailableInfo DeviceInfoName = C.CL_DEVICE_COMPILER_AVAILABLE
	// DeviceDeviceEnqueueCapabilitiesInfo describes device-side enqueue capabilities of the device.
	// This is a bit-field.
	//
	// If DeviceQueueReplaceableDefault is set, DeviceQueueSupported must also be set.
	//
	// Devices that set DeviceQueueSupported for DeviceDeviceEnqueueCapabilitiesInfo must also return True for
	// DeviceGenericAddressSpaceSupportInfo.
	//
	// Returned type: DeviceDeviceEnqueueCapabilitiesFlags
	// Since: 3.0
	DeviceDeviceEnqueueCapabilitiesInfo DeviceInfoName = C.CL_DEVICE_DEVICE_ENQUEUE_CAPABILITIES
	// DeviceDoubleFpConfigInfo describes double precision floating-point capability of the OpenCL device.
	// This is a bit-field.
	//
	// Returned type: DeviceFpConfigFlags
	// Since: 1.2
	DeviceDoubleFpConfigInfo DeviceInfoName = C.CL_DEVICE_DOUBLE_FP_CONFIG
	// DeviceEndianLittleInfo is True if the OpenCL device is a little endian device and False otherwise.
	//
	// Returned type: Bool
	DeviceEndianLittleInfo DeviceInfoName = C.CL_DEVICE_ENDIAN_LITTLE
	// DeviceErrorCorrectionSupportInfo is True if the device implements error correction for all accesses to compute
	// device memory (global and constant). Is False if the device does not implement such error correction.
	//
	// Returned type: Bool
	DeviceErrorCorrectionSupportInfo DeviceInfoName = C.CL_DEVICE_ERROR_CORRECTION_SUPPORT
	// DeviceExecutionCapabilitiesInfo describes the execution capabilities of the device. This is a bit-field.
	//
	// The mandated minimum capability is ExecKernel.
	//
	// Returned type: DeviceExecCapabilitiesFlags
	DeviceExecutionCapabilitiesInfo DeviceInfoName = C.CL_DEVICE_EXECUTION_CAPABILITIES
	// DeviceExtensionsInfo returns a space separated list of extension names (the extension names themselves do not
	// contain any spaces) supported by the device. The list of extension names may include Khronos approved
	// extension names and vendor specified extension names.
	//
	// Returned type: string
	DeviceExtensionsInfo DeviceInfoName = C.CL_DEVICE_EXTENSIONS
	// DeviceExtensionsWithVersionInfo returns an array of description (name and version) structures. The same
	// extension name must not be reported more than once. The list of extensions reported must match the list
	// reported via DeviceExtensionsInfo.
	//
	// Returned type: []NameVersion
	// Since: 3.0
	DeviceExtensionsWithVersionInfo DeviceInfoName = C.CL_DEVICE_EXTENSIONS_WITH_VERSION
	// DeviceGenericAddressSpaceSupportInfo is True if the device supports the generic address space and its
	// associated built-in functions, and False otherwise.
	//
	// Returned type: Bool
	// Since: 3.0
	DeviceGenericAddressSpaceSupportInfo DeviceInfoName = C.CL_DEVICE_GENERIC_ADDRESS_SPACE_SUPPORT
	// DeviceGlobalMemCacheSizeInfo returns the size of global memory cache in bytes.
	//
	// Returned type: uint64
	DeviceGlobalMemCacheSizeInfo DeviceInfoName = C.CL_DEVICE_GLOBAL_MEM_CACHE_SIZE
	// DeviceHostUnifiedMemoryInfo is True if the device and the host have a unified memory subsystem and is
	// False otherwise.
	//
	// Returned type: Bool
	// Deprecated: 1.2
	DeviceHostUnifiedMemoryInfo DeviceInfoName = C.CL_DEVICE_HOST_UNIFIED_MEMORY
	// DeviceGlobalMemCacheTypeInfo represents the type of global memory cache supported.
	//
	// Returned type: DeviceMemCacheTypeEnum
	DeviceGlobalMemCacheTypeInfo DeviceInfoName = C.CL_DEVICE_GLOBAL_MEM_CACHE_TYPE
	// DeviceGlobalMemCachelineSizeInfo is the size of global memory cache line in bytes.
	//
	// Returned type: uint32
	DeviceGlobalMemCachelineSizeInfo DeviceInfoName = C.CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE
	// DeviceGlobalMemSizeInfo is the size of global device memory in bytes.
	//
	// Returned type: uint64
	DeviceGlobalMemSizeInfo DeviceInfoName = C.CL_DEVICE_GLOBAL_MEM_SIZE
	// DeviceGlobalVariablePreferredTotalSizeInfo is the maximum preferred total size, in bytes, of all program
	// variables in the global address space. This is a performance hint. An implementation may place such variables in
	// storage with optimized device access. This query returns the capacity of such storage. The minimum value is 0.
	//
	// Returned type: uintptr
	// Since: 2.0
	DeviceGlobalVariablePreferredTotalSizeInfo DeviceInfoName = C.CL_DEVICE_GLOBAL_VARIABLE_PREFERRED_TOTAL_SIZE
	// DeviceIlVersionInfo represents the intermediate languages that can be supported by CreateProgramWithIl for this
	// device. Returns a space-separated list of IL version strings of the form
	// <IL_Prefix>_<Major_Version>.<Minor_Version>.
	//
	// For an OpenCL 2.1 or 2.2 device, SPIR-V is a required IL prefix.
	//
	// If the device does not support intermediate language programs, the value must be "" (an empty string).
	//
	// Returned type: string
	// Since: 2.1
	// Extension: cl_khr_il_program
	DeviceIlVersionInfo DeviceInfoName = C.CL_DEVICE_IL_VERSION
	// DeviceIlsWithVersionInfo returns an array of descriptions (name and version) for all supported intermediate
	// languages. Intermediate languages with the same name may be reported more than once but each name and
	// major/minor version combination may only be reported once. The list of intermediate languages reported must
	// match the list reported via DeviceIlVersionInfo.
	//
	// For an OpenCL 2.1 or 2.2 device, at least one version of SPIR-V must be reported.
	//
	// Returned type: []NameVersion
	// Since: 3.0
	// Extension: cl_khr_il_program
	DeviceIlsWithVersionInfo DeviceInfoName = C.CL_DEVICE_ILS_WITH_VERSION
	// DeviceImage2dMaxHeightInfo is the maximum height of 2D image in pixels.
	// The minimum value is 16384 if DeviceImageSupportInfo is True, the value is 0 otherwise.
	//
	// Returned type: uintptr
	DeviceImage2dMaxHeightInfo DeviceInfoName = C.CL_DEVICE_IMAGE2D_MAX_HEIGHT
	// DeviceImage2dMaxWidthInfo is the maximum width of 2D image or 1D image not created from a buffer object in pixels.
	// The minimum value is 16384 if DeviceImageSupportInfo is True, the value is 0 otherwise.
	//
	// Returned type: uintptr
	DeviceImage2dMaxWidthInfo DeviceInfoName = C.CL_DEVICE_IMAGE2D_MAX_WIDTH
	// DeviceImage3dMaxDepthInfo is the maximum depth of 3D image in pixels.
	// The minimum value is 2048 if DeviceImageSupportInfo is True, the value is 0 otherwise.
	//
	// Returned type: uintptr
	DeviceImage3dMaxDepthInfo DeviceInfoName = C.CL_DEVICE_IMAGE3D_MAX_DEPTH
	// DeviceImage3dMaxHeightInfo is the maximum height of 3D image in pixels.
	// The minimum value is 2048 if DeviceImageSupportInfo is True, the value is 0 otherwise.
	//
	// Returned type: uintptr
	DeviceImage3dMaxHeightInfo DeviceInfoName = C.CL_DEVICE_IMAGE3D_MAX_HEIGHT
	// DeviceImage3dMaxWidthInfo is the maximum width of 3D image in pixels.
	// The minimum value is 2048 if DeviceImageSupportInfo is True, the value is 0 otherwise.
	//
	// Returned type: uintptr
	DeviceImage3dMaxWidthInfo DeviceInfoName = C.CL_DEVICE_IMAGE3D_MAX_WIDTH
	// DeviceImageBaseAddressAlignmentInfo specifies the minimum alignment in pixels of the host_ptr specified to
	// CreateBuffer() or CreateBufferWithProperties() when a 2D image is created from a buffer which was created
	// using MemUseHostPtr. The value returned must be a power of 2.
	//
	// This value must be 0 for devices that do not support 2D images created from a buffer.
	//
	// Returned type: uint32
	// Since: 2.0
	DeviceImageBaseAddressAlignmentInfo DeviceInfoName = C.CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT
	// DeviceImageMaxArraySizeInfo is the maximum number of images in a 1D or 2D image array.
	// The minimum value is 2048 if DeviceImageSupportInfo is True, the value is 0 otherwise.
	//
	// Returned type: uintptr
	// Since: 1.2
	DeviceImageMaxArraySizeInfo DeviceInfoName = C.CL_DEVICE_IMAGE_MAX_ARRAY_SIZE
	// DeviceImageMaxBufferSizeInfo is the maximum number of pixels for a 1D image created from a buffer object.
	// The minimum value is 65536 if DeviceImageSupportInfo is True, the value is 0 otherwise.
	//
	// Returned type: uintptr
	// Since: 1.2
	DeviceImageMaxBufferSizeInfo DeviceInfoName = C.CL_DEVICE_IMAGE_MAX_BUFFER_SIZE
	// DeviceImagePitchAlignmentInfo is the row pitch alignment size in pixels for 2D images created from a buffer.
	// The value returned must be a power of 2.
	// This value must be 0 for devices that do not support 2D images created from a buffer.
	//
	// Returned type: uint32
	// Since: 2.0
	DeviceImagePitchAlignmentInfo DeviceInfoName = C.CL_DEVICE_IMAGE_PITCH_ALIGNMENT
	// DeviceImageSupportInfo is True if images are supported by the OpenCL device and False otherwise.
	//
	// Returned type: Bool
	DeviceImageSupportInfo DeviceInfoName = C.CL_DEVICE_IMAGE_SUPPORT
	// DeviceLatestConformanceVersionPassedInfo returns the latest version of the conformance test suite that this
	// device has fully passed in accordance with the official conformance process.
	//
	// Returned type: string
	// Since: 3.0
	DeviceLatestConformanceVersionPassedInfo DeviceInfoName = C.CL_DEVICE_LATEST_CONFORMANCE_VERSION_PASSED
	// DeviceLinkerAvailableInfo is False if the implementation does not have a linker available.
	// It is True if the linker is available.
	//
	// This can be False for the embedded platform profile only.
	// This must be True if DeviceCompilerAvailableInfo is True.
	//
	// Returned type: Bool
	// Since: 1.2
	DeviceLinkerAvailableInfo DeviceInfoName = C.CL_DEVICE_LINKER_AVAILABLE
	// DeviceLocalMemSizeInfo is the size of local memory region in bytes. The minimum value is 32 KB for devices
	// that are not of type DeviceTypeCustom.
	//
	// Returned type: uint64
	DeviceLocalMemSizeInfo DeviceInfoName = C.CL_DEVICE_LOCAL_MEM_SIZE
	// DeviceLocalMemTypeInfo is the type of local memory supported.
	// This can be set to DeviceLocalMemTypeLocal implying dedicated local memory storage such as SRAM, or
	// DeviceLocalMemTypeGlobal.
	//
	// For custom devices, DeviceLocalMemTypeNone can also be returned indicating no local memory support.
	//
	// Returned type: DeviceLocalMemTypeEnum
	DeviceLocalMemTypeInfo DeviceInfoName = C.CL_DEVICE_LOCAL_MEM_TYPE
	// DeviceMaxClockFrequencyInfo is the clock frequency of the device in MHz. The meaning of this value is
	// implementation-defined. For devices with multiple clock domains, the clock frequency for any of the clock
	// domains may be returned. For devices that dynamically change frequency for power or thermal reasons, the
	// returned clock frequency may be any valid frequency.
	//
	// Note: This definition is missing before version 2.2.
	//
	// Returned type: uint32
	// Deprecated: by 2.2
	DeviceMaxClockFrequencyInfo DeviceInfoName = C.CL_DEVICE_MAX_CLOCK_FREQUENCY
	// DeviceMaxComputeUnitsInfo refers to the number of parallel compute units on the OpenCL device.
	// A work-group executes on a single compute unit. The minimum value is 1.
	//
	// Returned type: uint32
	DeviceMaxComputeUnitsInfo DeviceInfoName = C.CL_DEVICE_MAX_COMPUTE_UNITS
	// DeviceMaxConstantArgsInfo is the maximum number of arguments declared with the __constant qualifier in a kernel.
	// The minimum value is 8 for devices that are not of type DeviceTypeCustom.
	//
	// Returned type: uint32
	DeviceMaxConstantArgsInfo DeviceInfoName = C.CL_DEVICE_MAX_CONSTANT_ARGS
	// DeviceMaxConstantBufferSizeInfo is the maximum size in bytes of a constant buffer allocation. The minimum value
	// is 64 KB for devices that are not of type DeviceTypeCustom.
	//
	// Returned type: uint64
	DeviceMaxConstantBufferSizeInfo DeviceInfoName = C.CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE
	// DeviceMaxGlobalVariableSizeInfo is the maximum number of bytes of storage that may be allocated for any single
	// variable in program scope or inside a function in an OpenCL kernel language declared in the global address space.
	//
	// The minimum value is 64 KB if the device supports program scope global variables, and must be 0 for devices
	// that do not support program scope global variables.
	//
	// Returned type: uintptr
	// Since: 2.0
	DeviceMaxGlobalVariableSizeInfo DeviceInfoName = C.CL_DEVICE_MAX_GLOBAL_VARIABLE_SIZE
	// DeviceMaxMemAllocSizeInfo is the maximum size of memory object allocation in bytes. The minimum value is
	// max(min(1024 * 1024 * 1024, 1/4th of DeviceGlobalMemSizeInfo), 32 * 1024 * 1024)
	// for devices that are not of type DeviceTypeCustom.
	//
	// Returned type: uint64
	DeviceMaxMemAllocSizeInfo DeviceInfoName = C.CL_DEVICE_MAX_MEM_ALLOC_SIZE
	// DeviceMaxNumSubGroupsInfo is the maximum number of subgroups in a work-group that a device is capable of executing
	// on a single compute unit, for any given kernel-instance running on the device.
	//
	// The minimum value is 1 if the device supports subgroups, and must be 0 for devices that do not support subgroups.
	//
	// Returned type: uint32
	// Since: 2.1
	DeviceMaxNumSubGroupsInfo DeviceInfoName = C.CL_DEVICE_MAX_NUM_SUB_GROUPS
	// DeviceMaxOnDeviceEventsInfo is the maximum number of events in use by a device queue. These refer to events
	// returned by the enqueue_ built-in functions to a device queue or user events returned by the create_user_event
	// built-in function that have not been released.
	//
	// The minimum value is 1024 for devices supporting on-device queues, and must be 0 for devices that do not
	// support on-device queues.
	//
	// Returned type: uint32
	// Since: 2.0
	DeviceMaxOnDeviceEventsInfo DeviceInfoName = C.CL_DEVICE_MAX_ON_DEVICE_EVENTS
	// DeviceMaxOnDeviceQueuesInfo is the maximum number of device queues that can be created for this device in a
	// single context.
	//
	// The minimum value is 1 for devices supporting on-device queues, and must be 0 for devices that do not
	// support on-device queues.
	//
	// Returned type: uint32
	// Since: 2.0
	DeviceMaxOnDeviceQueuesInfo DeviceInfoName = C.CL_DEVICE_MAX_ON_DEVICE_QUEUES
	// DeviceMaxParameterSizeInfo is the maximum size in bytes of all arguments that can be passed to a kernel.
	//
	// The minimum value is 1024 for devices that are not of type DeviceTypeCustom. For this minimum value,
	// only a maximum of 128 arguments can be passed to a kernel
	//
	// Returned type: uintptr
	DeviceMaxParameterSizeInfo DeviceInfoName = C.CL_DEVICE_MAX_PARAMETER_SIZE
	// DeviceMaxPipeArgsInfo is the maximum number of pipe objects that can be passed as arguments to a kernel.
	// The minimum value is 16 for devices supporting pipes, and must be 0 for devices that do not support pipes.
	//
	// Returned type: uint32
	// Since: 2.0
	DeviceMaxPipeArgsInfo DeviceInfoName = C.CL_DEVICE_MAX_PIPE_ARGS
	// DeviceMaxReadImageArgsInfo is the maximum number of image objects arguments of a kernel declared with the read_only
	// qualifier. The minimum value is 128 if DeviceImageSupportInfo is True, the value is 0 otherwise.
	//
	// Returned type: uint32
	DeviceMaxReadImageArgsInfo DeviceInfoName = C.CL_DEVICE_MAX_READ_IMAGE_ARGS
	// DeviceMaxReadWriteImageArgsInfo is the maximum number of image objects arguments of a kernel declared with the
	// write_only or read_write qualifier.
	//
	// The minimum value is 64 if the device supports read-write images arguments, and must be 0 for devices that
	// do not support read-write images.
	//
	// Returned type: uint32
	// Since: 2.0
	DeviceMaxReadWriteImageArgsInfo DeviceInfoName = C.CL_DEVICE_MAX_READ_WRITE_IMAGE_ARGS
	// DeviceMaxSamplersInfo is the maximum number of samplers that can be used in a kernel.
	// The minimum value is 16 if DeviceImageSupportInfo is True, the value is 0 otherwise.
	//
	// Returned type: uint32
	DeviceMaxSamplersInfo DeviceInfoName = C.CL_DEVICE_MAX_SAMPLERS
	// DeviceMaxWorkGroupSizeInfo is the maximum number of work-items in a work-group that a device is capable of
	// executing on a single compute unit, for any given kernel-instance running on the device.
	// The minimum value is 1. The returned value is an upper limit and will not necessarily maximize performance.
	// This maximum may be larger than supported by a specific kernel.
	//
	// Returned type: uintptr
	DeviceMaxWorkGroupSizeInfo DeviceInfoName = C.CL_DEVICE_MAX_WORK_GROUP_SIZE
	// DeviceMaxWorkItemDimensionsInfo is the maximum dimensions that specify the global and local work-item IDs used by
	// the data parallel execution model. The minimum value is 3 for devices that are not of type DeviceTypeCustom.
	//
	// Return type: uint32
	DeviceMaxWorkItemDimensionsInfo DeviceInfoName = C.CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS
	// DeviceMaxWorkItemSizesInfo is the maximum number of work-items that can be specified in each dimension of the
	// work-group to EnqueueNDRangeKernel().
	// Returns N uintptr entries, where N is the value returned by the query for DeviceMaxWorkItemDimensionsInfo.
	// The minimum value is (1, 1, 1) for devices that are not of type DeviceTypeCustom.
	//
	// Returned type: []uintptr
	DeviceMaxWorkItemSizesInfo DeviceInfoName = C.CL_DEVICE_MAX_WORK_ITEM_SIZES
	// DeviceMaxWriteImageArgsInfo is the maximum number of image objects arguments of a kernel declared with the
	// write_only qualifier. The minimum value is 64 if DeviceImageSupportInfo is True, the value is 0 otherwise.
	//
	// Returned type: uint32
	DeviceMaxWriteImageArgsInfo DeviceInfoName = C.CL_DEVICE_MAX_WRITE_IMAGE_ARGS
	// DeviceMemBaseAddrAlignInfo is the alignment requirement (in bits) for sub-buffer offsets. The minimum value is
	// the size (in bits) of the largest OpenCL built-in data type supported by the device
	// (long16 in FULL profile, long16 or int16 in EMBEDDED profile) for devices that are not of type DeviceTypeCustom.
	//
	// Returned type: uint32
	DeviceMemBaseAddrAlignInfo DeviceInfoName = C.CL_DEVICE_MEM_BASE_ADDR_ALIGN
	// DeviceNameInfo refers to a human-readable string that identifies the device.
	//
	// Returned type: string
	DeviceNameInfo DeviceInfoName = C.CL_DEVICE_NAME
	// DeviceNativeVectorWidthCharInfo returns the native ISA vector width.
	// The vector width is defined as the number of scalar elements that can be stored in the vector.
	//
	// Returned type: uint32
	// Since: 1.1
	DeviceNativeVectorWidthCharInfo DeviceInfoName = C.CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR
	// DeviceNativeVectorWidthDoubleInfo returns the native ISA vector width.
	// The vector width is defined as the number of scalar elements that can be stored in the vector.
	//
	// If double precision is not supported, this value must be 0.
	//
	// Returned type: uint32
	// Since: 1.1
	DeviceNativeVectorWidthDoubleInfo DeviceInfoName = C.CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE
	// DeviceNativeVectorWidthFloatInfo returns the native ISA vector width.
	// The vector width is defined as the number of scalar elements that can be stored in the vector.
	//
	// Returned type: uint32
	// Since: 1.1
	DeviceNativeVectorWidthFloatInfo DeviceInfoName = C.CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT
	// DeviceNativeVectorWidthHalfInfo returns the native ISA vector width.
	// The vector width is defined as the number of scalar elements that can be stored in the vector.
	//
	// If the cl_khr_fp16 extension is not supported, this value must be 0.
	//
	// Returned type: uint32
	// Since: 1.1
	// Extension: cl_khr_fp16
	DeviceNativeVectorWidthHalfInfo DeviceInfoName = C.CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF
	// DeviceNativeVectorWidthIntInfo returns the native ISA vector width.
	// The vector width is defined as the number of scalar elements that can be stored in the vector.
	//
	// Returned type: uint32
	// Since: 1.1
	DeviceNativeVectorWidthIntInfo DeviceInfoName = C.CL_DEVICE_NATIVE_VECTOR_WIDTH_INT
	// DeviceNativeVectorWidthLongInfo returns the native ISA vector width.
	// The vector width is defined as the number of scalar elements that can be stored in the vector.
	//
	// Returned type: uint32
	// Since: 1.1
	DeviceNativeVectorWidthLongInfo DeviceInfoName = C.CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG
	// DeviceNativeVectorWidthShortInfo returns the native ISA vector width.
	// The vector width is defined as the number of scalar elements that can be stored in the vector.
	//
	// Returned type: uint32
	// Since: 1.1
	DeviceNativeVectorWidthShortInfo DeviceInfoName = C.CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT
	// DeviceNonUniformWorkGroupSupportInfo is True if the device supports non-uniform work-groups, and False otherwise.
	//
	// Returned type: Bool
	// Since: 3.0
	DeviceNonUniformWorkGroupSupportInfo DeviceInfoName = C.CL_DEVICE_NON_UNIFORM_WORK_GROUP_SUPPORT
	// DeviceOpenClCAllVersionsInfo returns an array of name, version descriptions listing all the versions of OpenCL C
	// supported by the compiler for the device. In each returned description structure, the name field is required
	// to be "OpenCL C". The list may include both newer non-backwards compatible OpenCL C versions, such as
	// OpenCL C 3.0, and older OpenCL C versions with mandatory backwards compatibility.
	// The version returned by DeviceOpenClCVersionInfo is required to be present in the list.
	//
	// For devices that support compilation from OpenCL C source:
	//
	// Because OpenCL 3.0 is backwards compatible with OpenCL C 1.2, and OpenCL C 1.2 is backwards compatible
	// with OpenCL C 1.1 and OpenCL C 1.0, support for at least OpenCL C 3.0, OpenCL C 1.2, OpenCL C 1.1, and
	// OpenCL C 1.0 is required for an OpenCL 3.0 device.
	//
	// Support for OpenCL C 2.0, OpenCL C 1.2, OpenCL C 1.1, and OpenCL C 1.0 is required for
	// an OpenCL 2.0, OpenCL 2.1, or OpenCL 2.2 device.
	//
	// Support for OpenCL C 1.2, OpenCL C 1.1, and OpenCL C 1.0 is required for an OpenCL 1.2 device.
	//
	// Support for OpenCL C 1.1 and OpenCL C 1.0 is required for an OpenCL 1.1 device.
	//
	// Support for at least OpenCL C 1.0 is required for an OpenCL 1.0 device.
	//
	// For devices that do not support compilation from OpenCL C source, this query may return an empty array.
	//
	// Returned type: []NameVersion
	// Since: 3.0
	DeviceOpenClCAllVersionsInfo DeviceInfoName = C.CL_DEVICE_OPENCL_C_ALL_VERSIONS
	// DeviceOpenClCFeaturesInfo returns an array of optional OpenCL C features supported by the compiler for
	// the device alongside the OpenCL C version that introduced the feature macro. For example, if a compiler
	// supports an OpenCL C 3.0 feature, the returned name will be the full name of the OpenCL C feature macro,
	// and the returned version will be 3.0.0.
	//
	// For devices that do not support compilation from OpenCL C source, this query may return an empty array.
	//
	// Returned type: []NameVersion
	// Since: 3.0
	DeviceOpenClCFeaturesInfo DeviceInfoName = C.CL_DEVICE_OPENCL_C_FEATURES
	// DeviceOpenClCVersionInfo returns the highest fully backwards compatible OpenCL C version supported by the
	// compiler for the device. For devices supporting compilation from OpenCL C source, this will return
	// a version string with the following format:
	//
	// OpenCL<space>C<space><major_version.minor_version><space><vendor-specific information>
	//
	// Returned type: string
	// Since: 1.1
	// Deprecated: 3.0; This query has been superseded by the DeviceOpenClCAllVersionsInfo query,
	// which returns a set of OpenCL C versions supported by a device.
	DeviceOpenClCVersionInfo DeviceInfoName = C.CL_DEVICE_OPENCL_C_VERSION
	// DeviceParentDeviceInfo returns the DeviceID of the parent device to which this sub-device belongs.
	// If device is a root-level device, a zero value is returned.
	//
	// Returned type: DeviceID
	// Since: 1.2
	DeviceParentDeviceInfo DeviceInfoName = C.CL_DEVICE_PARENT_DEVICE
	// DevicePartitionAffinityDomainInfo returns the list of supported affinity domains for partitioning the device
	// using DevicePartitionByAffinityDomainProperty. This is a bit-field.
	// If the device does not support any affinity domains, a value of 0 will be returned.
	//
	// Returned type: DeviceAffinityDomainFlags
	// Since: 1.2
	DevicePartitionAffinityDomainInfo DeviceInfoName = C.CL_DEVICE_PARTITION_AFFINITY_DOMAIN
	// DevicePartitionMaxSubDevicesInfo returns the maximum number of sub-devices that can be created when
	// a device is partitioned.
	// The value returned cannot exceed DeviceMaxComputeUnitsInfo.
	//
	// Returned type: uint32
	// Since: 1.2
	DevicePartitionMaxSubDevicesInfo DeviceInfoName = C.CL_DEVICE_PARTITION_MAX_SUB_DEVICES
	// DevicePartitionPropertiesInfo returns the list of partition types supported by device.
	// This is an array of uintptr values drawn from the list of DevicePartitionEquallyProperty, DevicePartitionByCountsProperty,
	// and DevicePartitionByAffinityDomainProperty.
	// If the device cannot be partitioned (i.e. there is no partitioning scheme supported by the device that will
	// return at least two subdevices), a value of 0 will be returned.
	//
	// Returned type: []uintptr
	// Since: 1.2
	DevicePartitionPropertiesInfo DeviceInfoName = C.CL_DEVICE_PARTITION_PROPERTIES
	// DevicePartitionTypeInfo returns the properties argument specified in CreateSubDevices() if device is a sub-device.
	// In the case where the properties argument to CreateSubDevices() is DevicePartitionByAffinityDomainProperty,
	// DeviceAffinityDomainNextPartitionable, the affinity domain used to perform the partition will be returned.
	// This can be one of the following values:
	//
	// DeviceAffinityDomainNuma
	// DeviceAffinityDomainL4Cache
	// DeviceAffinityDomainL3Cache
	// DeviceAffinityDomainL2Cache
	// DeviceAffinityDomainL1Cache
	//
	// Otherwise the implementation may either return a parameter size of 0 i.e. there is no partition type
	// associated with device or can return a property value of 0 (where 0 is used to terminate the
	// partition property list) in the memory that the result value points to.
	//
	// Returned type: []uintptr
	// Since: 1.2
	DevicePartitionTypeInfo DeviceInfoName = C.CL_DEVICE_PARTITION_TYPE
	// DevicePipeMaxActiveReservationsInfo is the maximum number of reservations that can be active for a pipe per
	// work-item in a kernel. A work-group reservation is counted as one reservation per work-item.
	// The minimum value is 1 for devices supporting pipes, and must be 0 for devices that do not support pipes.
	//
	// Returned type: uint32
	// Since: 2.0
	DevicePipeMaxActiveReservationsInfo DeviceInfoName = C.CL_DEVICE_PIPE_MAX_ACTIVE_RESERVATIONS
	// DevicePipeMaxPacketSizeInfo is the maximum size of pipe packet in bytes.
	// The minimum value is 1024 bytes if the device supports pipes, and must be 0 for devices that do not
	// support pipes.
	//
	// Returned type: uint32
	// Since: 2.0
	DevicePipeMaxPacketSizeInfo DeviceInfoName = C.CL_DEVICE_PIPE_MAX_PACKET_SIZE
	// DevicePipeSupportInfo is True if the device supports pipes, and False otherwise.
	// Devices that return True for DevicePipeSupportInfo must also return True for DeviceGenericAddressSpaceSupportInfo.
	//
	// Returned type: Bool
	// Since: 3.0
	DevicePipeSupportInfo DeviceInfoName = C.CL_DEVICE_PIPE_SUPPORT
	// DevicePlatformInfo returns the platform associated with this device.
	//
	// Returned type: PlatformID
	DevicePlatformInfo DeviceInfoName = C.CL_DEVICE_PLATFORM
	// DevicePreferredGlobalAtomicAlignmentInfo returns the value representing the preferred alignment in bytes for
	// OpenCL 2.0 atomic types to global memory. This query can return 0 which indicates that the preferred
	// alignment is aligned to the natural size of the type.
	//
	// Returned type: uint32
	// Since: 2.0
	DevicePreferredGlobalAtomicAlignmentInfo DeviceInfoName = C.CL_DEVICE_PREFERRED_GLOBAL_ATOMIC_ALIGNMENT
	// DevicePreferredInteropUserSyncInfo is True if the devices preference is for the user to be responsible for
	// synchronization, when sharing memory objects between OpenCL and other APIs such as DirectX,
	// False if the device / implementation has a performant path for performing synchronization of memory object
	// shared between OpenCL and other APIs such as DirectX.
	//
	// Returned type: Bool
	// Since: 1.2
	DevicePreferredInteropUserSyncInfo DeviceInfoName = C.CL_DEVICE_PREFERRED_INTEROP_USER_SYNC
	// DevicePreferredLocalAtomicAlignmentInfo returns the value representing the preferred alignment in bytes for
	// OpenCL 2.0 atomic types to local memory. This query can return 0 which indicates that the preferred
	// alignment is aligned to the natural size of the type.
	//
	// Returned type: uint32
	// Since: 2.0
	DevicePreferredLocalAtomicAlignmentInfo DeviceInfoName = C.CL_DEVICE_PREFERRED_LOCAL_ATOMIC_ALIGNMENT
	// DevicePreferredPlatformAtomicAlignmentInfo returns the value representing the preferred alignment in bytes for
	// OpenCL 2.0 fine-grained SVM atomic types. This query can return 0 which indicates that the preferred
	// alignment is aligned to the natural size of the type.
	//
	// Returned type: uint32
	// Since: 2.0
	DevicePreferredPlatformAtomicAlignmentInfo DeviceInfoName = C.CL_DEVICE_PREFERRED_PLATFORM_ATOMIC_ALIGNMENT
	// DevicePreferredVectorWidthCharInfo is the preferred native vector width size for built-in scalar types that
	// can be put into vectors. The vector width is defined as the number of scalar elements that can be stored
	// in the vector.
	//
	// Returned type: uint32
	DevicePreferredVectorWidthCharInfo DeviceInfoName = C.CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR
	// DevicePreferredVectorWidthDoubleInfo is the preferred native vector width size for built-in scalar types that
	// can be put into vectors. The vector width is defined as the number of scalar elements that can be stored
	// in the vector.
	// If double precision is not supported, this value must be 0.
	//
	// Returned type: uint32
	DevicePreferredVectorWidthDoubleInfo DeviceInfoName = C.CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE
	// DevicePreferredVectorWidthFloatInfo is the preferred native vector width size for built-in scalar types that
	// can be put into vectors. The vector width is defined as the number of scalar elements that can be stored
	// in the vector.
	//
	// Returned type: uint32
	DevicePreferredVectorWidthFloatInfo DeviceInfoName = C.CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT
	// DevicePreferredVectorWidthHalfInfo is the preferred native vector width size for built-in scalar types that
	// can be put into vectors. The vector width is defined as the number of scalar elements that can be stored
	// in the vector.
	// If the cl_khr_fp16 extension is not supported, this value must be 0.
	//
	// Returned type: uint32
	// Since: 1.1
	// Extension: cl_khr_fp16
	DevicePreferredVectorWidthHalfInfo DeviceInfoName = C.CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF
	// DevicePreferredVectorWidthIntInfo is the preferred native vector width size for built-in scalar types that
	// can be put into vectors. The vector width is defined as the number of scalar elements that can be stored
	// in the vector.
	//
	// Returned type: uint32
	DevicePreferredVectorWidthIntInfo DeviceInfoName = C.CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT
	// DevicePreferredVectorWidthLongInfo is the preferred native vector width size for built-in scalar types that
	// can be put into vectors. The vector width is defined as the number of scalar elements that can be stored
	// in the vector.
	//
	// Returned type: uint32
	DevicePreferredVectorWidthLongInfo DeviceInfoName = C.CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG
	// DevicePreferredVectorWidthShortInfo is the preferred native vector width size for built-in scalar types that
	// can be put into vectors. The vector width is defined as the number of scalar elements that can be stored
	// in the vector.
	//
	// Returned type: uint32
	DevicePreferredVectorWidthShortInfo DeviceInfoName = C.CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT
	// DevicePrintfBufferSizeInfo is the maximum size in bytes of the internal buffer that holds the output of printf
	// calls from a kernel. The minimum value for the FULL profile is 1 MB.
	//
	// Returned type: uintptr
	// Since: 1.2
	DevicePrintfBufferSizeInfo DeviceInfoName = C.CL_DEVICE_PRINTF_BUFFER_SIZE
	// DeviceProfileInfo is the OpenCL profile string. Returns the profile name supported by the device.
	// The profile name returned can be one of the following strings:
	//
	// "FULL_PROFILE" - if the device supports the OpenCL specification (functionality defined as part of the core
	// specification and does not require any extensions to be supported).
	//
	// "EMBEDDED_PROFILE" - if the device supports the OpenCL embedded profile.
	//
	// Returned type: string
	DeviceProfileInfo DeviceInfoName = C.CL_DEVICE_PROFILE
	// DeviceProfilingTimerResolutionInfo describes the resolution of device timer. This is measured in nanoseconds.
	//
	// Returned type: uintptr
	DeviceProfilingTimerResolutionInfo DeviceInfoName = C.CL_DEVICE_PROFILING_TIMER_RESOLUTION
	// DeviceQueueOnDeviceMaxSizeInfo is the maximum size of the device queue in bytes.
	// The minimum value is 256 KB for the full profile and 64 KB for the embedded profile for devices supporting
	// on-device queues, and must be 0 for devices that do not support on-device queues.
	//
	// Returned type: uint32
	// Since: 2.0
	DeviceQueueOnDeviceMaxSizeInfo DeviceInfoName = C.CL_DEVICE_QUEUE_ON_DEVICE_MAX_SIZE
	// DeviceQueueOnDevicePreferredSizeInfo is the preferred size of the device queue, in bytes. Applications should
	// use this size for the device queue to ensure good performance.
	// The minimum value is 16 KB for devices supporting on-device queues, and must be 0 for devices that
	// do not support on-device queues.
	//
	// Returned type: uint32
	// Since: 2.0
	DeviceQueueOnDevicePreferredSizeInfo DeviceInfoName = C.CL_DEVICE_QUEUE_ON_DEVICE_PREFERRED_SIZE
	// DeviceQueueOnDevicePropertiesInfo describes the on device command-queue properties supported by the device.
	// This is a bit-field.
	//
	// Returned type: CommandQueuePropertiesFlags
	// Since: 2.0
	DeviceQueueOnDevicePropertiesInfo DeviceInfoName = C.CL_DEVICE_QUEUE_ON_DEVICE_PROPERTIES
	// DeviceQueueOnHostPropertiesInfo describes the on host command-queue properties supported by the device.
	// This is a bit-field
	//
	// Returned type: CommandQueuePropertiesFlags
	// Since: 2.0
	DeviceQueueOnHostPropertiesInfo DeviceInfoName = C.CL_DEVICE_QUEUE_ON_HOST_PROPERTIES
	// DeviceQueuePropertiesInfo describes the command-queue properties supported by the device. This is a bit-field
	// that describes one or more of the following values: QueueOutOfOrderExecModeEnable, QueueProfilingEnable.
	//
	// Returned type: CommandQueuePropertiesFlags
	// Deprecated: 1.2; Use DeviceQueueOnHostPropertiesInfo instead.
	DeviceQueuePropertiesInfo DeviceInfoName = C.CL_DEVICE_QUEUE_PROPERTIES
	// DeviceReferenceCountInfo returns the device reference count. If the device is a root-level device,
	// a reference count of one is returned.
	//
	// Note: The reference count returned should be considered immediately stale. It is unsuitable for general
	// use in applications. This feature is provided for identifying memory leaks.
	//
	// Returned type: uint32
	// Since: 1.2
	DeviceReferenceCountInfo DeviceInfoName = C.CL_DEVICE_REFERENCE_COUNT
	// DeviceSingleFpConfigInfo describes single precision floating-point capability of the device. This is a bit-field.
	//
	// Returned type: DeviceFpConfigFlags
	DeviceSingleFpConfigInfo DeviceInfoName = C.CL_DEVICE_SINGLE_FP_CONFIG
	// DeviceSubGroupIndependentForwardProgressInfo is True if this device supports independent forward progress of
	// subgroups, False otherwise.
	// This value must be True for devices that support the cl_khr_subgroups extension, and must return False for
	// devices that do not support subgroups.
	//
	// Returned type: Bool
	// Since: 2.1
	// Extension: cl_khr_subgroups
	DeviceSubGroupIndependentForwardProgressInfo DeviceInfoName = C.CL_DEVICE_SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS
	// DeviceSvmCapabilitiesInfo describes the various shared virtual memory (SVM) memory allocation types the
	// device supports. This is a bit-field.
	//
	// Returned type: DeviceSvmCapabilitiesFlags
	// Since: 2.0
	DeviceSvmCapabilitiesInfo DeviceInfoName = C.CL_DEVICE_SVM_CAPABILITIES
	// DeviceTypeInfo is the type or types of the OpenCL device.
	//
	// Returned type: DeviceTypeFlags
	DeviceTypeInfo DeviceInfoName = C.CL_DEVICE_TYPE
	// DeviceVendorInfo refers to a human-readable string that identifies the vendor of the device.
	//
	// Returned type: string
	DeviceVendorInfo DeviceInfoName = C.CL_DEVICE_VENDOR
	// DeviceVendorIDInfo is a unique device vendor identifier.
	//
	// Returned type: uint32
	DeviceVendorIDInfo DeviceInfoName = C.CL_DEVICE_VENDOR_ID
	// DeviceVersionInfo is an OpenCL version string. Returns the OpenCL version supported by the device.
	// This version string has the following format:
	//
	// OpenCL<space><major_version.minor_version><space><vendor-specific information>
	//
	// Returned type: string
	DeviceVersionInfo DeviceInfoName = C.CL_DEVICE_VERSION
	// DeviceWorkGroupCollectiveFunctionsSupportInfo is True if the device supports work-group collective functions
	// e.g. work_group_broadcast, work_group_reduce, and work_group_scan, and False otherwise.
	//
	// Returned type: Bool
	// Since: 3.0
	DeviceWorkGroupCollectiveFunctionsSupportInfo DeviceInfoName = C.CL_DEVICE_WORK_GROUP_COLLECTIVE_FUNCTIONS_SUPPORT
	// DriverVersionInfo specifies the OpenCL software driver version string. Follows a vendor-specific format.
	//
	// Returned type: string
	DriverVersionInfo DeviceInfoName = C.CL_DRIVER_VERSION
)

const (
	DeviceLocalMemTypeNone   DeviceLocalMemTypeEnum = C.CL_NONE
	DeviceLocalMemTypeLocal  DeviceLocalMemTypeEnum = C.CL_LOCAL
	DeviceLocalMemTypeGlobal DeviceLocalMemTypeEnum = C.CL_GLOBAL
)

const (
	DeviceMemCacheNone      DeviceMemCacheTypeEnum = C.CL_NONE
	DeviceMemCacheReadOnly  DeviceMemCacheTypeEnum = C.CL_READ_ONLY_CACHE
	DeviceMemCacheReadWrite DeviceMemCacheTypeEnum = C.CL_READ_WRITE_CACHE
)

const (
	// DeviceSvmCoarseGrainBuffer identifies support for coarse-grain buffer sharing using SvmAlloc().
	// Memory consistency is guaranteed at synchronization points and the host must use calls to EnqueueMapBuffer()
	// and EnqueueUnmapMemObject().
	//
	// Since: 2.0
	DeviceSvmCoarseGrainBuffer DeviceSvmCapabilitiesFlags = C.CL_DEVICE_SVM_COARSE_GRAIN_BUFFER
	// DeviceSvmFineGrainBuffer identifies support for fine-grain buffer sharing using SvmAlloc().
	// Memory consistency is guaranteed at synchronization points without need for EnqueueMapBuffer() and
	// EnqueueUnmapMemObject().
	//
	// Since: 2.0
	DeviceSvmFineGrainBuffer DeviceSvmCapabilitiesFlags = C.CL_DEVICE_SVM_FINE_GRAIN_BUFFER
	// DeviceSvmFineGrainSystem identifies support for sharing the host’s entire virtual memory including memory
	// allocated using malloc. Memory consistency is guaranteed at synchronization points.
	//
	// Since: 2.0
	DeviceSvmFineGrainSystem DeviceSvmCapabilitiesFlags = C.CL_DEVICE_SVM_FINE_GRAIN_SYSTEM
	// DeviceSvmAtomics identifies support for the OpenCL 2.0 atomic operations that provide memory consistency
	// across the host and all OpenCL devices supporting fine-grain SVM allocations.
	//
	// Since: 2.0
	DeviceSvmAtomics DeviceSvmCapabilitiesFlags = C.CL_DEVICE_SVM_ATOMICS
)

const (
	// DeviceTerminateCapabilityKhrContext indicates that context termination is supported.
	//
	// Note: The constant is an assumption. Refer to https://github.com/KhronosGroup/OpenCL-Docs/issues/813 for details.
	//
	// Extension: KhrTerminateContextExtensionName
	DeviceTerminateCapabilityKhrContext DeviceTerminateCapabilityKhrFlags = 1 << 0
)

const (
	// DeviceTypeCPU is an OpenCL device similar to a traditional CPU (Central Processing Unit).
	// The host processor that executes OpenCL host code may also be considered a CPU OpenCL device.
	DeviceTypeCPU DeviceTypeFlags = C.CL_DEVICE_TYPE_CPU
	// DeviceTypeDefault is the default OpenCL device in the platform.
	// The default OpenCL device must not be a DeviceTypeCustom device.
	DeviceTypeDefault DeviceTypeFlags = C.CL_DEVICE_TYPE_DEFAULT
	// DeviceTypeGpu is an OpenCL device similar to a GPU (Graphics Processing Unit).
	// Many systems include a dedicated processor for graphics or rendering that may be considered a GPU OpenCL device.
	DeviceTypeGpu DeviceTypeFlags = C.CL_DEVICE_TYPE_GPU
	// DeviceTypeAccelerator are dedicated devices that may accelerate OpenCL programs, such as FPGAs
	// (Field Programmable Gate Arrays), DSPs (Digital Signal Processors), or AI (Artificial Intelligence) processors.
	DeviceTypeAccelerator DeviceTypeFlags = C.CL_DEVICE_TYPE_ACCELERATOR
	// DeviceTypeCustom are specialized devices that implement some OpenCL runtime APIs but do not support
	// all required OpenCL functionality.
	//
	// Since: 1.2
	DeviceTypeCustom DeviceTypeFlags = C.CL_DEVICE_TYPE_CUSTOM
	// DeviceTypeAll identifies all OpenCL devices available in the platform, except for DeviceTypeCustom devices.
	DeviceTypeAll DeviceTypeFlags = C.CL_DEVICE_TYPE_ALL
)

const (
	// EventCommandQueuedStatus means the command has been enqueued in the command-queue.
	EventCommandQueuedStatus EventCommandExecutionStatus = C.CL_QUEUED
	// EventCommandSubmittedStatus means the enqueued command has been submitted by the host to the device associated
	// with the command-queue.
	EventCommandSubmittedStatus EventCommandExecutionStatus = C.CL_SUBMITTED
	// EventCommandRunningStatus means the device is currently executing this command.
	EventCommandRunningStatus EventCommandExecutionStatus = C.CL_RUNNING
	// EventCommandCompleteStatus means that the command has completed.
	EventCommandCompleteStatus EventCommandExecutionStatus = C.CL_COMPLETE
)

const (
	// CommandNdRangeKernel events are created by EnqueueNDRangeKernel().
	CommandNdRangeKernel EventCommandType = C.CL_COMMAND_NDRANGE_KERNEL
	// CommandTask events are created by EnqueueTask().
	CommandTask EventCommandType = C.CL_COMMAND_TASK
	// CommandNativeKernel events are created by EnqueueNativeKernel().
	CommandNativeKernel EventCommandType = C.CL_COMMAND_NATIVE_KERNEL
	// CommandReadBuffer events are created by EnqueueReadBuffer().
	CommandReadBuffer EventCommandType = C.CL_COMMAND_READ_BUFFER
	// CommandWriteBuffer events are created by EnqueueWriteBuffer().
	CommandWriteBuffer EventCommandType = C.CL_COMMAND_WRITE_BUFFER
	// CommandCopyBuffer events are created by EnqueueCopyBuffer().
	CommandCopyBuffer EventCommandType = C.CL_COMMAND_COPY_BUFFER
	// CommandReadImage events are created by EnqueueReadImage().
	CommandReadImage EventCommandType = C.CL_COMMAND_READ_IMAGE
	// CommandWriteImage events are created by EnqueueWriteImage().
	CommandWriteImage EventCommandType = C.CL_COMMAND_WRITE_IMAGE
	// CommandCopyImage events are created by EnqueueCopyImage().
	CommandCopyImage EventCommandType = C.CL_COMMAND_COPY_IMAGE
	// CommandCopyImageToBuffer events are created by EnqueueCopyImageToBuffer().
	CommandCopyImageToBuffer EventCommandType = C.CL_COMMAND_COPY_IMAGE_TO_BUFFER
	// CommandCopyBufferToImage events are created by EnqueueCopyBufferToImage().
	CommandCopyBufferToImage EventCommandType = C.CL_COMMAND_COPY_BUFFER_TO_IMAGE
	// CommandMapBuffer events are created by EnqueueMapBuffer().
	CommandMapBuffer EventCommandType = C.CL_COMMAND_MAP_BUFFER
	// CommandMapImage events are created by EnqueueMapImage().
	CommandMapImage EventCommandType = C.CL_COMMAND_MAP_IMAGE
	// CommandUnmapMemObject events are created by EnqueueUnmapMemObject().
	CommandUnmapMemObject EventCommandType = C.CL_COMMAND_UNMAP_MEM_OBJECT
	// CommandMarker events are created by EnqueueMarker() and EnqueueMarkerWithWaitList().
	CommandMarker EventCommandType = C.CL_COMMAND_MARKER
	// CommandReadBufferRect events are created by EnqueueReadBufferRect().
	//
	// Since: 1.1
	CommandReadBufferRect EventCommandType = C.CL_COMMAND_READ_BUFFER_RECT
	// CommandWriteBufferRect events are created by EnqueueWriteBufferRect().
	//
	// Since: 1.1
	CommandWriteBufferRect EventCommandType = C.CL_COMMAND_WRITE_BUFFER_RECT
	// CommandCopyBufferRect events are created by EnqueueCopyBufferRect().
	//
	// Since: 1.1
	CommandCopyBufferRect EventCommandType = C.CL_COMMAND_COPY_BUFFER_RECT
	// CommandUser events are created by CreateUserEvent().
	//
	// Since: 1.1
	CommandUser EventCommandType = C.CL_COMMAND_USER
	// CommandBarrier events are created by EnqueueBarrier() and EnqueueBarrierWithWaitList().
	//
	// Since: 1.2
	CommandBarrier EventCommandType = C.CL_COMMAND_BARRIER
	// CommandMigrateMemObjects events are created by EnqueueMigrateMemObjects().
	//
	// Since: 1.2
	CommandMigrateMemObjects EventCommandType = C.CL_COMMAND_MIGRATE_MEM_OBJECTS
	// CommandFillBuffer events are created by EnqueueFillBuffer().
	//
	// Since: 1.2
	CommandFillBuffer EventCommandType = C.CL_COMMAND_FILL_BUFFER
	// CommandFillImage events are created by EnqueueFillImage().
	//
	// Since: 1.2
	CommandFillImage EventCommandType = C.CL_COMMAND_FILL_IMAGE

	// CommandSvmFree events are created by EnqueueSvmFree().
	//
	// Since: 2.0
	CommandSvmFree EventCommandType = C.CL_COMMAND_SVM_FREE
	// CommandSvmMemcpy events are created by EnqueueSvmMemcpy().
	//
	// Since: 2.0
	CommandSvmMemcpy EventCommandType = C.CL_COMMAND_SVM_MEMCPY
	// CommandSvmMemFill events are created by EnqueueSvmMemFill().
	//
	// Since: 2.0
	CommandSvmMemFill EventCommandType = C.CL_COMMAND_SVM_MEMFILL
	// CommandSvmMap events are created by EnqueueSvmMap().
	//
	// Since: 2.0
	CommandSvmMap EventCommandType = C.CL_COMMAND_SVM_MAP
	// CommandSvmUnmap events are created by EnqueueSvmUnmap().
	//
	// Since: 2.0
	CommandSvmUnmap EventCommandType = C.CL_COMMAND_SVM_UNMAP

	// CommandSvmMigrateMem events are created by EnqueueSvmMigrateMem().
	//
	// Since: 3.0
	CommandSvmMigrateMem EventCommandType = C.CL_COMMAND_SVM_MIGRATE_MEM
)

const (
	// EventCommandQueueInfo returns the command-queue associated with event. For user event objects,
	// a zero value is returned.
	//
	// Returned type: CommandQueue
	EventCommandQueueInfo EventInfoName = C.CL_EVENT_COMMAND_QUEUE
	// EventContextInfo returns the context associated with event.
	//
	// Returned type: Context
	EventContextInfo EventInfoName = C.CL_EVENT_CONTEXT
	// EventCommandTypeInfo return the command type associated with the event.
	//
	// Returned type: EventCommandType
	EventCommandTypeInfo EventInfoName = C.CL_EVENT_COMMAND_TYPE
	// EventReferenceCountInfo returns the event reference count.
	//
	// Note: The reference count returned should be considered immediately stale. It is unsuitable for
	// general use in applications. This feature is provided for identifying memory leaks.
	//
	// Returned type: uint32
	EventReferenceCountInfo EventInfoName = C.CL_EVENT_REFERENCE_COUNT
	// EventCommandExecutionStatusInfo returns the execution status of the command identified by event.
	//
	// Error codes are identified by a negative integer value: The command was abnormally terminated - this may be
	// caused by a bad memory access for example. These error codes come from the same set of error codes that are
	// returned from the platform or runtime API calls as status codes.
	//
	// Returned type: EventCommandExecutionStatus
	EventCommandExecutionStatusInfo EventInfoName = C.CL_EVENT_COMMAND_EXECUTION_STATUS
)

const (
	// ProfilingCommandQueuedInfo describes the current device time counter in nanoseconds when the command identified
	// by the event is enqueued in a command-queue by the host.
	//
	// Returned type: uint64
	ProfilingCommandQueuedInfo EventProfilingInfoName = C.CL_PROFILING_COMMAND_QUEUED
	// ProfilingCommandSubmitInfo describes the current device time counter in nanoseconds when the command identified
	// by the event that has been enqueued is submitted by the host to the device associated with the command-queue.
	//
	// Returned type: uint64
	ProfilingCommandSubmitInfo EventProfilingInfoName = C.CL_PROFILING_COMMAND_SUBMIT
	// ProfilingCommandStartInfo describes the current device time counter in nanoseconds when the command identified
	// by the event starts execution on the device.
	//
	// Returned type: uint64
	ProfilingCommandStartInfo EventProfilingInfoName = C.CL_PROFILING_COMMAND_START
	// ProfilingCommandEndInfo describes the current device time counter in nanoseconds when the command identified
	// by the event has finished execution on the device.
	//
	// Returned type: uint64
	ProfilingCommandEndInfo EventProfilingInfoName = C.CL_PROFILING_COMMAND_END
	// ProfilingCommandCompleteInfo describes the current device time counter in nanoseconds when the command identified
	// by the event and any child commands enqueued by this command on the device have finished execution.
	//
	// Returned type: uint64
	// Since: 2.0
	ProfilingCommandCompleteInfo EventProfilingInfoName = C.CL_PROFILING_COMMAND_COMPLETE
)

const (
	// ImageFormatInfo return the image format descriptor specified when the image was created.
	//
	// Returned type: ImageFormat
	ImageFormatInfo ImageInfoName = C.CL_IMAGE_FORMAT
	// ImageElementSizeInfo returns the size of each element of the image memory object given by image in bytes.
	//
	// Returned type: uintptr
	ImageElementSizeInfo ImageInfoName = C.CL_IMAGE_ELEMENT_SIZE
	// ImageRowPitchInfo returns the row pitch in bytes of a row of elements of the image object given by image.
	//
	// Returned type: uintptr
	ImageRowPitchInfo ImageInfoName = C.CL_IMAGE_ROW_PITCH
	// ImageSlicePitchInfo returns the slice pitch in bytes of a 2D slice for the 3D image object or size of each
	// image in a 1D or 2D image array given by image.
	//
	// Returned type: uintptr
	ImageSlicePitchInfo ImageInfoName = C.CL_IMAGE_SLICE_PITCH
	// ImageWidthInfo returns the width of the image in pixels.
	//
	// Returned type: uintptr
	ImageWidthInfo ImageInfoName = C.CL_IMAGE_WIDTH
	// ImageHeightInfo returns the height of the image in pixels.
	// For a 1D image, 1D image buffer and 1D image array object, height is 0.
	//
	// Returned type: uintptr
	ImageHeightInfo ImageInfoName = C.CL_IMAGE_HEIGHT
	// ImageDepthInfo returns the depth of the image in pixels.
	// For a 1D image, 1D image buffer, 2D image or 1D and 2D image array object, depth is 0.
	//
	// Returned type: uintptr
	ImageDepthInfo ImageInfoName = C.CL_IMAGE_DEPTH
	// ImageArraySizeInfo returns the number of images in the image array.
	// If image is not an image array, 0 is returned.
	//
	// Returend type: uintptr
	// Since: 1.2
	ImageArraySizeInfo ImageInfoName = C.CL_IMAGE_ARRAY_SIZE
	// ImageBufferInfo returns the buffer object associated with image.
	//
	// Returned type: MemObject
	// Since: 1.2
	// Deprecated: 2.0
	ImageBufferInfo ImageInfoName = C.CL_IMAGE_BUFFER
	// ImageNumMipLevelsInfo returns the MIP level count associated with the image.
	//
	// Returned type: uint32
	// Since: 1.2
	ImageNumMipLevelsInfo ImageInfoName = C.CL_IMAGE_NUM_MIP_LEVELS
	// ImageNumSamplesInfo returns the sample count associated with the image.
	//
	// Returned type: uint32
	// Since: 1.2
	ImageNumSamplesInfo ImageInfoName = C.CL_IMAGE_NUM_SAMPLES
)

const (
	KernelArgAccessReadOnly  KernelArgAccessQualifier = C.CL_KERNEL_ARG_ACCESS_READ_ONLY
	KernelArgAccessWriteOnly KernelArgAccessQualifier = C.CL_KERNEL_ARG_ACCESS_WRITE_ONLY
	KernelArgAccessReadWrite KernelArgAccessQualifier = C.CL_KERNEL_ARG_ACCESS_READ_WRITE
	KernelArgAccessNone      KernelArgAccessQualifier = C.CL_KERNEL_ARG_ACCESS_NONE
)

const (
	KernelArgAddressGlobal   KernelArgAddressQualifier = C.CL_KERNEL_ARG_ADDRESS_GLOBAL
	KernelArgAddressLocal    KernelArgAddressQualifier = C.CL_KERNEL_ARG_ADDRESS_LOCAL
	KernelArgAddressConstant KernelArgAddressQualifier = C.CL_KERNEL_ARG_ADDRESS_CONSTANT
	KernelArgAddressPrivate  KernelArgAddressQualifier = C.CL_KERNEL_ARG_ADDRESS_PRIVATE
)

const (
	// KernelArgAddressQualifierInfo returns the address qualifier specified for the argument.
	//
	// Returned type: KernelArgAddressQualifier
	// Since: 1.2
	KernelArgAddressQualifierInfo KernelArgInfoName = C.CL_KERNEL_ARG_ADDRESS_QUALIFIER
	// KernelArgAccessQualifierInfo returns the access qualifier specified for the argument.
	//
	// Returned type: KernelArgAccessQualifier
	// Since: 1.2
	KernelArgAccessQualifierInfo KernelArgInfoName = C.CL_KERNEL_ARG_ACCESS_QUALIFIER
	// KernelArgTypeNameInfo returns the type name specified for the argument.
	// The type name returned will be the argument type name as it was declared with any whitespace removed.
	// If argument type name is an unsigned scalar type (i.e. unsigned char, unsigned short, unsigned int,
	// unsigned long), uchar, ushort, uint and ulong will be returned.
	// The argument type name returned does not include any type qualifiers.
	//
	// Returned type: string
	// Since: 1.2
	KernelArgTypeNameInfo KernelArgInfoName = C.CL_KERNEL_ARG_TYPE_NAME
	// KernelArgTypeQualifierInfo returns a bitfield describing one or more type qualifiers specified for the argument.
	//
	// Returned type: KernelArgTypeQualifier
	// Since: 1.2
	KernelArgTypeQualifierInfo KernelArgInfoName = C.CL_KERNEL_ARG_TYPE_QUALIFIER
	// KernelArgNameInfo returns the name specified for the argument.
	//
	// Returned type: string
	// Since: 1.2
	KernelArgNameInfo KernelArgInfoName = C.CL_KERNEL_ARG_NAME
)

const (
	KernelArgTypeNone     KernelArgTypeQualifier = C.CL_KERNEL_ARG_TYPE_NONE
	KernelArgTypeConst    KernelArgTypeQualifier = C.CL_KERNEL_ARG_TYPE_CONST
	KernelArgTypeRestrict KernelArgTypeQualifier = C.CL_KERNEL_ARG_TYPE_RESTRICT
	KernelArgTypeVolatile KernelArgTypeQualifier = C.CL_KERNEL_ARG_TYPE_VOLATILE
	KernelArgTypePipe     KernelArgTypeQualifier = C.CL_KERNEL_ARG_TYPE_PIPE
)

const (
	// KernelExecInfoSvmPtrs defines the SVM pointers that must reference locations contained entirely within buffers
	// that are passed to kernel as arguments, or that are passed through the execution information.
	//
	// Non-argument SVM buffers must be specified by passing pointers to those buffers via SetKernelExecInfo()
	// for coarse-grain and fine-grain buffer SVM allocations but not for fine-grain system SVM allocations.
	//
	// Required type: []unsafe.Pointer
	// Since: 2.0
	KernelExecInfoSvmPtrs KernelExecInfoName = C.CL_KERNEL_EXEC_INFO_SVM_PTRS
	// KernelExecInfoSvmFineGrainSystem indicates whether the kernel uses pointers that are fine-grain system SVM
	// allocations. These fine-grain system SVM pointers may be passed as arguments or defined in SVM buffers that
	// are passed as arguments to kernel.
	//
	// Required type: Bool
	// Since: 2.0
	KernelExecInfoSvmFineGrainSystem KernelExecInfoName = C.CL_KERNEL_EXEC_INFO_SVM_FINE_GRAIN_SYSTEM
)

const (
	// KernelFunctionNameInfo returns the kernel function name.
	//
	// Returned type: string
	KernelFunctionNameInfo KernelInfoName = C.CL_KERNEL_FUNCTION_NAME
	// KernelNumArgsInfo returns the number of arguments to kernel.
	//
	// Returned type: uint32
	KernelNumArgsInfo KernelInfoName = C.CL_KERNEL_NUM_ARGS
	// KernelReferenceCountInfo returns the kernel reference count.
	//
	// Note: The reference count returned should be considered immediately stale. It is unsuitable for general
	// use in applications. This feature is provided for identifying memory leaks.
	//
	// Returned type: uint32
	KernelReferenceCountInfo KernelInfoName = C.CL_KERNEL_REFERENCE_COUNT
	// KernelContextInfo returns the context associated with kernel.
	//
	// Returned type: Context
	KernelContextInfo KernelInfoName = C.CL_KERNEL_CONTEXT
	// KernelProgramInfo returns the program object associated with kernel.
	//
	// Returned type: Program
	KernelProgramInfo KernelInfoName = C.CL_KERNEL_PROGRAM
	// KernelAttributesInfo returns any attributes specified using the __attribute__ OpenCL C qualifier
	// (or using an OpenCL C++ qualifier syntax [[]] ) with the kernel function declaration in the program source.
	//
	// Returned type: string
	// Since: 1.2
	KernelAttributesInfo KernelInfoName = C.CL_KERNEL_ATTRIBUTES
)

const (
	// KernelMaxSubGroupSizeForNDRangeInfo returns the maximum sub-group size for this kernel.
	// All sub-groups must be the same size, while the last subgroup in any work-group (i.e. the subgroup with
	// the maximum index) could be the same or smaller size.
	//
	// The input value must be an array of uintptr values corresponding to the local work size parameter of the
	// intended dispatch. The number of dimensions in the ND-range will be inferred from the value specified for
	// input size.
	//
	// Input type: []uintptr
	// Returned type: uintptr
	// Since: 2.1
	// Extension: cl_khr_subgroups
	KernelMaxSubGroupSizeForNDRangeInfo KernelSubGroupInfoName = C.CL_KERNEL_MAX_SUB_GROUP_SIZE_FOR_NDRANGE
	// KernelSubGroupCountForNDRangeInfo returns the number of sub-groups that will be present in each work-group for
	// a given local work size. All workgroups, apart from the last work-group in each dimension in the presence of
	// non-uniform work-group sizes, will have the same number of sub-groups.
	//
	// The input value must be an array of uintptr values corresponding to the local work size parameter of the
	// intended dispatch. The number of dimensions in the ND-range will be inferred from the value specified
	// for input size.
	//
	// Input type: []uintptr
	// Returned type: uintptr
	// Since: 2.1
	// Extension: cl_khr_subgroups
	KernelSubGroupCountForNDRangeInfo KernelSubGroupInfoName = C.CL_KERNEL_SUB_GROUP_COUNT_FOR_NDRANGE
	// KernelLocalSizeForSubGroupCountInfo returns the local size that will generate the requested number of
	// sub-groups for the kernel. The output array must be an array of uintptr values corresponding to the local
	// size parameter. Any returned work-group will have one dimension. Other dimensions inferred from the value
	// specified for param_value_size will be filled with the value 1. The returned value will produce an exact number
	// of sub-groups and result in no partial groups for an executing kernel except in the case where the last
	// work-group in a dimension has a size different from that of the other groups.
	// If no work-group size can accommodate the requested number of sub-groups, 0 will be returned in each element
	// of the return array.
	//
	// Input type: uintptr
	// Returned type: []uintptr
	// Since: 2.1
	// Extension: cl_khr_subgroups
	KernelLocalSizeForSubGroupCountInfo KernelSubGroupInfoName = C.CL_KERNEL_LOCAL_SIZE_FOR_SUB_GROUP_COUNT
	// KernelMaxNumSubGroupsInfo provides a mechanism for the application to query the maximum number of sub-groups
	// that may make up each work-group to execute a kernel on a specific device given by device.
	// The OpenCL implementation uses the resource requirements of the kernel (register usage etc.) to determine
	// what this work-group size should be. The returned value may be used to compute a work-group size to enqueue
	// the kernel with to give a round number of sub-groups for an enqueue.
	//
	// Input type: (ignored)
	// Returned type: uintptr
	// Since: 2.1
	// Extension: cl_khr_subgroups
	KernelMaxNumSubGroupsInfo KernelSubGroupInfoName = C.CL_KERNEL_MAX_NUM_SUB_GROUPS
	// KernelCompileNumSubGroupsInfo returns the number of sub-groups per work-group specified in the kernel source
	// or IL. If the sub-group count is not specified then 0 is returned.
	//
	// Input type: (ignored)
	// Returned type: uintptr
	// Since: 2.1
	// Extension: cl_khr_subgroups
	KernelCompileNumSubGroupsInfo KernelSubGroupInfoName = C.CL_KERNEL_COMPILE_NUM_SUB_GROUPS
)

const (
	// KernelWorkGroupSizeInfo provides a mechanism for the application to query the maximum work-group size
	// that can be used to execute the kernel on a specific device given by device.
	// The OpenCL implementation uses the resource requirements of the kernel (register usage etc.) to determine what
	// this work-group size should be.
	//
	// As a result and unlike DeviceMaxWorkGroupSizeInfo this value may vary from one kernel to another as well as
	// one device to another.
	//
	// KernelCompileWorkGroupSizeInfo will be less than or equal to DeviceMaxWorkGroupSizeInfo for a given kernel object.
	//
	// Returned type: uintptr
	KernelWorkGroupSizeInfo KernelWorkGroupInfoName = C.CL_KERNEL_WORK_GROUP_SIZE
	// KernelCompileWorkGroupSizeInfo returns the work-group size specified in the kernel source or IL.
	//
	// If the work-group size is not specified in the kernel source or IL, (0, 0, 0) is returned.
	//
	// Returned type: [3]uintptr
	KernelCompileWorkGroupSizeInfo KernelWorkGroupInfoName = C.CL_KERNEL_COMPILE_WORK_GROUP_SIZE
	// KernelLocalMemSizeInfo returns the amount of local memory in bytes being used by a kernel.
	// This includes local memory that may be needed by an implementation to execute the kernel, variables declared
	// inside the kernel with the __local address qualifier and local memory to be allocated for arguments to the
	// kernel declared as pointers with the __local address qualifier and whose size is specified with SetKernelArg().
	//
	// If the local memory size, for any pointer argument to the kernel declared with the __local address qualifier,
	// is not specified, its size is assumed to be 0.
	//
	// Returned type: uint64
	KernelLocalMemSizeInfo KernelWorkGroupInfoName = C.CL_KERNEL_LOCAL_MEM_SIZE
	// KernelPreferredWorkGroupSizeMultipleInfo returns the preferred multiple of work-group size for launch.
	// This is a performance hint. Specifying a work-group size that is not a multiple of the value returned by this
	// query as the value of the local work size argument to EnqueueNDRangeKernel() will not fail to enqueue the kernel
	// for execution unless the work-group size specified is larger than the device maximum.
	//
	// Returned type: uintptr
	KernelPreferredWorkGroupSizeMultipleInfo KernelWorkGroupInfoName = C.CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE
	// KernelPrivateMemSizeInfo returns the minimum amount of private memory, in bytes, used by each work-item in
	// the kernel. This value may include any private memory needed by an implementation to execute the kernel,
	// including that used by the language built-ins and variable declared inside the kernel with the __private qualifier.
	//
	// Returned type: uint64
	KernelPrivateMemSizeInfo KernelWorkGroupInfoName = C.CL_KERNEL_PRIVATE_MEM_SIZE
	// KernelGlobalWorkSizeInfo provides a mechanism for the application to query the maximum global size that can be
	// used to execute a kernel (i.e. globalWorkSize argument to EnqueueNDRangeKernel()) on a custom device given by
	// device or a built-in kernel on an OpenCL device given by device.
	//
	// If device is not a custom device and kernel is not a built-in kernel, GetKernelWorkGroupInfo() returns the
	// error ErrInvalidValue.
	//
	// Returned type: [3]uintptr
	// Since: 1.2
	KernelGlobalWorkSizeInfo KernelWorkGroupInfoName = C.CL_KERNEL_GLOBAL_WORK_SIZE
)

const (
	// MapRead specifies that the region being mapped in the memory object is being mapped for reading.
	MapRead MapFlags = C.CL_MAP_READ
	// MapWrite specifies that the region being mapped in the memory object is being mapped for writing.
	MapWrite MapFlags = C.CL_MAP_WRITE
	// MapWriteInvalidateRegion specifies that the region being mapped in the memory object is being mapped for writing.
	//
	// The contents of the region being mapped are to be discarded. This is typically the case when the region
	// being mapped is overwritten by the host. This flag allows the implementation to no longer guarantee that the
	// pointer returned by EnqueueMapBuffer() (EnqueueMapImage()) contains the latest bits in the region being mapped
	// which can be a significant performance enhancement.
	//
	// Since: 1.2
	MapWriteInvalidateRegion MapFlags = C.CL_MAP_WRITE_INVALIDATE_REGION
)

const (
	// MigrateMemObjectHost indicates that the specified set of memory objects are to be migrated to the host,
	// regardless of the target command-queue.
	//
	// Since: 1.2
	MigrateMemObjectHost MemMigrationFlags = C.CL_MIGRATE_MEM_OBJECT_HOST
	// MigrateMemObjectContentUndefined indicates that the contents of the set of memory objects are undefined after
	// migration. The specified set of memory objects are migrated to the device associated with the command-queue
	// without incurring the overhead of migrating their contents.
	//
	// Since: 1.2
	MigrateMemObjectContentUndefined MemMigrationFlags = C.CL_MIGRATE_MEM_OBJECT_CONTENT_UNDEFINED
)

const (
	// MemTypeInfo returns the type of the memory object.
	//
	// Returned type: MemObjectType
	MemTypeInfo MemObjectInfoName = C.CL_MEM_TYPE
	// MemFlagsInfo returns the flags argument value specified when the memory object was created.
	// If the memory object is a sub-buffer the memory access qualifiers inherited from parent buffer are also returned.
	//
	// Returned type: MemFlags
	MemFlagsInfo MemObjectInfoName = C.CL_MEM_FLAGS
	// MemSizeInfo returns the actual size of the data store associated with the memory object in bytes.
	//
	// Returned type: uintptr
	MemSizeInfo MemObjectInfoName = C.CL_MEM_SIZE
	// MemHostPtrInfo returns the underlying host pointer for a MemObject if it (or its source buffer) was
	// created with the MemUseHostPtrFlag. It returns nil otherwise.
	//
	// Returned type: unsafe.Pointer
	MemHostPtrInfo MemObjectInfoName = C.CL_MEM_HOST_PTR
	// MemContextInfo returns the context specified when memory object is created.
	//
	// Returned type: Context
	MemContextInfo MemObjectInfoName = C.CL_MEM_CONTEXT
	// MemOffsetInfo returns the offset if memory object is a sub-buffer object created using CreateSubBuffer().
	// It returns 0 if memory object is not a sub-buffer object.
	//
	// Returned type: uintptr
	// Since: 1.1
	MemOffsetInfo MemObjectInfoName = C.CL_MEM_OFFSET
	// MemPropertiesInfo return the properties that were specified during object creation.
	//
	// Returned type: []uint64
	// Since: 3.0
	MemPropertiesInfo MemObjectInfoName = C.CL_MEM_PROPERTIES
	// MemMapCountInfo returns the current map count.
	//
	// Note: The map count returned should be considered immediately stale. It is unsuitable for
	// general use in applications. This feature is provided for debugging.
	//
	// Returned type: uint32
	MemMapCountInfo MemObjectInfoName = C.CL_MEM_MAP_COUNT
	// MemReferenceCountInfo returns the memory reference count.
	//
	// Note: The reference count returned should be considered immediately stale. It is unsuitable for
	// general use in applications. This feature is provided for identifying memory leaks.
	//
	// Returned type: uint32
	MemReferenceCountInfo MemObjectInfoName = C.CL_MEM_REFERENCE_COUNT
	// MemAssociatedMemObjectInfo returns the memory object from which the queried memory object is created.
	//
	// Returned type: MemObject
	// Since: 1.1
	MemAssociatedMemObjectInfo MemObjectInfoName = C.CL_MEM_ASSOCIATED_MEMOBJECT
	// MemUsesSvmPointerInfo returns True if memory object is a buffer object that was created with
	// MemUseHostPtrFlag or is a sub-buffer object of a buffer object that was created with MemUseHostPtrFlag and
	// the host pointer specified when the buffer object was created is an SVM pointer; otherwise returns False.
	//
	// Returned type: Bool
	// Since: 2.0
	MemUsesSvmPointerInfo MemObjectInfoName = C.CL_MEM_USES_SVM_POINTER
)

const (
	MemObjectBufferType  MemObjectType = C.CL_MEM_OBJECT_BUFFER
	MemObjectImage2DType MemObjectType = C.CL_MEM_OBJECT_IMAGE2D
	MemObjectImage3DType MemObjectType = C.CL_MEM_OBJECT_IMAGE3D

	MemObjectImage2DArrayType  MemObjectType = C.CL_MEM_OBJECT_IMAGE2D_ARRAY
	MemObjectImage1DType       MemObjectType = C.CL_MEM_OBJECT_IMAGE1D
	MemObjectImage1DArrayType  MemObjectType = C.CL_MEM_OBJECT_IMAGE1D_ARRAY
	MemObjectImage1DBufferType MemObjectType = C.CL_MEM_OBJECT_IMAGE1D_BUFFER

	MemObjectPipeType MemObjectType = C.CL_MEM_OBJECT_PIPE
)

const (
	// PipePacketSizeInfo returns pipe packet size specified when pipe is created with CreatePipe().
	//
	// Returned type: uint32
	// Since: 2.0
	PipePacketSizeInfo PipeInfoName = C.CL_PIPE_PACKET_SIZE
	// PipeMaxPacketsInfo returns maximum number of packets specified when pipe is created with CreatePipe().
	//
	// Returned type: uint32
	// Since: 2.0
	PipeMaxPacketsInfo PipeInfoName = C.CL_PIPE_MAX_PACKETS
	// PipePropertiesInfo returns the properties argument specified in CreatePipe().
	//
	// Returned type: []uintptr
	// Since: 3.0
	PipePropertiesInfo PipeInfoName = C.CL_PIPE_PROPERTIES
)

const (
	// PlatformNameInfo refers to a human-readable string that identifies the platform.
	//
	// Returned type: string
	PlatformNameInfo PlatformInfoName = C.CL_PLATFORM_NAME
	// PlatformVendorInfo refers to a human-readable string that identifies the vendor of the platform.
	//
	// Returned type: string
	PlatformVendorInfo PlatformInfoName = C.CL_PLATFORM_VENDOR
	// PlatformProfileInfo refers to the profile name supported by the implementation.
	// The profile name returned can be one of the following strings:
	//
	// "FULL_PROFILE" - if the implementation supports the OpenCL specification (functionality defined as part of the
	// core specification and does not require any extensions to be supported).
	//
	// "EMBEDDED_PROFILE" - if the implementation supports the OpenCL embedded profile. The embedded profile is defined
	// to be a subset for each version of OpenCL.
	//
	// Returned type: string
	PlatformProfileInfo PlatformInfoName = C.CL_PLATFORM_PROFILE
	// PlatformVersionInfo refers to the OpenCL version supported by the implementation.
	// This version string has the following format:
	//
	// OpenCL<space><major_version.minor_version><space><platform-specific information>
	//
	// Returned type: string
	PlatformVersionInfo PlatformInfoName = C.CL_PLATFORM_VERSION
	// PlatformNumericVersionInfo refers to the detailed (major, minor, patch) version supported by the platform.
	// The major and minor version numbers returned must match those returned via PlatformVersionInfo.
	//
	// Returned type: Version
	// Since: 3.0
	PlatformNumericVersionInfo PlatformInfoName = C.CL_PLATFORM_NUMERIC_VERSION
	// PlatformExtensionsInfo refers to a space separated list of extension names (the extension names themselves do not
	// contain any spaces) supported by the platform. Each extension that is supported by all devices associated with
	// this platform must be reported here.
	//
	// Returned type: string
	PlatformExtensionsInfo PlatformInfoName = C.CL_PLATFORM_EXTENSIONS
	// PlatformExtensionsWithVersionInfo refers to an array of description (name and version) structures that lists all
	// the extensions supported by the platform. The same extension name must not be reported more than once.
	// The list of extensions reported must match the list reported via PlatformExtensionsInfo.
	//
	// Returned type: []NameVersion
	// Since: 3.0
	PlatformExtensionsWithVersionInfo PlatformInfoName = C.CL_PLATFORM_EXTENSIONS_WITH_VERSION
	// PlatformHostTimerResolutionInfo refers to the resolution of the host timer in nanoseconds as used by
	// DeviceAndHostTimer() and HostTimer().
	// This value must be 0 for devices that do not support device and host timer synchronization.
	//
	// Returned type: uint64
	// Since: 2.1
	PlatformHostTimerResolutionInfo PlatformInfoName = C.CL_PLATFORM_HOST_TIMER_RESOLUTION
)

const (
	// ProgramBinaryTypeNone is set if there is no binary associated with the specified program object for device.
	ProgramBinaryTypeNone ProgramBinaryType = C.CL_PROGRAM_BINARY_TYPE_NONE
	// ProgramBinaryTypeCompiledObject is a compiled binary associated with device.
	// This is the case when the specified program object was created using CreateProgramWithSource() and compiled
	// using CompileProgram(), or when a compiled binary was loaded using CreateProgramWithBinary().
	ProgramBinaryTypeCompiledObject ProgramBinaryType = C.CL_PROGRAM_BINARY_TYPE_COMPILED_OBJECT
	// ProgramBinaryTypeLibrary is a library binary associated with device.
	// This is the case when the specified program object was linked by LinkProgram() using the -create-library link
	// option, or when a compiled library binary was loaded using CreateProgramWithBinary().
	ProgramBinaryTypeLibrary ProgramBinaryType = C.CL_PROGRAM_BINARY_TYPE_LIBRARY
	// ProgramBinaryTypeExecutable is an executable binary associated with device.
	// This is the case when the specified program object was linked by LinkProgram() without the -create-library link
	// option, or when an executable binary was built using BuildProgram().
	ProgramBinaryTypeExecutable ProgramBinaryType = C.CL_PROGRAM_BINARY_TYPE_EXECUTABLE
)

const (
	// ProgramBuildStatusInfo returns the build, compile, or link status, whichever was performed last on the
	// specified program object for device.
	//
	// Returned type: BuildStatus
	ProgramBuildStatusInfo ProgramBuildInfoName = C.CL_PROGRAM_BUILD_STATUS
	// ProgramBuildOptionsInfo return the build, compile, or link options specified by the options argument in
	// BuildProgram(), CompileProgram(), or LinkProgram(), whichever was performed last on the specified program
	// object for device.
	//
	// If build status of the specified program for device is BuildNoneStatus, an empty string is returned.
	//
	// Returned type: string
	ProgramBuildOptionsInfo ProgramBuildInfoName = C.CL_PROGRAM_BUILD_OPTIONS
	// ProgramBuildLogInfo returns the build, compile, or link log for BuildProgram(), CompileProgram(), or
	// LinkProgram(), whichever was performed last on program for device.
	//
	// If build status of the specified program for device is BuildNoneStatus, an empty string is returned.
	//
	// Returned type: string
	ProgramBuildLogInfo ProgramBuildInfoName = C.CL_PROGRAM_BUILD_LOG
	// ProgramBinaryTypeInfo returns the program binary type for device.
	//
	// Returned type: ProgramBinaryType
	// Since: 1.2
	ProgramBinaryTypeInfo ProgramBuildInfoName = C.CL_PROGRAM_BINARY_TYPE
	// ProgramBuildGlobalVariableTotalSizeInfo returns the total amount of storage, in bytes, used by program
	// variables in the global address space.
	//
	// Returned type: uintptr
	// Since: 2.0
	ProgramBuildGlobalVariableTotalSizeInfo ProgramBuildInfoName = C.CL_PROGRAM_BUILD_GLOBAL_VARIABLE_TOTAL_SIZE
)

const (
	// ProgramReferenceCountInfo returns the program reference count.
	//
	// Note: The reference count returned should be considered immediately stale. It is unsuitable for
	// general use in applications. This feature is provided for identifying memory leaks.
	//
	// Returned type: uint32
	ProgramReferenceCountInfo ProgramInfoName = C.CL_PROGRAM_REFERENCE_COUNT
	// ProgramContextInfo returns the context specified when the program object is created.
	//
	// Returned type: Context
	ProgramContextInfo ProgramInfoName = C.CL_PROGRAM_CONTEXT
	// ProgramNumDevicesInfo returns the number of devices associated with program.
	//
	// Returned type: uint32
	ProgramNumDevicesInfo ProgramInfoName = C.CL_PROGRAM_NUM_DEVICES
	// ProgramDevicesInfo returns the list of devices associated with the program object. This can be the
	// devices associated with context on which the program object has been created or can be a subset of devices
	// that are specified when a program object is created using CreateProgramWithBinary().
	//
	// Returned type: []DeviceID
	ProgramDevicesInfo ProgramInfoName = C.CL_PROGRAM_DEVICES
	// ProgramSourceInfo returns the program source code specified by CreateProgramWithSource().
	// The source string returned is a concatenation of all source strings specified to CreateProgramWithSource().
	//
	// If program is created using CreateProgramWithBinary(), CreateProgramWithIl(), or
	// CreateProgramWithBuiltInKernels(), an empty string or the appropriate program source code is returned depending
	// on whether the program source code is stored in the binary.
	//
	// Returned type: string
	ProgramSourceInfo ProgramInfoName = C.CL_PROGRAM_SOURCE
	// ProgramBinarySizesInfo returns an array that contains the size in bytes of the program binary
	// (could be an executable binary, compiled binary, or library binary) for each device associated with program.
	// The size of the array is the number of devices associated with program. If a binary is not available for a
	// device(s), a size of zero is returned.
	//
	// If program is created using CreateProgramWithBuiltInKernels(), the implementation may return zero in any
	// entries of the returned array.
	//
	// Returned type: []uintptr
	ProgramBinarySizesInfo ProgramInfoName = C.CL_PROGRAM_BINARY_SIZES
	// ProgramBinariesInfo returns the program binaries (could be an executable binary, compiled binary, or
	// library binary) for all devices associated with program. For each device in program, the binary returned can
	// be the binary specified for the device when program is created with CreateProgramWithBinary() or it can be the
	// executable binary generated by BuildProgram() or LinkProgram().
	// If program is created with CreateProgramWithSource() or CreateProgramWithIl(), the binary returned is the
	// binary generated by BuildProgram(), CompileProgram(), or LinkProgram(). The bits returned can be an
	// implementation-specific intermediate representation (a.k.a. IR) or device specific executable bits or both.
	// The decision on which information is returned in the binary is up to the OpenCL implementation.
	//
	// The paramValue points to an array of N pointers allocated by the caller, where N is the number of devices
	// associated with program. The buffer sizes needed to allocate the memory that these N pointers refer to can
	// be queried using the ProgramBinarySizesInfo query.
	//
	// Each entry in this array is used by the implementation as the location in memory where to copy the program
	// binary for a specific device, if there is a binary available. To find out which device the program binary
	// in the array refers to, use the ProgramDevicesInfo query to get the list of devices. There is a one-to-one
	// correspondence between the array of N pointers returned by ProgramBinariesInfo and array of devices returned
	// by ProgramDevicesInfo.
	//
	// Returned type: []unsafe.Pointer (pointing to byte arrays)
	ProgramBinariesInfo ProgramInfoName = C.CL_PROGRAM_BINARIES
	// ProgramNumKernelsInfo returns the number of kernels declared in program that can be created with CreateKernel().
	// This information is only available after a successful program executable has been built for at least one device
	// in the list of devices associated with program.
	//
	// Returned type: uintptr
	// Since: 1.2
	ProgramNumKernelsInfo ProgramInfoName = C.CL_PROGRAM_NUM_KERNELS
	// ProgramKernelNamesInfo returns a semi-colon separated list of kernel names in program that can be created
	// with CreateKernel(). This information is only available after a successful program executable has been built
	// for at least one device in the list of devices associated with program.
	//
	// Returned type: string
	// Since: 1.2
	ProgramKernelNamesInfo ProgramInfoName = C.CL_PROGRAM_KERNEL_NAMES
	// ProgramIlInfo returns the program intermediate language (IL) for programs created with CreateProgramWithIl().
	//
	// If program is created with CreateProgramWithSource(), CreateProgramWithBinary(), or
	// CreateProgramWithBuiltInKernels() the memory pointed to by paramValue will be unchanged and
	// the returned size be 0.
	//
	// Returned type: []byte
	// Since: 2.1
	ProgramIlInfo ProgramInfoName = C.CL_PROGRAM_IL
	// ProgramScopeGlobalCtorsPresentInfo indicates that the program object contains non-trivial constructor(s)
	// that will be executed by runtime before any kernel from the program is executed.
	// This information is only available after a successful program executable has been built for at least one
	// device in the list of devices associated with program.
	//
	// Querying ProgramScopeGlobalCtorsPresentInfo may unconditionally return False if no devices associated
	// with program support constructors for program scope global variables. Support for constructors and destructors
	// for program scope global variables is required only for OpenCL 2.2 devices.
	//
	// Returned type: Bool
	// Since: 2.2
	ProgramScopeGlobalCtorsPresentInfo ProgramInfoName = C.CL_PROGRAM_SCOPE_GLOBAL_CTORS_PRESENT
	// ProgramScopeGlobalDtorsPresentInfo indicates that the program object contains non-trivial destructor(s)
	// that will be executed by runtime when program is destroyed.
	// This information is only available after a successful program executable has been built for at least one
	// device in the list of devices associated with program.
	//
	// Querying ProgramScopeGlobalDtorsPresentInfo may unconditionally return False if no devices associated
	// with program support destructors for program scope global variables. Support for constructors and destructors
	// for program scope global variables is required only for OpenCL 2.2 devices.
	//
	// Returned type: Bool
	// Since: 2.2
	ProgramScopeGlobalDtorsPresentInfo ProgramInfoName = C.CL_PROGRAM_SCOPE_GLOBAL_DTORS_PRESENT
)

const (
	// AddressNoneMode specifies that behavior is undefined for out-of-range image coordinates.
	AddressNoneMode SamplerAddressingMode = C.CL_ADDRESS_NONE
	// AddressClampToEdgeMode specifies that out-of-range image coordinates are clamped to the edge of the image.
	AddressClampToEdgeMode SamplerAddressingMode = C.CL_ADDRESS_CLAMP_TO_EDGE
	// AddressClampMode specifies that out-of-range image coordinates are assigned a border color value.
	AddressClampMode SamplerAddressingMode = C.CL_ADDRESS_CLAMP
	// AddressRepeatMode specifies that out-of-range image coordinates read from the image as-if the image data were
	// replicated in all dimensions.
	AddressRepeatMode SamplerAddressingMode = C.CL_ADDRESS_REPEAT
	// AddressMirroredRepeatMode specifies that out-of-range image coordinates read from the image as-if the image data
	// were replicated in all dimensions, mirroring the image contents at the edge of each replication.
	//
	// Since: 1.1
	AddressMirroredRepeatMode SamplerAddressingMode = C.CL_ADDRESS_MIRRORED_REPEAT
)

const (
	// FilterNearestMode returns the image element nearest to the image coordinate.
	FilterNearestMode SamplerFilterMode = C.CL_FILTER_NEAREST
	// FilterLinearMode returns a weighted average of the four image elements nearest to the image coordinate.
	FilterLinearMode SamplerFilterMode = C.CL_FILTER_LINEAR
)

const (
	// SamplerReferenceCountInfo returns the sampler reference count.
	//
	// Note: The reference count returned should be considered immediately stale. It is unsuitable for general use
	// in applications. This feature is provided for identifying memory leaks.
	//
	// Returned type: uint32
	SamplerReferenceCountInfo SamplerInfoName = C.CL_SAMPLER_REFERENCE_COUNT
	// SamplerContextInfo returns the context specified when the sampler is created.
	//
	// Returned type: Context
	SamplerContextInfo SamplerInfoName = C.CL_SAMPLER_CONTEXT
	// SamplerNormalizedCoordsInfo return the normalized coords value associated with sampler.
	//
	// Returned type: Bool
	SamplerNormalizedCoordsInfo SamplerInfoName = C.CL_SAMPLER_NORMALIZED_COORDS
	// SamplerAddressingModeInfo returns the addressing mode value associated with sampler.
	//
	// Returned type: SamplerAddressingMode
	SamplerAddressingModeInfo SamplerInfoName = C.CL_SAMPLER_ADDRESSING_MODE
	// SamplerFilterModeInfo returns the filter mode value associated with sampler.
	//
	// Returned type: SamplerFilterMode
	SamplerFilterModeInfo SamplerInfoName = C.CL_SAMPLER_FILTER_MODE
	// SamplerPropertiesInfo returns the properties argument specified in CreateSamplerWithProperties().
	//
	// Returned type: []uint64
	// Since: 3.0
	SamplerPropertiesInfo SamplerInfoName = C.CL_SAMPLER_PROPERTIES
)

const (
	ErrDeviceNotFound                     StatusError = C.CL_DEVICE_NOT_FOUND
	ErrDeviceNotAvailable                 StatusError = C.CL_DEVICE_NOT_AVAILABLE
	ErrCompilerNotAvailable               StatusError = C.CL_COMPILER_NOT_AVAILABLE
	ErrMemObjectAllocationFailure         StatusError = C.CL_MEM_OBJECT_ALLOCATION_FAILURE
	ErrOutOfResources                     StatusError = C.CL_OUT_OF_RESOURCES
	ErrOutOfHostMemory                    StatusError = C.CL_OUT_OF_HOST_MEMORY
	ErrProfilingInfoNotAvailable          StatusError = C.CL_PROFILING_INFO_NOT_AVAILABLE
	ErrMemCopyOverlap                     StatusError = C.CL_MEM_COPY_OVERLAP
	ErrImageFormatMismatch                StatusError = C.CL_IMAGE_FORMAT_MISMATCH
	ErrImageFormatNotSupported            StatusError = C.CL_IMAGE_FORMAT_NOT_SUPPORTED
	ErrBuildProgramFailure                StatusError = C.CL_BUILD_PROGRAM_FAILURE
	ErrMapFailure                         StatusError = C.CL_MAP_FAILURE
	ErrMisalignedSubBufferOffset          StatusError = C.CL_MISALIGNED_SUB_BUFFER_OFFSET
	ErrExecStatusErrorForEventsInWaitList StatusError = C.CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST
	ErrCompileProgramFailure              StatusError = C.CL_COMPILE_PROGRAM_FAILURE
	ErrLinkerNotAvailable                 StatusError = C.CL_LINKER_NOT_AVAILABLE
	ErrLinkProgramFailure                 StatusError = C.CL_LINK_PROGRAM_FAILURE
	ErrDevicePartitionFailed              StatusError = C.CL_DEVICE_PARTITION_FAILED
	ErrKernelArgInfoNotAvailable          StatusError = C.CL_KERNEL_ARG_INFO_NOT_AVAILABLE
	ErrInvalidValue                       StatusError = C.CL_INVALID_VALUE
	ErrInvalidDeviceType                  StatusError = C.CL_INVALID_DEVICE_TYPE
	ErrInvalidPlatform                    StatusError = C.CL_INVALID_PLATFORM
	ErrInvalidDevice                      StatusError = C.CL_INVALID_DEVICE
	ErrInvalidContext                     StatusError = C.CL_INVALID_CONTEXT
	ErrInvalidQueueProperties             StatusError = C.CL_INVALID_QUEUE_PROPERTIES
	ErrInvalidCommandQueue                StatusError = C.CL_INVALID_COMMAND_QUEUE
	ErrInvalidHostPtr                     StatusError = C.CL_INVALID_HOST_PTR
	ErrInvalidMemObject                   StatusError = C.CL_INVALID_MEM_OBJECT
	ErrINvalidImageFormatDescriptor       StatusError = C.CL_INVALID_IMAGE_FORMAT_DESCRIPTOR
	ErrInvalidImageSize                   StatusError = C.CL_INVALID_IMAGE_SIZE
	ErrInvalidSampler                     StatusError = C.CL_INVALID_SAMPLER
	ErrInvalidBinary                      StatusError = C.CL_INVALID_BINARY
	ErrInvalidBuildOptions                StatusError = C.CL_INVALID_BUILD_OPTIONS
	ErrInvalidProgram                     StatusError = C.CL_INVALID_PROGRAM
	ErrInvalidProgramExecutable           StatusError = C.CL_INVALID_PROGRAM_EXECUTABLE
	ErrInvalidKernelName                  StatusError = C.CL_INVALID_KERNEL_NAME
	ErrInvalidKernelDefinition            StatusError = C.CL_INVALID_KERNEL_DEFINITION
	ErrInvalidKernel                      StatusError = C.CL_INVALID_KERNEL
	ErrInvalidArgIndex                    StatusError = C.CL_INVALID_ARG_INDEX
	ErrInvalidArgValue                    StatusError = C.CL_INVALID_ARG_VALUE
	ErrInvalidArgSize                     StatusError = C.CL_INVALID_ARG_SIZE
	ErrInvalidKernelArgs                  StatusError = C.CL_INVALID_KERNEL_ARGS
	ErrInvalidWorkDimension               StatusError = C.CL_INVALID_WORK_DIMENSION
	ErrInvalidWorkGroupSize               StatusError = C.CL_INVALID_WORK_GROUP_SIZE
	ErrInvalidWorkItemSize                StatusError = C.CL_INVALID_WORK_ITEM_SIZE
	ErrInvalidGlobalOffset                StatusError = C.CL_INVALID_GLOBAL_OFFSET
	ErrInvalidEventWaitList               StatusError = C.CL_INVALID_EVENT_WAIT_LIST
	ErrInvalidEvent                       StatusError = C.CL_INVALID_EVENT
	ErrInvalidOperation                   StatusError = C.CL_INVALID_OPERATION
	ErrInvalidGlObject                    StatusError = C.CL_INVALID_GL_OBJECT
	ErrInvalidBufferSize                  StatusError = C.CL_INVALID_BUFFER_SIZE
	ErrInvalidMipLevel                    StatusError = C.CL_INVALID_MIP_LEVEL
	ErrInvalidGlobalWorkSize              StatusError = C.CL_INVALID_GLOBAL_WORK_SIZE
	ErrInvalidProperty                    StatusError = C.CL_INVALID_PROPERTY
	ErrInvalidImageDescriptor             StatusError = C.CL_INVALID_IMAGE_DESCRIPTOR
	ErrInvalidCompilerOptions             StatusError = C.CL_INVALID_COMPILER_OPTIONS
	ErrInvalidLinkerOptions               StatusError = C.CL_INVALID_LINKER_OPTIONS
	ErrInvalidDevicePartitionCount        StatusError = C.CL_INVALID_DEVICE_PARTITION_COUNT
	ErrInvalidPipeSize                    StatusError = C.CL_INVALID_PIPE_SIZE
	ErrInvalidDeviceQueue                 StatusError = C.CL_INVALID_DEVICE_QUEUE
	ErrInvalidSpecID                      StatusError = C.CL_INVALID_SPEC_ID
	ErrMaxSizeRestrictionExceeded         StatusError = C.CL_MAX_SIZE_RESTRICTION_EXCEEDED
)

const (
	// VersionMin is the lowest value that Version can represent. It has all components set to zero.
	VersionMin Version = 0
	// VersionMax is the highest value that Version can represent.
	// It has all components set to their maximally possible value.
	VersionMax Version = math.MaxUint32
)

const (
	// ErrExtensionNotAvailable is returned in case an extension loader function could not complete its setup.
	ErrExtensionNotAvailable WrapperError = "extension not available"
	// ErrExtensionNotLoaded is returned in case an extension was used without being loaded.
	ErrExtensionNotLoaded WrapperError = "extension not loaded"
	// ErrDataSizeLimitExceeded is returned by convenience functions that query information, typically string-loading
	// functions. The error occurs if the required size would be beyond a (feasible) limit.
	ErrDataSizeLimitExceeded WrapperError = "data size limit exceeded"
	// ErrOutOfMemory is returned by wrapper functions that need to allocate memory.
	ErrOutOfMemory WrapperError = "out of memory"
)