Source code for binaryninja._binaryninjacore

import ctypes, os

from typing import Optional, AnyStr# Load core module
import platform
core = None
_base_path = None
core_platform = platform.system()
if core_platform == "Darwin":
	_base_path = os.path.join(os.path.dirname(__file__), "..", "..", "..", "MacOS")
	core = ctypes.CDLL(os.path.join(_base_path, "libbinaryninjacore.dylib"))

elif core_platform == "Linux":
	_base_path = os.path.join(os.path.dirname(__file__), "..", "..")
	core = ctypes.CDLL(os.path.join(_base_path, "libbinaryninjacore.so.1"))

elif (core_platform == "Windows") or (core_platform.find("CYGWIN_NT") == 0):
	_base_path = os.path.join(os.path.dirname(__file__), "..", "..")
	core = ctypes.CDLL(os.path.join(_base_path, "binaryninjacore.dll"))
else:
	raise Exception("OS not supported")


def cstr(var: Optional[AnyStr]) -> Optional[bytes]:
	if var is None:
		return None
	if isinstance(var, bytes):
		return var
	return var.encode("utf-8")


def pyNativeStr(arg: AnyStr) -> str:
	if isinstance(arg, str):
		return arg
	else:
		return arg.decode('utf8')


def free_string(value:ctypes.c_char_p) -> None:
	BNFreeString(ctypes.cast(value, ctypes.POINTER(ctypes.c_byte)))

# Type definitions
ActionTypeEnum = ctypes.c_int
class BNActiveAnalysisInfo(ctypes.Structure):
	pass


BNActiveAnalysisInfoHandle = ctypes.POINTER(BNActiveAnalysisInfo)


class BNActivity(ctypes.Structure):
	pass


BNActivityHandle = ctypes.POINTER(BNActivity)


class BNAddressRange(ctypes.Structure):
	pass


BNAddressRangeHandle = ctypes.POINTER(BNAddressRange)


class BNAnalysisCompletionEvent(ctypes.Structure):
	pass


BNAnalysisCompletionEventHandle = ctypes.POINTER(BNAnalysisCompletionEvent)


class BNAnalysisContext(ctypes.Structure):
	pass


BNAnalysisContextHandle = ctypes.POINTER(BNAnalysisContext)


class BNAnalysisInfo(ctypes.Structure):
	pass


BNAnalysisInfoHandle = ctypes.POINTER(BNAnalysisInfo)


AnalysisModeEnum = ctypes.c_int
class BNAnalysisParameters(ctypes.Structure):
	pass


BNAnalysisParametersHandle = ctypes.POINTER(BNAnalysisParameters)


class BNAnalysisProgress(ctypes.Structure):
	pass


BNAnalysisProgressHandle = ctypes.POINTER(BNAnalysisProgress)


AnalysisSkipReasonEnum = ctypes.c_int
AnalysisStateEnum = ctypes.c_int
AnalysisWarningActionTypeEnum = ctypes.c_int
class BNArchitecture(ctypes.Structure):
	pass


BNArchitectureHandle = ctypes.POINTER(BNArchitecture)


class BNArchitectureAndAddress(ctypes.Structure):
	pass


BNArchitectureAndAddressHandle = ctypes.POINTER(BNArchitectureAndAddress)


class BNBackgroundTask(ctypes.Structure):
	pass


BNBackgroundTaskHandle = ctypes.POINTER(BNBackgroundTask)


class BNBasicBlock(ctypes.Structure):
	pass


BNBasicBlockHandle = ctypes.POINTER(BNBasicBlock)


class BNBasicBlockEdge(ctypes.Structure):
	pass


BNBasicBlockEdgeHandle = ctypes.POINTER(BNBasicBlockEdge)


class BNBinaryDataNotification(ctypes.Structure):
	pass


BNBinaryDataNotificationHandle = ctypes.POINTER(BNBinaryDataNotification)


class BNBinaryReader(ctypes.Structure):
	pass


BNBinaryReaderHandle = ctypes.POINTER(BNBinaryReader)


class BNBinaryView(ctypes.Structure):
	pass


BNBinaryViewHandle = ctypes.POINTER(BNBinaryView)


class BNBinaryViewEvent(ctypes.Structure):
	pass


BNBinaryViewEventHandle = ctypes.POINTER(BNBinaryViewEvent)


BinaryViewEventTypeEnum = ctypes.c_int
class BNBinaryViewType(ctypes.Structure):
	pass


BNBinaryViewTypeHandle = ctypes.POINTER(BNBinaryViewType)


class BNBinaryWriter(ctypes.Structure):
	pass


BNBinaryWriterHandle = ctypes.POINTER(BNBinaryWriter)


class BNBoolWithConfidence(ctypes.Structure):
	pass


BNBoolWithConfidenceHandle = ctypes.POINTER(BNBoolWithConfidence)


BranchTypeEnum = ctypes.c_int
class BNCallingConvention(ctypes.Structure):
	pass


BNCallingConventionHandle = ctypes.POINTER(BNCallingConvention)


CallingConventionNameEnum = ctypes.c_int
class BNCallingConventionWithConfidence(ctypes.Structure):
	pass


BNCallingConventionWithConfidenceHandle = ctypes.POINTER(BNCallingConventionWithConfidence)


class BNComponent(ctypes.Structure):
	pass


BNComponentHandle = ctypes.POINTER(BNComponent)


class BNConstantReference(ctypes.Structure):
	pass


BNConstantReferenceHandle = ctypes.POINTER(BNConstantReference)


class BNCustomArchitecture(ctypes.Structure):
	pass


BNCustomArchitectureHandle = ctypes.POINTER(BNCustomArchitecture)


class BNCustomBinaryView(ctypes.Structure):
	pass


BNCustomBinaryViewHandle = ctypes.POINTER(BNCustomBinaryView)


class BNCustomBinaryViewType(ctypes.Structure):
	pass


BNCustomBinaryViewTypeHandle = ctypes.POINTER(BNCustomBinaryViewType)


class BNCustomCallingConvention(ctypes.Structure):
	pass


BNCustomCallingConventionHandle = ctypes.POINTER(BNCustomCallingConvention)


class BNCustomDataRenderer(ctypes.Structure):
	pass


BNCustomDataRendererHandle = ctypes.POINTER(BNCustomDataRenderer)


class BNCustomFlowGraph(ctypes.Structure):
	pass


BNCustomFlowGraphHandle = ctypes.POINTER(BNCustomFlowGraph)


class BNCustomRelocationHandler(ctypes.Structure):
	pass


BNCustomRelocationHandlerHandle = ctypes.POINTER(BNCustomRelocationHandler)


class BNCustomTransform(ctypes.Structure):
	pass


BNCustomTransformHandle = ctypes.POINTER(BNCustomTransform)


class BNDataBuffer(ctypes.Structure):
	pass


BNDataBufferHandle = ctypes.POINTER(BNDataBuffer)


DataFlowQueryOptionEnum = ctypes.c_int
class BNDataRenderer(ctypes.Structure):
	pass


BNDataRendererHandle = ctypes.POINTER(BNDataRenderer)


class BNDataRendererContainer(ctypes.Structure):
	pass


BNDataRendererContainerHandle = ctypes.POINTER(BNDataRendererContainer)


class BNDataVariable(ctypes.Structure):
	pass


BNDataVariableHandle = ctypes.POINTER(BNDataVariable)


class BNDataVariableAndName(ctypes.Structure):
	@property
	def name(self):
		return pyNativeStr(self._name)
	@name.setter
	def name(self, value):
		self._name = cstr(value)


BNDataVariableAndNameHandle = ctypes.POINTER(BNDataVariableAndName)


class BNDataVariableAndNameAndDebugParser(ctypes.Structure):
	@property
	def name(self):
		return pyNativeStr(self._name)
	@name.setter
	def name(self, value):
		self._name = cstr(value)
	@property
	def parser(self):
		return pyNativeStr(self._parser)
	@parser.setter
	def parser(self, value):
		self._parser = cstr(value)


BNDataVariableAndNameAndDebugParserHandle = ctypes.POINTER(BNDataVariableAndNameAndDebugParser)


class BNDatabase(ctypes.Structure):
	pass


BNDatabaseHandle = ctypes.POINTER(BNDatabase)


DeadStoreEliminationEnum = ctypes.c_int
class BNDebugFunctionInfo(ctypes.Structure):
	@property
	def shortName(self):
		return pyNativeStr(self._shortName)
	@shortName.setter
	def shortName(self, value):
		self._shortName = cstr(value)
	@property
	def fullName(self):
		return pyNativeStr(self._fullName)
	@fullName.setter
	def fullName(self, value):
		self._fullName = cstr(value)
	@property
	def rawName(self):
		return pyNativeStr(self._rawName)
	@rawName.setter
	def rawName(self, value):
		self._rawName = cstr(value)


BNDebugFunctionInfoHandle = ctypes.POINTER(BNDebugFunctionInfo)


class BNDebugInfo(ctypes.Structure):
	pass


BNDebugInfoHandle = ctypes.POINTER(BNDebugInfo)


class BNDebugInfoParser(ctypes.Structure):
	pass


BNDebugInfoParserHandle = ctypes.POINTER(BNDebugInfoParser)


DisassemblyOptionEnum = ctypes.c_int
class BNDisassemblySettings(ctypes.Structure):
	pass


BNDisassemblySettingsHandle = ctypes.POINTER(BNDisassemblySettings)


class BNDisassemblyTextLine(ctypes.Structure):
	pass


BNDisassemblyTextLineHandle = ctypes.POINTER(BNDisassemblyTextLine)


class BNDisassemblyTextLineTypeInfo(ctypes.Structure):
	pass


BNDisassemblyTextLineTypeInfoHandle = ctypes.POINTER(BNDisassemblyTextLineTypeInfo)


class BNDisassemblyTextRenderer(ctypes.Structure):
	pass


BNDisassemblyTextRendererHandle = ctypes.POINTER(BNDisassemblyTextRenderer)


class BNDownloadInstance(ctypes.Structure):
	pass


BNDownloadInstanceHandle = ctypes.POINTER(BNDownloadInstance)


class BNDownloadInstanceCallbacks(ctypes.Structure):
	pass


BNDownloadInstanceCallbacksHandle = ctypes.POINTER(BNDownloadInstanceCallbacks)


class BNDownloadInstanceInputOutputCallbacks(ctypes.Structure):
	pass


BNDownloadInstanceInputOutputCallbacksHandle = ctypes.POINTER(BNDownloadInstanceInputOutputCallbacks)


class BNDownloadInstanceOutputCallbacks(ctypes.Structure):
	pass


BNDownloadInstanceOutputCallbacksHandle = ctypes.POINTER(BNDownloadInstanceOutputCallbacks)


class BNDownloadInstanceResponse(ctypes.Structure):
	pass


BNDownloadInstanceResponseHandle = ctypes.POINTER(BNDownloadInstanceResponse)


class BNDownloadProvider(ctypes.Structure):
	pass


BNDownloadProviderHandle = ctypes.POINTER(BNDownloadProvider)


class BNDownloadProviderCallbacks(ctypes.Structure):
	pass


BNDownloadProviderCallbacksHandle = ctypes.POINTER(BNDownloadProviderCallbacks)


EdgePenStyleEnum = ctypes.c_int
class BNEdgeStyle(ctypes.Structure):
	pass


BNEdgeStyleHandle = ctypes.POINTER(BNEdgeStyle)


EndiannessEnum = ctypes.c_int
class BNEnterpriseServerCallbacks(ctypes.Structure):
	pass


BNEnterpriseServerCallbacksHandle = ctypes.POINTER(BNEnterpriseServerCallbacks)


class BNEnumeration(ctypes.Structure):
	pass


BNEnumerationHandle = ctypes.POINTER(BNEnumeration)


class BNEnumerationBuilder(ctypes.Structure):
	pass


BNEnumerationBuilderHandle = ctypes.POINTER(BNEnumerationBuilder)


class BNEnumerationMember(ctypes.Structure):
	@property
	def name(self):
		return pyNativeStr(self._name)
	@name.setter
	def name(self, value):
		self._name = cstr(value)


BNEnumerationMemberHandle = ctypes.POINTER(BNEnumerationMember)


class BNFileAccessor(ctypes.Structure):
	pass


BNFileAccessorHandle = ctypes.POINTER(BNFileAccessor)


class BNFileMetadata(ctypes.Structure):
	pass


BNFileMetadataHandle = ctypes.POINTER(BNFileMetadata)


FindFlagEnum = ctypes.c_int
FindRangeTypeEnum = ctypes.c_int
FindTypeEnum = ctypes.c_int
class BNFlagConditionForSemanticClass(ctypes.Structure):
	pass


BNFlagConditionForSemanticClassHandle = ctypes.POINTER(BNFlagConditionForSemanticClass)


FlagRoleEnum = ctypes.c_int
class BNFlowGraph(ctypes.Structure):
	pass


BNFlowGraphHandle = ctypes.POINTER(BNFlowGraph)


class BNFlowGraphEdge(ctypes.Structure):
	pass


BNFlowGraphEdgeHandle = ctypes.POINTER(BNFlowGraphEdge)


class BNFlowGraphLayoutRequest(ctypes.Structure):
	pass


BNFlowGraphLayoutRequestHandle = ctypes.POINTER(BNFlowGraphLayoutRequest)


class BNFlowGraphNode(ctypes.Structure):
	pass


BNFlowGraphNodeHandle = ctypes.POINTER(BNFlowGraphNode)


FlowGraphOptionEnum = ctypes.c_int
class BNFormInputField(ctypes.Structure):
	@property
	def prompt(self):
		return pyNativeStr(self._prompt)
	@prompt.setter
	def prompt(self, value):
		self._prompt = cstr(value)
	@property
	def ext(self):
		return pyNativeStr(self._ext)
	@ext.setter
	def ext(self, value):
		self._ext = cstr(value)
	@property
	def defaultName(self):
		return pyNativeStr(self._defaultName)
	@defaultName.setter
	def defaultName(self, value):
		self._defaultName = cstr(value)
	@property
	def stringResult(self):
		return pyNativeStr(self._stringResult)
	@stringResult.setter
	def stringResult(self, value):
		self._stringResult = cstr(value)
	@property
	def stringDefault(self):
		return pyNativeStr(self._stringDefault)
	@stringDefault.setter
	def stringDefault(self, value):
		self._stringDefault = cstr(value)


BNFormInputFieldHandle = ctypes.POINTER(BNFormInputField)


FormInputFieldTypeEnum = ctypes.c_int
class BNFunction(ctypes.Structure):
	pass


BNFunctionHandle = ctypes.POINTER(BNFunction)


FunctionAnalysisSkipOverrideEnum = ctypes.c_int
FunctionGraphTypeEnum = ctypes.c_int
class BNFunctionParameter(ctypes.Structure):
	@property
	def name(self):
		return pyNativeStr(self._name)
	@name.setter
	def name(self, value):
		self._name = cstr(value)


BNFunctionParameterHandle = ctypes.POINTER(BNFunctionParameter)


class BNFunctionRecognizer(ctypes.Structure):
	pass


BNFunctionRecognizerHandle = ctypes.POINTER(BNFunctionRecognizer)


FunctionUpdateTypeEnum = ctypes.c_int
class BNHighLevelILFunction(ctypes.Structure):
	pass


BNHighLevelILFunctionHandle = ctypes.POINTER(BNHighLevelILFunction)


class BNHighLevelILInstruction(ctypes.Structure):
	pass


BNHighLevelILInstructionHandle = ctypes.POINTER(BNHighLevelILInstruction)


HighLevelILOperationEnum = ctypes.c_int
class BNHighlightColor(ctypes.Structure):
	pass


BNHighlightColorHandle = ctypes.POINTER(BNHighlightColor)


HighlightColorStyleEnum = ctypes.c_int
HighlightStandardColorEnum = ctypes.c_int
ILBranchDependenceEnum = ctypes.c_int
class BNILBranchInstructionAndDependence(ctypes.Structure):
	pass


BNILBranchInstructionAndDependenceHandle = ctypes.POINTER(BNILBranchInstructionAndDependence)


class BNILReferenceSource(ctypes.Structure):
	pass


BNILReferenceSourceHandle = ctypes.POINTER(BNILReferenceSource)


ImplicitRegisterExtendEnum = ctypes.c_int
class BNIndirectBranchInfo(ctypes.Structure):
	pass


BNIndirectBranchInfoHandle = ctypes.POINTER(BNIndirectBranchInfo)


class BNInstructionInfo(ctypes.Structure):
	pass


BNInstructionInfoHandle = ctypes.POINTER(BNInstructionInfo)


class BNInstructionTextLine(ctypes.Structure):
	pass


BNInstructionTextLineHandle = ctypes.POINTER(BNInstructionTextLine)


class BNInstructionTextToken(ctypes.Structure):
	@property
	def text(self):
		return pyNativeStr(self._text)
	@text.setter
	def text(self, value):
		self._text = cstr(value)


BNInstructionTextTokenHandle = ctypes.POINTER(BNInstructionTextToken)


InstructionTextTokenContextEnum = ctypes.c_int
InstructionTextTokenTypeEnum = ctypes.c_int
IntegerDisplayTypeEnum = ctypes.c_int
class BNInteractionHandlerCallbacks(ctypes.Structure):
	pass


BNInteractionHandlerCallbacksHandle = ctypes.POINTER(BNInteractionHandlerCallbacks)


class BNKeyValueStore(ctypes.Structure):
	pass


BNKeyValueStoreHandle = ctypes.POINTER(BNKeyValueStore)


class BNLanguageRepresentationFunction(ctypes.Structure):
	pass


BNLanguageRepresentationFunctionHandle = ctypes.POINTER(BNLanguageRepresentationFunction)


class BNLinearDisassemblyLine(ctypes.Structure):
	pass


BNLinearDisassemblyLineHandle = ctypes.POINTER(BNLinearDisassemblyLine)


LinearDisassemblyLineTypeEnum = ctypes.c_int
class BNLinearViewCursor(ctypes.Structure):
	pass


BNLinearViewCursorHandle = ctypes.POINTER(BNLinearViewCursor)


class BNLinearViewObject(ctypes.Structure):
	pass


BNLinearViewObjectHandle = ctypes.POINTER(BNLinearViewObject)


class BNLinearViewObjectIdentifier(ctypes.Structure):
	@property
	def name(self):
		return pyNativeStr(self._name)
	@name.setter
	def name(self, value):
		self._name = cstr(value)


BNLinearViewObjectIdentifierHandle = ctypes.POINTER(BNLinearViewObjectIdentifier)


LinearViewObjectIdentifierTypeEnum = ctypes.c_int
LogLevelEnum = ctypes.c_int
class BNLogListener(ctypes.Structure):
	pass


BNLogListenerHandle = ctypes.POINTER(BNLogListener)


class BNLogger(ctypes.Structure):
	pass


BNLoggerHandle = ctypes.POINTER(BNLogger)


class BNLookupTableEntry(ctypes.Structure):
	pass


BNLookupTableEntryHandle = ctypes.POINTER(BNLookupTableEntry)


LowLevelILFlagConditionEnum = ctypes.c_int
class BNLowLevelILFunction(ctypes.Structure):
	pass


BNLowLevelILFunctionHandle = ctypes.POINTER(BNLowLevelILFunction)


class BNLowLevelILInstruction(ctypes.Structure):
	pass


BNLowLevelILInstructionHandle = ctypes.POINTER(BNLowLevelILInstruction)


class BNLowLevelILLabel(ctypes.Structure):
	pass


BNLowLevelILLabelHandle = ctypes.POINTER(BNLowLevelILLabel)


LowLevelILOperationEnum = ctypes.c_int
class BNMainThreadAction(ctypes.Structure):
	pass


BNMainThreadActionHandle = ctypes.POINTER(BNMainThreadAction)


class BNMainThreadCallbacks(ctypes.Structure):
	pass


BNMainThreadCallbacksHandle = ctypes.POINTER(BNMainThreadCallbacks)


class BNMediumLevelILFunction(ctypes.Structure):
	pass


BNMediumLevelILFunctionHandle = ctypes.POINTER(BNMediumLevelILFunction)


class BNMediumLevelILInstruction(ctypes.Structure):
	pass


BNMediumLevelILInstructionHandle = ctypes.POINTER(BNMediumLevelILInstruction)


class BNMediumLevelILLabel(ctypes.Structure):
	pass


BNMediumLevelILLabelHandle = ctypes.POINTER(BNMediumLevelILLabel)


MediumLevelILOperationEnum = ctypes.c_int
MemberAccessEnum = ctypes.c_int
MemberScopeEnum = ctypes.c_int
class BNMemoryUsageInfo(ctypes.Structure):
	@property
	def name(self):
		return pyNativeStr(self._name)
	@name.setter
	def name(self, value):
		self._name = cstr(value)


BNMemoryUsageInfoHandle = ctypes.POINTER(BNMemoryUsageInfo)


class BNMergeResult(ctypes.Structure):
	@property
	def hash(self):
		return pyNativeStr(self._hash)
	@hash.setter
	def hash(self, value):
		self._hash = cstr(value)


BNMergeResultHandle = ctypes.POINTER(BNMergeResult)


MergeStatusEnum = ctypes.c_int
class BNMergedVariable(ctypes.Structure):
	pass


BNMergedVariableHandle = ctypes.POINTER(BNMergedVariable)


MessageBoxButtonResultEnum = ctypes.c_int
MessageBoxButtonSetEnum = ctypes.c_int
MessageBoxIconEnum = ctypes.c_int
class BNMetadata(ctypes.Structure):
	pass


BNMetadataHandle = ctypes.POINTER(BNMetadata)


MetadataTypeEnum = ctypes.c_int
class BNMetadataValueStore(ctypes.Structure):
	pass


BNMetadataValueStoreHandle = ctypes.POINTER(BNMetadataValueStore)


ModificationStatusEnum = ctypes.c_int
class BNNameAndType(ctypes.Structure):
	@property
	def name(self):
		return pyNativeStr(self._name)
	@name.setter
	def name(self, value):
		self._name = cstr(value)


BNNameAndTypeHandle = ctypes.POINTER(BNNameAndType)


class BNNameList(ctypes.Structure):
	@property
	def join(self):
		return pyNativeStr(self._join)
	@join.setter
	def join(self, value):
		self._join = cstr(value)


BNNameListHandle = ctypes.POINTER(BNNameList)


class BNNameSpace(ctypes.Structure):
	@property
	def join(self):
		return pyNativeStr(self._join)
	@join.setter
	def join(self, value):
		self._join = cstr(value)


BNNameSpaceHandle = ctypes.POINTER(BNNameSpace)


NameTypeEnum = ctypes.c_int
class BNNamedTypeReference(ctypes.Structure):
	pass


BNNamedTypeReferenceHandle = ctypes.POINTER(BNNamedTypeReference)


class BNNamedTypeReferenceBuilder(ctypes.Structure):
	pass


BNNamedTypeReferenceBuilderHandle = ctypes.POINTER(BNNamedTypeReferenceBuilder)


NamedTypeReferenceClassEnum = ctypes.c_int
class BNNavigationHandler(ctypes.Structure):
	pass


BNNavigationHandlerHandle = ctypes.POINTER(BNNavigationHandler)


class BNObjectDestructionCallbacks(ctypes.Structure):
	pass


BNObjectDestructionCallbacksHandle = ctypes.POINTER(BNObjectDestructionCallbacks)


class BNOffsetWithConfidence(ctypes.Structure):
	pass


BNOffsetWithConfidenceHandle = ctypes.POINTER(BNOffsetWithConfidence)


class BNParameterVariablesWithConfidence(ctypes.Structure):
	pass


BNParameterVariablesWithConfidenceHandle = ctypes.POINTER(BNParameterVariablesWithConfidence)


class BNParsedType(ctypes.Structure):
	pass


BNParsedTypeHandle = ctypes.POINTER(BNParsedType)


class BNPerformanceInfo(ctypes.Structure):
	@property
	def name(self):
		return pyNativeStr(self._name)
	@name.setter
	def name(self, value):
		self._name = cstr(value)


BNPerformanceInfoHandle = ctypes.POINTER(BNPerformanceInfo)


class BNPlatform(ctypes.Structure):
	pass


BNPlatformHandle = ctypes.POINTER(BNPlatform)


class BNPluginCommand(ctypes.Structure):
	@property
	def name(self):
		return pyNativeStr(self._name)
	@name.setter
	def name(self, value):
		self._name = cstr(value)
	@property
	def description(self):
		return pyNativeStr(self._description)
	@description.setter
	def description(self, value):
		self._description = cstr(value)


BNPluginCommandHandle = ctypes.POINTER(BNPluginCommand)


PluginCommandTypeEnum = ctypes.c_int
PluginLoadOrderEnum = ctypes.c_int
PluginOriginEnum = ctypes.c_int
PluginStatusEnum = ctypes.c_int
PluginTypeEnum = ctypes.c_int
class BNPoint(ctypes.Structure):
	pass


BNPointHandle = ctypes.POINTER(BNPoint)


PointerSuffixEnum = ctypes.c_int
class BNPossibleValueSet(ctypes.Structure):
	pass


BNPossibleValueSetHandle = ctypes.POINTER(BNPossibleValueSet)


class BNQualifiedName(ctypes.Structure):
	@property
	def join(self):
		return pyNativeStr(self._join)
	@join.setter
	def join(self, value):
		self._join = cstr(value)


BNQualifiedNameHandle = ctypes.POINTER(BNQualifiedName)


class BNQualifiedNameAndType(ctypes.Structure):
	pass


BNQualifiedNameAndTypeHandle = ctypes.POINTER(BNQualifiedNameAndType)


class BNQualifiedNameList(ctypes.Structure):
	pass


BNQualifiedNameListHandle = ctypes.POINTER(BNQualifiedNameList)


class BNQualifiedNameTypeAndId(ctypes.Structure):
	@property
	def id(self):
		return pyNativeStr(self._id)
	@id.setter
	def id(self, value):
		self._id = cstr(value)


BNQualifiedNameTypeAndIdHandle = ctypes.POINTER(BNQualifiedNameTypeAndId)


class BNRange(ctypes.Structure):
	pass


BNRangeHandle = ctypes.POINTER(BNRange)


class BNReferenceSource(ctypes.Structure):
	pass


BNReferenceSourceHandle = ctypes.POINTER(BNReferenceSource)


ReferenceTypeEnum = ctypes.c_int
class BNRegisterInfo(ctypes.Structure):
	pass


BNRegisterInfoHandle = ctypes.POINTER(BNRegisterInfo)


class BNRegisterOrConstant(ctypes.Structure):
	pass


BNRegisterOrConstantHandle = ctypes.POINTER(BNRegisterOrConstant)


class BNRegisterSetWithConfidence(ctypes.Structure):
	pass


BNRegisterSetWithConfidenceHandle = ctypes.POINTER(BNRegisterSetWithConfidence)


class BNRegisterStackAdjustment(ctypes.Structure):
	pass


BNRegisterStackAdjustmentHandle = ctypes.POINTER(BNRegisterStackAdjustment)


class BNRegisterStackInfo(ctypes.Structure):
	pass


BNRegisterStackInfoHandle = ctypes.POINTER(BNRegisterStackInfo)


class BNRegisterValue(ctypes.Structure):
	pass


BNRegisterValueHandle = ctypes.POINTER(BNRegisterValue)


RegisterValueTypeEnum = ctypes.c_int
class BNRegisterValueWithConfidence(ctypes.Structure):
	pass


BNRegisterValueWithConfidenceHandle = ctypes.POINTER(BNRegisterValueWithConfidence)


class BNRelocation(ctypes.Structure):
	pass


BNRelocationHandle = ctypes.POINTER(BNRelocation)


class BNRelocationHandler(ctypes.Structure):
	pass


BNRelocationHandlerHandle = ctypes.POINTER(BNRelocationHandler)


class BNRelocationInfo(ctypes.Structure):
	pass


BNRelocationInfoHandle = ctypes.POINTER(BNRelocationInfo)


RelocationTypeEnum = ctypes.c_int
class BNRepoPlugin(ctypes.Structure):
	pass


BNRepoPluginHandle = ctypes.POINTER(BNRepoPlugin)


class BNReportCollection(ctypes.Structure):
	pass


BNReportCollectionHandle = ctypes.POINTER(BNReportCollection)


ReportTypeEnum = ctypes.c_int
class BNRepository(ctypes.Structure):
	pass


BNRepositoryHandle = ctypes.POINTER(BNRepository)


class BNRepositoryManager(ctypes.Structure):
	pass


BNRepositoryManagerHandle = ctypes.POINTER(BNRepositoryManager)


SaveOptionEnum = ctypes.c_int
class BNSaveSettings(ctypes.Structure):
	pass


BNSaveSettingsHandle = ctypes.POINTER(BNSaveSettings)


class BNScriptingInstance(ctypes.Structure):
	pass


BNScriptingInstanceHandle = ctypes.POINTER(BNScriptingInstance)


class BNScriptingInstanceCallbacks(ctypes.Structure):
	pass


BNScriptingInstanceCallbacksHandle = ctypes.POINTER(BNScriptingInstanceCallbacks)


class BNScriptingOutputListener(ctypes.Structure):
	pass


BNScriptingOutputListenerHandle = ctypes.POINTER(BNScriptingOutputListener)


class BNScriptingProvider(ctypes.Structure):
	pass


BNScriptingProviderHandle = ctypes.POINTER(BNScriptingProvider)


class BNScriptingProviderCallbacks(ctypes.Structure):
	pass


BNScriptingProviderCallbacksHandle = ctypes.POINTER(BNScriptingProviderCallbacks)


ScriptingProviderExecuteResultEnum = ctypes.c_int
ScriptingProviderInputReadyStateEnum = ctypes.c_int
class BNSecretsProvider(ctypes.Structure):
	pass


BNSecretsProviderHandle = ctypes.POINTER(BNSecretsProvider)


class BNSecretsProviderCallbacks(ctypes.Structure):
	pass


BNSecretsProviderCallbacksHandle = ctypes.POINTER(BNSecretsProviderCallbacks)


class BNSection(ctypes.Structure):
	pass


BNSectionHandle = ctypes.POINTER(BNSection)


SectionSemanticsEnum = ctypes.c_int
class BNSegment(ctypes.Structure):
	pass


BNSegmentHandle = ctypes.POINTER(BNSegment)


SegmentFlagEnum = ctypes.c_int
class BNSettings(ctypes.Structure):
	pass


BNSettingsHandle = ctypes.POINTER(BNSettings)


SettingsScopeEnum = ctypes.c_int
class BNSnapshot(ctypes.Structure):
	pass


BNSnapshotHandle = ctypes.POINTER(BNSnapshot)


class BNStackVariableReference(ctypes.Structure):
	@property
	def name(self):
		return pyNativeStr(self._name)
	@name.setter
	def name(self, value):
		self._name = cstr(value)


BNStackVariableReferenceHandle = ctypes.POINTER(BNStackVariableReference)


class BNStringReference(ctypes.Structure):
	pass


BNStringReferenceHandle = ctypes.POINTER(BNStringReference)


StringTypeEnum = ctypes.c_int
class BNStructure(ctypes.Structure):
	pass


BNStructureHandle = ctypes.POINTER(BNStructure)


class BNStructureBuilder(ctypes.Structure):
	pass


BNStructureBuilderHandle = ctypes.POINTER(BNStructureBuilder)


class BNStructureMember(ctypes.Structure):
	@property
	def name(self):
		return pyNativeStr(self._name)
	@name.setter
	def name(self, value):
		self._name = cstr(value)


BNStructureMemberHandle = ctypes.POINTER(BNStructureMember)


StructureVariantEnum = ctypes.c_int
class BNSymbol(ctypes.Structure):
	pass


BNSymbolHandle = ctypes.POINTER(BNSymbol)


SymbolBindingEnum = ctypes.c_int
SymbolTypeEnum = ctypes.c_int
class BNSystemCallInfo(ctypes.Structure):
	pass


BNSystemCallInfoHandle = ctypes.POINTER(BNSystemCallInfo)


class BNTag(ctypes.Structure):
	pass


BNTagHandle = ctypes.POINTER(BNTag)


class BNTagReference(ctypes.Structure):
	pass


BNTagReferenceHandle = ctypes.POINTER(BNTagReference)


TagReferenceTypeEnum = ctypes.c_int
class BNTagType(ctypes.Structure):
	pass


BNTagTypeHandle = ctypes.POINTER(BNTagType)


TagTypeTypeEnum = ctypes.c_int
class BNTemporaryFile(ctypes.Structure):
	pass


BNTemporaryFileHandle = ctypes.POINTER(BNTemporaryFile)


ThemeColorEnum = ctypes.c_int
TokenEscapingTypeEnum = ctypes.c_int
class BNTransform(ctypes.Structure):
	pass


BNTransformHandle = ctypes.POINTER(BNTransform)


class BNTransformParameter(ctypes.Structure):
	@property
	def name(self):
		return pyNativeStr(self._name)
	@name.setter
	def name(self, value):
		self._name = cstr(value)


BNTransformParameterHandle = ctypes.POINTER(BNTransformParameter)


class BNTransformParameterInfo(ctypes.Structure):
	@property
	def name(self):
		return pyNativeStr(self._name)
	@name.setter
	def name(self, value):
		self._name = cstr(value)
	@property
	def longName(self):
		return pyNativeStr(self._longName)
	@longName.setter
	def longName(self, value):
		self._longName = cstr(value)


BNTransformParameterInfoHandle = ctypes.POINTER(BNTransformParameterInfo)


TransformTypeEnum = ctypes.c_int
class BNType(ctypes.Structure):
	pass


BNTypeHandle = ctypes.POINTER(BNType)


class BNTypeBuilder(ctypes.Structure):
	pass


BNTypeBuilderHandle = ctypes.POINTER(BNTypeBuilder)


TypeClassEnum = ctypes.c_int
class BNTypeContext(ctypes.Structure):
	pass


BNTypeContextHandle = ctypes.POINTER(BNTypeContext)


class BNTypeDefinitionLine(ctypes.Structure):
	@property
	def rootTypeName(self):
		return pyNativeStr(self._rootTypeName)
	@rootTypeName.setter
	def rootTypeName(self, value):
		self._rootTypeName = cstr(value)


BNTypeDefinitionLineHandle = ctypes.POINTER(BNTypeDefinitionLine)


TypeDefinitionLineTypeEnum = ctypes.c_int
class BNTypeField(ctypes.Structure):
	pass


BNTypeFieldHandle = ctypes.POINTER(BNTypeField)


class BNTypeFieldReference(ctypes.Structure):
	pass


BNTypeFieldReferenceHandle = ctypes.POINTER(BNTypeFieldReference)


class BNTypeFieldReferenceSizeInfo(ctypes.Structure):
	pass


BNTypeFieldReferenceSizeInfoHandle = ctypes.POINTER(BNTypeFieldReferenceSizeInfo)


class BNTypeFieldReferenceTypeInfo(ctypes.Structure):
	pass


BNTypeFieldReferenceTypeInfoHandle = ctypes.POINTER(BNTypeFieldReferenceTypeInfo)


class BNTypeLibrary(ctypes.Structure):
	pass


BNTypeLibraryHandle = ctypes.POINTER(BNTypeLibrary)


class BNTypeLibraryMapping(ctypes.Structure):
	pass


BNTypeLibraryMappingHandle = ctypes.POINTER(BNTypeLibraryMapping)


class BNTypeParser(ctypes.Structure):
	pass


BNTypeParserHandle = ctypes.POINTER(BNTypeParser)


class BNTypeParserCallbacks(ctypes.Structure):
	pass


BNTypeParserCallbacksHandle = ctypes.POINTER(BNTypeParserCallbacks)


class BNTypeParserError(ctypes.Structure):
	@property
	def message(self):
		return pyNativeStr(self._message)
	@message.setter
	def message(self, value):
		self._message = cstr(value)
	@property
	def fileName(self):
		return pyNativeStr(self._fileName)
	@fileName.setter
	def fileName(self, value):
		self._fileName = cstr(value)


BNTypeParserErrorHandle = ctypes.POINTER(BNTypeParserError)


TypeParserErrorSeverityEnum = ctypes.c_int
TypeParserOptionEnum = ctypes.c_int
class BNTypeParserResult(ctypes.Structure):
	pass


BNTypeParserResultHandle = ctypes.POINTER(BNTypeParserResult)


class BNTypePrinter(ctypes.Structure):
	pass


BNTypePrinterHandle = ctypes.POINTER(BNTypePrinter)


class BNTypePrinterCallbacks(ctypes.Structure):
	pass


BNTypePrinterCallbacksHandle = ctypes.POINTER(BNTypePrinterCallbacks)


class BNTypeReferenceSource(ctypes.Structure):
	pass


BNTypeReferenceSourceHandle = ctypes.POINTER(BNTypeReferenceSource)


TypeReferenceTypeEnum = ctypes.c_int
class BNTypeWithConfidence(ctypes.Structure):
	pass


BNTypeWithConfidenceHandle = ctypes.POINTER(BNTypeWithConfidence)


class BNUndoAction(ctypes.Structure):
	@property
	def summaryText(self):
		return pyNativeStr(self._summaryText)
	@summaryText.setter
	def summaryText(self, value):
		self._summaryText = cstr(value)


BNUndoActionHandle = ctypes.POINTER(BNUndoAction)


class BNUndoEntry(ctypes.Structure):
	@property
	def hash(self):
		return pyNativeStr(self._hash)
	@hash.setter
	def hash(self, value):
		self._hash = cstr(value)


BNUndoEntryHandle = ctypes.POINTER(BNUndoEntry)


class BNUpdateChannel(ctypes.Structure):
	@property
	def name(self):
		return pyNativeStr(self._name)
	@name.setter
	def name(self, value):
		self._name = cstr(value)
	@property
	def description(self):
		return pyNativeStr(self._description)
	@description.setter
	def description(self, value):
		self._description = cstr(value)
	@property
	def latestVersion(self):
		return pyNativeStr(self._latestVersion)
	@latestVersion.setter
	def latestVersion(self, value):
		self._latestVersion = cstr(value)


BNUpdateChannelHandle = ctypes.POINTER(BNUpdateChannel)


UpdateResultEnum = ctypes.c_int
class BNUpdateVersion(ctypes.Structure):
	@property
	def version(self):
		return pyNativeStr(self._version)
	@version.setter
	def version(self, value):
		self._version = cstr(value)
	@property
	def notes(self):
		return pyNativeStr(self._notes)
	@notes.setter
	def notes(self, value):
		self._notes = cstr(value)


BNUpdateVersionHandle = ctypes.POINTER(BNUpdateVersion)


class BNUser(ctypes.Structure):
	pass


BNUserHandle = ctypes.POINTER(BNUser)


class BNUserVariableValue(ctypes.Structure):
	pass


BNUserVariableValueHandle = ctypes.POINTER(BNUserVariableValue)


class BNValueRange(ctypes.Structure):
	pass


BNValueRangeHandle = ctypes.POINTER(BNValueRange)


class BNVariable(ctypes.Structure):
	pass


BNVariableHandle = ctypes.POINTER(BNVariable)


class BNVariableNameAndType(ctypes.Structure):
	@property
	def name(self):
		return pyNativeStr(self._name)
	@name.setter
	def name(self, value):
		self._name = cstr(value)


BNVariableNameAndTypeHandle = ctypes.POINTER(BNVariableNameAndType)


class BNVariableReferenceSource(ctypes.Structure):
	pass


BNVariableReferenceSourceHandle = ctypes.POINTER(BNVariableReferenceSource)


VariableSourceTypeEnum = ctypes.c_int
class BNVersionInfo(ctypes.Structure):
	@property
	def channel(self):
		return pyNativeStr(self._channel)
	@channel.setter
	def channel(self, value):
		self._channel = cstr(value)


BNVersionInfoHandle = ctypes.POINTER(BNVersionInfo)


class BNWebsocketClient(ctypes.Structure):
	pass


BNWebsocketClientHandle = ctypes.POINTER(BNWebsocketClient)


class BNWebsocketClientCallbacks(ctypes.Structure):
	pass


BNWebsocketClientCallbacksHandle = ctypes.POINTER(BNWebsocketClientCallbacks)


class BNWebsocketClientOutputCallbacks(ctypes.Structure):
	pass


BNWebsocketClientOutputCallbacksHandle = ctypes.POINTER(BNWebsocketClientOutputCallbacks)


class BNWebsocketProvider(ctypes.Structure):
	pass


BNWebsocketProviderHandle = ctypes.POINTER(BNWebsocketProvider)


class BNWebsocketProviderCallbacks(ctypes.Structure):
	pass


BNWebsocketProviderCallbacksHandle = ctypes.POINTER(BNWebsocketProviderCallbacks)


class BNWorkflow(ctypes.Structure):
	pass


BNWorkflowHandle = ctypes.POINTER(BNWorkflow)


WorkflowStateEnum = ctypes.c_int
PluginLoadStatusEnum = ctypes.c_int

# Structure definitions
BNActiveAnalysisInfo._fields_ = [
		("func", ctypes.POINTER(BNFunction)),
		("analysisTime", ctypes.c_ulonglong),
		("updateCount", ctypes.c_ulonglong),
		("submitCount", ctypes.c_ulonglong),
	]
BNAddressRange._fields_ = [
		("start", ctypes.c_ulonglong),
		("end", ctypes.c_ulonglong),
	]
BNAnalysisInfo._fields_ = [
		("state", AnalysisStateEnum),
		("analysisTime", ctypes.c_ulonglong),
		("activeInfo", ctypes.POINTER(BNActiveAnalysisInfo)),
		("count", ctypes.c_ulonglong),
	]
BNAnalysisParameters._fields_ = [
		("maxAnalysisTime", ctypes.c_ulonglong),
		("maxFunctionSize", ctypes.c_ulonglong),
		("maxFunctionAnalysisTime", ctypes.c_ulonglong),
		("maxFunctionUpdateCount", ctypes.c_ulonglong),
		("maxFunctionSubmitCount", ctypes.c_ulonglong),
		("suppressNewAutoFunctionAnalysis", ctypes.c_bool),
		("mode", AnalysisModeEnum),
		("alwaysAnalyzeIndirectBranches", ctypes.c_bool),
		("advancedAnalysisCacheSize", ctypes.c_ulonglong),
	]
BNAnalysisProgress._fields_ = [
		("state", AnalysisStateEnum),
		("count", ctypes.c_ulonglong),
		("total", ctypes.c_ulonglong),
	]
BNArchitectureAndAddress._fields_ = [
		("arch", ctypes.POINTER(BNArchitecture)),
		("address", ctypes.c_ulonglong),
	]
BNBasicBlockEdge._fields_ = [
		("type", BranchTypeEnum),
		("target", ctypes.POINTER(BNBasicBlock)),
		("backEdge", ctypes.c_bool),
		("fallThrough", ctypes.c_bool),
	]
BNBinaryDataNotification._fields_ = [
		("context", ctypes.c_void_p),
		("dataWritten", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong, ctypes.c_ulonglong)),
		("dataInserted", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong, ctypes.c_ulonglong)),
		("dataRemoved", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong, ctypes.c_ulonglong)),
		("functionAdded", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNFunction))),
		("functionRemoved", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNFunction))),
		("functionUpdated", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNFunction))),
		("functionUpdateRequested", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNFunction))),
		("dataVariableAdded", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNDataVariable))),
		("dataVariableRemoved", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNDataVariable))),
		("dataVariableUpdated", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNDataVariable))),
		("dataMetadataUpdated", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong)),
		("tagTypeUpdated", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNTagType))),
		("tagAdded", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNTagReference))),
		("tagUpdated", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNTagReference))),
		("tagRemoved", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNTagReference))),
		("symbolAdded", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNSymbol))),
		("symbolUpdated", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNSymbol))),
		("symbolRemoved", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNSymbol))),
		("stringFound", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), StringTypeEnum, ctypes.c_ulonglong, ctypes.c_ulonglong)),
		("stringRemoved", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), StringTypeEnum, ctypes.c_ulonglong, ctypes.c_ulonglong)),
		("typeDefined", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNQualifiedName), ctypes.POINTER(BNType))),
		("typeUndefined", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNQualifiedName), ctypes.POINTER(BNType))),
		("typeReferenceChanged", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNQualifiedName), ctypes.POINTER(BNType))),
		("typeFieldReferenceChanged", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNQualifiedName), ctypes.c_ulonglong)),
		("segmentAdded", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNSegment))),
		("segmentUpdated", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNSegment))),
		("segmentRemoved", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNSegment))),
		("sectionAdded", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNSection))),
		("sectionUpdated", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNSection))),
		("sectionRemoved", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNSection))),
		("componentNameUpdated", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_char_p, ctypes.POINTER(BNComponent))),
		("componentAdded", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNComponent))),
		("componentMoved", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNComponent), ctypes.POINTER(BNComponent), ctypes.POINTER(BNComponent))),
		("componentRemoved", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNComponent), ctypes.POINTER(BNComponent))),
		("componentFunctionAdded", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNComponent), ctypes.POINTER(BNFunction))),
		("componentFunctionRemoved", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNComponent), ctypes.POINTER(BNFunction))),
	]
BNBinaryViewEvent._fields_ = [
		("type", BinaryViewEventTypeEnum),
		("callback", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView))),
		("ctx", ctypes.c_void_p),
	]
BNBoolWithConfidence._fields_ = [
		("value", ctypes.c_bool),
		("confidence", ctypes.c_ubyte),
	]
BNCallingConventionWithConfidence._fields_ = [
		("convention", ctypes.POINTER(BNCallingConvention)),
		("confidence", ctypes.c_ubyte),
	]
BNConstantReference._fields_ = [
		("value", ctypes.c_longlong),
		("size", ctypes.c_ulonglong),
		("pointer", ctypes.c_bool),
		("intermediate", ctypes.c_bool),
	]
BNCustomArchitecture._fields_ = [
		("context", ctypes.c_void_p),
		("init", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNArchitecture))),
		("getEndianness", ctypes.CFUNCTYPE(EndiannessEnum, ctypes.c_void_p)),
		("getAddressSize", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p)),
		("getDefaultIntegerSize", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p)),
		("getInstructionAlignment", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p)),
		("getMaxInstructionLength", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p)),
		("getOpcodeDisplayLength", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p)),
		("getAssociatedArchitectureByAddress", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
		("getInstructionInfo", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_ulonglong, ctypes.POINTER(BNInstructionInfo))),
		("getInstructionText", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.POINTER(ctypes.c_ulonglong), ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)), ctypes.POINTER(ctypes.c_ulonglong))),
		("freeInstructionText", ctypes.CFUNCTYPE(None, ctypes.POINTER(BNInstructionTextToken), ctypes.c_ulonglong)),
		("getInstructionLowLevelIL", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.POINTER(ctypes.c_ulonglong), ctypes.POINTER(BNLowLevelILFunction))),
		("getRegisterName", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint)),
		("getFlagName", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint)),
		("getFlagWriteTypeName", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint)),
		("getSemanticFlagClassName", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint)),
		("getSemanticFlagGroupName", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint)),
		("getFullWidthRegisters", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
		("getAllRegisters", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
		("getAllFlags", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
		("getAllFlagWriteTypes", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
		("getAllSemanticFlagClasses", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
		("getAllSemanticFlagGroups", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
		("getFlagRole", ctypes.CFUNCTYPE(FlagRoleEnum, ctypes.c_void_p, ctypes.c_uint, ctypes.c_uint)),
		("getFlagsRequiredForFlagCondition", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, LowLevelILFlagConditionEnum, ctypes.c_uint, ctypes.POINTER(ctypes.c_ulonglong))),
		("getFlagsRequiredForSemanticFlagGroup", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint, ctypes.POINTER(ctypes.c_ulonglong))),
		("getFlagConditionsForSemanticFlagGroup", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint, ctypes.POINTER(ctypes.c_ulonglong))),
		("freeFlagConditionsForSemanticFlagGroup", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNFlagConditionForSemanticClass))),
		("getFlagsWrittenByFlagWriteType", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint, ctypes.POINTER(ctypes.c_ulonglong))),
		("getSemanticClassForFlagWriteType", ctypes.CFUNCTYPE(ctypes.c_uint, ctypes.c_void_p, ctypes.c_uint)),
		("getFlagWriteLowLevelIL", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p, LowLevelILOperationEnum, ctypes.c_ulonglong, ctypes.c_uint, ctypes.c_uint, ctypes.POINTER(BNRegisterOrConstant), ctypes.c_ulonglong, ctypes.POINTER(BNLowLevelILFunction))),
		("getFlagConditionLowLevelIL", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p, LowLevelILFlagConditionEnum, ctypes.c_uint, ctypes.POINTER(BNLowLevelILFunction))),
		("getSemanticFlagGroupLowLevelIL", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p, ctypes.c_uint, ctypes.POINTER(BNLowLevelILFunction))),
		("freeRegisterList", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(ctypes.c_uint))),
		("getRegisterInfo", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_uint, ctypes.POINTER(BNRegisterInfo))),
		("getStackPointerRegister", ctypes.CFUNCTYPE(ctypes.c_uint, ctypes.c_void_p)),
		("getLinkRegister", ctypes.CFUNCTYPE(ctypes.c_uint, ctypes.c_void_p)),
		("getGlobalRegisters", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
		("getSystemRegisters", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
		("getRegisterStackName", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint)),
		("getAllRegisterStacks", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
		("getRegisterStackInfo", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_uint, ctypes.POINTER(BNRegisterStackInfo))),
		("getIntrinsicName", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint)),
		("getAllIntrinsics", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
		("getIntrinsicInputs", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint, ctypes.POINTER(ctypes.c_ulonglong))),
		("freeNameAndTypeList", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNNameAndType), ctypes.c_ulonglong)),
		("getIntrinsicOutputs", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint, ctypes.POINTER(ctypes.c_ulonglong))),
		("freeTypeList", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNTypeWithConfidence), ctypes.c_ulonglong)),
		("canAssemble", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p)),
		("assemble", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_char_p, ctypes.c_ulonglong, ctypes.POINTER(BNDataBuffer), ctypes.POINTER(ctypes.c_char_p))),
		("isNeverBranchPatchAvailable", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_ulonglong)),
		("isAlwaysBranchPatchAvailable", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_ulonglong)),
		("isInvertBranchPatchAvailable", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_ulonglong)),
		("isSkipAndReturnZeroPatchAvailable", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_ulonglong)),
		("isSkipAndReturnValuePatchAvailable", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_ulonglong)),
		("convertToNop", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_ulonglong)),
		("alwaysBranch", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_ulonglong)),
		("invertBranch", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_ulonglong)),
		("skipAndReturnValue", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_ulonglong, ctypes.c_ulonglong)),
	]
BNCustomBinaryView._fields_ = [
		("context", ctypes.c_void_p),
		("init", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p)),
		("freeObject", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
		("externalRefTaken", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
		("externalRefReleased", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
		("read", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)),
		("write", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_void_p, ctypes.c_ulonglong)),
		("insert", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_void_p, ctypes.c_ulonglong)),
		("remove", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)),
		("getModification", ctypes.CFUNCTYPE(ModificationStatusEnum, ctypes.c_void_p, ctypes.c_ulonglong)),
		("isValidOffset", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong)),
		("isOffsetReadable", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong)),
		("isOffsetWritable", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong)),
		("isOffsetExecutable", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong)),
		("isOffsetBackedByFile", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong)),
		("getNextValidOffset", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p, ctypes.c_ulonglong)),
		("getStart", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p)),
		("getLength", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p)),
		("getEntryPoint", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p)),
		("isExecutable", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p)),
		("getDefaultEndianness", ctypes.CFUNCTYPE(EndiannessEnum, ctypes.c_void_p)),
		("isRelocatable", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p)),
		("getAddressSize", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p)),
		("save", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNFileAccessor))),
	]
BNCustomBinaryViewType._fields_ = [
		("context", ctypes.c_void_p),
		("create", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(BNBinaryView))),
		("parse", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(BNBinaryView))),
		("isValidForData", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView))),
		("isDeprecated", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p)),
		("getLoadSettingsForData", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(BNBinaryView))),
	]
BNCustomCallingConvention._fields_ = [
		("context", ctypes.c_void_p),
		("freeObject", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
		("getCallerSavedRegisters", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
		("getCalleeSavedRegisters", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
		("getIntegerArgumentRegisters", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
		("getFloatArgumentRegisters", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
		("freeRegisterList", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(ctypes.c_uint))),
		("areArgumentRegistersSharedIndex", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p)),
		("isStackReservedForArgumentRegisters", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p)),
		("isStackAdjustedOnReturn", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p)),
		("isEligibleForHeuristics", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p)),
		("getIntegerReturnValueRegister", ctypes.CFUNCTYPE(ctypes.c_uint, ctypes.c_void_p)),
		("getHighIntegerReturnValueRegister", ctypes.CFUNCTYPE(ctypes.c_uint, ctypes.c_void_p)),
		("getFloatReturnValueRegister", ctypes.CFUNCTYPE(ctypes.c_uint, ctypes.c_void_p)),
		("getGlobalPointerRegister", ctypes.CFUNCTYPE(ctypes.c_uint, ctypes.c_void_p)),
		("getImplicitlyDefinedRegisters", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
		("getIncomingRegisterValue", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_uint, ctypes.POINTER(BNFunction), ctypes.POINTER(BNRegisterValue))),
		("getIncomingFlagValue", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_uint, ctypes.POINTER(BNFunction), ctypes.POINTER(BNRegisterValue))),
		("getIncomingVariableForParameterVariable", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNVariable), ctypes.POINTER(BNFunction), ctypes.POINTER(BNVariable))),
		("getParameterVariableForIncomingVariable", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNVariable), ctypes.POINTER(BNFunction), ctypes.POINTER(BNVariable))),
		("areArgumentRegistersUsedForVarArgs", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p)),
	]
BNCustomDataRenderer._fields_ = [
		("context", ctypes.c_void_p),
		("freeObject", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
		("isValidForData", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong, ctypes.POINTER(BNType), ctypes.POINTER(BNTypeContext), ctypes.c_ulonglong)),
		("getLinesForData", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong, ctypes.POINTER(BNType), ctypes.POINTER(BNInstructionTextToken), ctypes.c_ulonglong, ctypes.c_ulonglong, ctypes.POINTER(ctypes.c_ulonglong), ctypes.POINTER(BNTypeContext), ctypes.c_ulonglong)),
	]
BNCustomFlowGraph._fields_ = [
		("context", ctypes.c_void_p),
		("prepareForLayout", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
		("populateNodes", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
		("completeLayout", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
		("update", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p)),
		("freeObject", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
		("externalRefTaken", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
		("externalRefReleased", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
	]
BNCustomRelocationHandler._fields_ = [
		("context", ctypes.c_void_p),
		("freeObject", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
		("getRelocationInfo", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNArchitecture), ctypes.POINTER(BNRelocationInfo), ctypes.c_ulonglong)),
		("applyRelocation", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNArchitecture), ctypes.POINTER(BNRelocation), ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong)),
		("getOperandForExternalRelocation", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_ulonglong, ctypes.POINTER(BNLowLevelILFunction), ctypes.POINTER(BNRelocation))),
	]
BNCustomTransform._fields_ = [
		("context", ctypes.c_void_p),
		("getParameters", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
		("freeParameters", ctypes.CFUNCTYPE(None, ctypes.POINTER(BNTransformParameterInfo), ctypes.c_ulonglong)),
		("decode", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNDataBuffer), ctypes.POINTER(BNDataBuffer), ctypes.POINTER(BNTransformParameter), ctypes.c_ulonglong)),
		("encode", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNDataBuffer), ctypes.POINTER(BNDataBuffer), ctypes.POINTER(BNTransformParameter), ctypes.c_ulonglong)),
	]
BNDataVariable._fields_ = [
		("address", ctypes.c_ulonglong),
		("type", ctypes.POINTER(BNType)),
		("autoDiscovered", ctypes.c_bool),
		("typeConfidence", ctypes.c_ubyte),
	]
BNDataVariableAndName._fields_ = [
		("address", ctypes.c_ulonglong),
		("type", ctypes.POINTER(BNType)),
		("_name", ctypes.c_char_p),
		("autoDiscovered", ctypes.c_bool),
		("typeConfidence", ctypes.c_ubyte),
	]
BNDataVariableAndNameAndDebugParser._fields_ = [
		("address", ctypes.c_ulonglong),
		("type", ctypes.POINTER(BNType)),
		("_name", ctypes.c_char_p),
		("_parser", ctypes.c_char_p),
		("autoDiscovered", ctypes.c_bool),
		("typeConfidence", ctypes.c_ubyte),
	]
BNDebugFunctionInfo._fields_ = [
		("_shortName", ctypes.c_char_p),
		("_fullName", ctypes.c_char_p),
		("_rawName", ctypes.c_char_p),
		("address", ctypes.c_ulonglong),
		("type", ctypes.POINTER(BNType)),
		("platform", ctypes.POINTER(BNPlatform)),
	]
BNDisassemblyTextLineTypeInfo._fields_ = [
		("hasTypeInfo", ctypes.c_bool),
		("parentType", ctypes.POINTER(BNType)),
		("fieldIndex", ctypes.c_ulonglong),
		("offset", ctypes.c_ulonglong),
	]
BNDownloadInstanceCallbacks._fields_ = [
		("context", ctypes.c_void_p),
		("destroyInstance", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
		("performRequest", ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_void_p, ctypes.c_char_p)),
		("performCustomRequest", ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_void_p, ctypes.c_char_p, ctypes.c_char_p, ctypes.c_ulonglong, ctypes.POINTER(ctypes.c_char_p), ctypes.POINTER(ctypes.c_char_p), ctypes.POINTER(ctypes.POINTER(BNDownloadInstanceResponse)))),
		("freeResponse", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNDownloadInstanceResponse))),
	]
BNDownloadInstanceInputOutputCallbacks._fields_ = [
		("readCallback", ctypes.CFUNCTYPE(ctypes.c_longlong, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_void_p)),
		("readContext", ctypes.c_void_p),
		("writeCallback", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_void_p)),
		("writeContext", ctypes.c_void_p),
		("progressCallback", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)),
		("progressContext", ctypes.c_void_p),
	]
BNDownloadInstanceOutputCallbacks._fields_ = [
		("writeCallback", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_void_p)),
		("writeContext", ctypes.c_void_p),
		("progressCallback", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)),
		("progressContext", ctypes.c_void_p),
	]
BNDownloadInstanceResponse._fields_ = [
		("statusCode", ctypes.c_ushort),
		("headerCount", ctypes.c_ulonglong),
		("headerKeys", ctypes.POINTER(ctypes.c_char_p)),
		("headerValues", ctypes.POINTER(ctypes.c_char_p)),
	]
BNDownloadProviderCallbacks._fields_ = [
		("context", ctypes.c_void_p),
		("createInstance", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p)),
	]
BNEdgeStyle._fields_ = [
		("style", EdgePenStyleEnum),
		("width", ctypes.c_ulonglong),
		("color", ThemeColorEnum),
	]
BNEnterpriseServerCallbacks._fields_ = [
		("context", ctypes.c_void_p),
		("licenseStatusChanged", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_bool)),
	]
BNEnumerationMember._fields_ = [
		("_name", ctypes.c_char_p),
		("value", ctypes.c_ulonglong),
		("isDefault", ctypes.c_bool),
	]
BNFileAccessor._fields_ = [
		("context", ctypes.c_void_p),
		("getLength", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p)),
		("read", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)),
		("write", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_void_p, ctypes.c_ulonglong)),
	]
BNFlagConditionForSemanticClass._fields_ = [
		("semanticClass", ctypes.c_uint),
		("condition", LowLevelILFlagConditionEnum),
	]
BNFlowGraphEdge._fields_ = [
		("type", BranchTypeEnum),
		("target", ctypes.POINTER(BNFlowGraphNode)),
		("points", ctypes.POINTER(BNPoint)),
		("pointCount", ctypes.c_ulonglong),
		("backEdge", ctypes.c_bool),
		("style", BNEdgeStyle),
	]
BNFormInputField._fields_ = [
		("type", FormInputFieldTypeEnum),
		("_prompt", ctypes.c_char_p),
		("view", ctypes.POINTER(BNBinaryView)),
		("currentAddress", ctypes.c_ulonglong),
		("choices", ctypes.POINTER(ctypes.c_char_p)),
		("count", ctypes.c_ulonglong),
		("_ext", ctypes.c_char_p),
		("_defaultName", ctypes.c_char_p),
		("intResult", ctypes.c_longlong),
		("addressResult", ctypes.c_ulonglong),
		("_stringResult", ctypes.c_char_p),
		("indexResult", ctypes.c_ulonglong),
		("hasDefault", ctypes.c_bool),
		("intDefault", ctypes.c_longlong),
		("addressDefault", ctypes.c_ulonglong),
		("_stringDefault", ctypes.c_char_p),
		("indexDefault", ctypes.c_ulonglong),
	]
BNFunctionRecognizer._fields_ = [
		("context", ctypes.c_void_p),
		("recognizeLowLevelIL", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNFunction), ctypes.POINTER(BNLowLevelILFunction))),
		("recognizeMediumLevelIL", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNFunction), ctypes.POINTER(BNMediumLevelILFunction))),
	]
BNHighLevelILInstruction._fields_ = [
		("operation", HighLevelILOperationEnum),
		("sourceOperand", ctypes.c_uint),
		("size", ctypes.c_ulonglong),
		("operands", ctypes.c_ulonglong * 5),
		("address", ctypes.c_ulonglong),
		("parent", ctypes.c_ulonglong),
	]
BNHighlightColor._fields_ = [
		("style", HighlightColorStyleEnum),
		("color", HighlightStandardColorEnum),
		("mixColor", HighlightStandardColorEnum),
		("mix", ctypes.c_ubyte),
		("r", ctypes.c_ubyte),
		("g", ctypes.c_ubyte),
		("b", ctypes.c_ubyte),
		("alpha", ctypes.c_ubyte),
	]
BNILBranchInstructionAndDependence._fields_ = [
		("branch", ctypes.c_ulonglong),
		("dependence", ILBranchDependenceEnum),
	]
BNILReferenceSource._fields_ = [
		("func", ctypes.POINTER(BNFunction)),
		("arch", ctypes.POINTER(BNArchitecture)),
		("addr", ctypes.c_ulonglong),
		("type", FunctionGraphTypeEnum),
		("exprId", ctypes.c_ulonglong),
	]
BNIndirectBranchInfo._fields_ = [
		("sourceArch", ctypes.POINTER(BNArchitecture)),
		("sourceAddr", ctypes.c_ulonglong),
		("destArch", ctypes.POINTER(BNArchitecture)),
		("destAddr", ctypes.c_ulonglong),
		("autoDefined", ctypes.c_bool),
	]
BNInstructionInfo._fields_ = [
		("length", ctypes.c_ulonglong),
		("branchCount", ctypes.c_ulonglong),
		("archTransitionByTargetAddr", ctypes.c_bool),
		("branchDelay", ctypes.c_bool),
		("branchType", BranchTypeEnum * 3),
		("branchTarget", ctypes.c_ulonglong * 3),
		("branchArch", ctypes.POINTER(BNArchitecture) * 3),
	]
BNInstructionTextLine._fields_ = [
		("tokens", ctypes.POINTER(BNInstructionTextToken)),
		("count", ctypes.c_ulonglong),
	]
BNInstructionTextToken._fields_ = [
		("type", InstructionTextTokenTypeEnum),
		("_text", ctypes.c_char_p),
		("value", ctypes.c_ulonglong),
		("width", ctypes.c_ulonglong),
		("size", ctypes.c_ulonglong),
		("operand", ctypes.c_ulonglong),
		("context", InstructionTextTokenContextEnum),
		("confidence", ctypes.c_ubyte),
		("address", ctypes.c_ulonglong),
		("typeNames", ctypes.POINTER(ctypes.c_char_p)),
		("namesCount", ctypes.c_ulonglong),
	]
BNInteractionHandlerCallbacks._fields_ = [
		("context", ctypes.c_void_p),
		("showPlainTextReport", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_char_p, ctypes.c_char_p)),
		("showMarkdownReport", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_char_p, ctypes.c_char_p, ctypes.c_char_p)),
		("showHTMLReport", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_char_p, ctypes.c_char_p, ctypes.c_char_p)),
		("showGraphReport", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_char_p, ctypes.POINTER(BNFlowGraph))),
		("showReportCollection", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_char_p, ctypes.POINTER(BNReportCollection))),
		("getTextLineInput", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_char_p), ctypes.c_char_p, ctypes.c_char_p)),
		("getIntegerInput", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_longlong), ctypes.c_char_p, ctypes.c_char_p)),
		("getAddressInput", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong), ctypes.c_char_p, ctypes.c_char_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong)),
		("getChoiceInput", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong), ctypes.c_char_p, ctypes.c_char_p, ctypes.POINTER(ctypes.c_char_p), ctypes.c_ulonglong)),
		("getOpenFileNameInput", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_char_p), ctypes.c_char_p, ctypes.c_char_p)),
		("getSaveFileNameInput", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_char_p), ctypes.c_char_p, ctypes.c_char_p, ctypes.c_char_p)),
		("getDirectoryNameInput", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_char_p), ctypes.c_char_p, ctypes.c_char_p)),
		("getFormInput", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNFormInputField), ctypes.c_ulonglong, ctypes.c_char_p)),
		("showMessageBox", ctypes.CFUNCTYPE(MessageBoxButtonResultEnum, ctypes.c_void_p, ctypes.c_char_p, ctypes.c_char_p, MessageBoxButtonSetEnum, MessageBoxIconEnum)),
		("openUrl", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_char_p)),
		("runProgressDialog", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_char_p, ctypes.c_bool, ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong), ctypes.c_void_p), ctypes.c_void_p)),
	]
BNLinearViewObjectIdentifier._fields_ = [
		("_name", ctypes.c_char_p),
		("type", LinearViewObjectIdentifierTypeEnum),
		("start", ctypes.c_ulonglong),
		("end", ctypes.c_ulonglong),
	]
BNLogListener._fields_ = [
		("context", ctypes.c_void_p),
		("log", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_ulonglong, LogLevelEnum, ctypes.c_char_p, ctypes.c_char_p, ctypes.c_ulonglong)),
		("close", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
		("getLogLevel", ctypes.CFUNCTYPE(LogLevelEnum, ctypes.c_void_p)),
	]
BNLookupTableEntry._fields_ = [
		("fromValues", ctypes.POINTER(ctypes.c_longlong)),
		("fromCount", ctypes.c_ulonglong),
		("toValue", ctypes.c_longlong),
	]
BNLowLevelILInstruction._fields_ = [
		("operation", LowLevelILOperationEnum),
		("size", ctypes.c_ulonglong),
		("flags", ctypes.c_uint),
		("sourceOperand", ctypes.c_uint),
		("operands", ctypes.c_ulonglong * 4),
		("address", ctypes.c_ulonglong),
	]
BNLowLevelILLabel._fields_ = [
		("resolved", ctypes.c_bool),
		("ref", ctypes.c_ulonglong),
		("operand", ctypes.c_ulonglong),
	]
BNMainThreadCallbacks._fields_ = [
		("context", ctypes.c_void_p),
		("addAction", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNMainThreadAction))),
	]
BNMediumLevelILInstruction._fields_ = [
		("operation", MediumLevelILOperationEnum),
		("sourceOperand", ctypes.c_uint),
		("size", ctypes.c_ulonglong),
		("operands", ctypes.c_ulonglong * 5),
		("address", ctypes.c_ulonglong),
	]
BNMediumLevelILLabel._fields_ = [
		("resolved", ctypes.c_bool),
		("ref", ctypes.c_ulonglong),
		("operand", ctypes.c_ulonglong),
	]
BNMemoryUsageInfo._fields_ = [
		("_name", ctypes.c_char_p),
		("value", ctypes.c_ulonglong),
	]
BNMetadataValueStore._fields_ = [
		("size", ctypes.c_ulonglong),
		("keys", ctypes.POINTER(ctypes.c_char_p)),
		("values", ctypes.POINTER(ctypes.POINTER(BNMetadata))),
	]
BNNameAndType._fields_ = [
		("_name", ctypes.c_char_p),
		("type", ctypes.POINTER(BNType)),
		("typeConfidence", ctypes.c_ubyte),
	]
BNNameList._fields_ = [
		("name", ctypes.POINTER(ctypes.c_char_p)),
		("_join", ctypes.c_char_p),
		("nameCount", ctypes.c_ulonglong),
	]
BNNameSpace._fields_ = [
		("name", ctypes.POINTER(ctypes.c_char_p)),
		("_join", ctypes.c_char_p),
		("nameCount", ctypes.c_ulonglong),
	]
BNNavigationHandler._fields_ = [
		("context", ctypes.c_void_p),
		("getCurrentView", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p)),
		("getCurrentOffset", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p)),
		("navigate", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_char_p, ctypes.c_ulonglong)),
	]
BNObjectDestructionCallbacks._fields_ = [
		("context", ctypes.c_void_p),
		("destructBinaryView", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView))),
		("destructFileMetadata", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNFileMetadata))),
		("destructFunction", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNFunction))),
	]
BNOffsetWithConfidence._fields_ = [
		("value", ctypes.c_longlong),
		("confidence", ctypes.c_ubyte),
	]
BNParameterVariablesWithConfidence._fields_ = [
		("vars", ctypes.POINTER(BNVariable)),
		("count", ctypes.c_ulonglong),
		("confidence", ctypes.c_ubyte),
	]
BNPerformanceInfo._fields_ = [
		("_name", ctypes.c_char_p),
		("seconds", ctypes.c_double),
	]
BNPluginCommand._fields_ = [
		("_name", ctypes.c_char_p),
		("_description", ctypes.c_char_p),
		("type", PluginCommandTypeEnum),
		("context", ctypes.c_void_p),
		("defaultCommand", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView))),
		("addressCommand", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong)),
		("rangeCommand", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong, ctypes.c_ulonglong)),
		("functionCommand", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNFunction))),
		("lowLevelILFunctionCommand", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNLowLevelILFunction))),
		("lowLevelILInstructionCommand", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNLowLevelILFunction), ctypes.c_ulonglong)),
		("mediumLevelILFunctionCommand", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNMediumLevelILFunction))),
		("mediumLevelILInstructionCommand", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNMediumLevelILFunction), ctypes.c_ulonglong)),
		("highLevelILFunctionCommand", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNHighLevelILFunction))),
		("highLevelILInstructionCommand", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNHighLevelILFunction), ctypes.c_ulonglong)),
		("defaultIsValid", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView))),
		("addressIsValid", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong)),
		("rangeIsValid", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong, ctypes.c_ulonglong)),
		("functionIsValid", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNFunction))),
		("lowLevelILFunctionIsValid", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNLowLevelILFunction))),
		("lowLevelILInstructionIsValid", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNLowLevelILFunction), ctypes.c_ulonglong)),
		("mediumLevelILFunctionIsValid", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNMediumLevelILFunction))),
		("mediumLevelILInstructionIsValid", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNMediumLevelILFunction), ctypes.c_ulonglong)),
		("highLevelILFunctionIsValid", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNHighLevelILFunction))),
		("highLevelILInstructionIsValid", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNHighLevelILFunction), ctypes.c_ulonglong)),
	]
BNPoint._fields_ = [
		("x", ctypes.c_float),
		("y", ctypes.c_float),
	]
BNPossibleValueSet._fields_ = [
		("state", RegisterValueTypeEnum),
		("value", ctypes.c_longlong),
		("offset", ctypes.c_longlong),
		("ranges", ctypes.POINTER(BNValueRange)),
		("valueSet", ctypes.POINTER(ctypes.c_longlong)),
		("table", ctypes.POINTER(BNLookupTableEntry)),
		("count", ctypes.c_ulonglong),
	]
BNQualifiedName._fields_ = [
		("name", ctypes.POINTER(ctypes.c_char_p)),
		("_join", ctypes.c_char_p),
		("nameCount", ctypes.c_ulonglong),
	]
BNQualifiedNameAndType._fields_ = [
		("name", BNQualifiedName),
		("type", ctypes.POINTER(BNType)),
	]
BNQualifiedNameList._fields_ = [
		("names", ctypes.POINTER(BNQualifiedName)),
		("count", ctypes.c_ulonglong),
	]
BNQualifiedNameTypeAndId._fields_ = [
		("name", BNQualifiedName),
		("_id", ctypes.c_char_p),
		("type", ctypes.POINTER(BNType)),
	]
BNRange._fields_ = [
		("start", ctypes.c_ulonglong),
		("end", ctypes.c_ulonglong),
	]
BNReferenceSource._fields_ = [
		("func", ctypes.POINTER(BNFunction)),
		("arch", ctypes.POINTER(BNArchitecture)),
		("addr", ctypes.c_ulonglong),
	]
BNRegisterInfo._fields_ = [
		("fullWidthRegister", ctypes.c_uint),
		("offset", ctypes.c_ulonglong),
		("size", ctypes.c_ulonglong),
		("extend", ImplicitRegisterExtendEnum),
	]
BNRegisterOrConstant._fields_ = [
		("constant", ctypes.c_bool),
		("reg", ctypes.c_uint),
		("value", ctypes.c_ulonglong),
	]
BNRegisterSetWithConfidence._fields_ = [
		("regs", ctypes.POINTER(ctypes.c_uint)),
		("count", ctypes.c_ulonglong),
		("confidence", ctypes.c_ubyte),
	]
BNRegisterStackAdjustment._fields_ = [
		("regStack", ctypes.c_uint),
		("adjustment", ctypes.c_int),
		("confidence", ctypes.c_ubyte),
	]
BNRegisterStackInfo._fields_ = [
		("firstStorageReg", ctypes.c_uint),
		("firstTopRelativeReg", ctypes.c_uint),
		("storageCount", ctypes.c_uint),
		("topRelativeCount", ctypes.c_uint),
		("stackTopReg", ctypes.c_uint),
	]
BNRegisterValue._fields_ = [
		("state", RegisterValueTypeEnum),
		("value", ctypes.c_longlong),
		("offset", ctypes.c_longlong),
	]
BNRegisterValueWithConfidence._fields_ = [
		("value", BNRegisterValue),
		("confidence", ctypes.c_ubyte),
	]
BNRelocationInfo._fields_ = [
		("type", RelocationTypeEnum),
		("pcRelative", ctypes.c_bool),
		("baseRelative", ctypes.c_bool),
		("base", ctypes.c_ulonglong),
		("size", ctypes.c_ulonglong),
		("truncateSize", ctypes.c_ulonglong),
		("nativeType", ctypes.c_ulonglong),
		("addend", ctypes.c_ulonglong),
		("hasSign", ctypes.c_bool),
		("implicitAddend", ctypes.c_bool),
		("external", ctypes.c_bool),
		("symbolIndex", ctypes.c_ulonglong),
		("sectionIndex", ctypes.c_ulonglong),
		("address", ctypes.c_ulonglong),
		("target", ctypes.c_ulonglong),
		("dataRelocation", ctypes.c_bool),
		("relocationDataCache", ctypes.c_ubyte * 8),
		("prev", ctypes.POINTER(BNRelocationInfo)),
		("next", ctypes.POINTER(BNRelocationInfo)),
	]
BNScriptingInstanceCallbacks._fields_ = [
		("context", ctypes.c_void_p),
		("destroyInstance", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
		("externalRefTaken", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
		("externalRefReleased", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
		("executeScriptInput", ctypes.CFUNCTYPE(ScriptingProviderExecuteResultEnum, ctypes.c_void_p, ctypes.c_char_p)),
		("executeScriptInputFromFilename", ctypes.CFUNCTYPE(ScriptingProviderExecuteResultEnum, ctypes.c_void_p, ctypes.c_char_p)),
		("cancelScriptInput", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
		("setCurrentBinaryView", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView))),
		("setCurrentFunction", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNFunction))),
		("setCurrentBasicBlock", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBasicBlock))),
		("setCurrentAddress", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_ulonglong)),
		("setCurrentSelection", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)),
		("completeInput", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_char_p, ctypes.c_ulonglong)),
		("stop", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
	]
BNScriptingOutputListener._fields_ = [
		("context", ctypes.c_void_p),
		("output", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_char_p)),
		("error", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_char_p)),
		("inputReadyStateChanged", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ScriptingProviderInputReadyStateEnum)),
	]
BNScriptingProviderCallbacks._fields_ = [
		("context", ctypes.c_void_p),
		("createInstance", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p)),
		("loadModule", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_char_p, ctypes.c_char_p, ctypes.c_bool)),
		("installModules", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_char_p)),
	]
BNSecretsProviderCallbacks._fields_ = [
		("context", ctypes.c_void_p),
		("hasData", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_char_p)),
		("getData", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_char_p)),
		("storeData", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_char_p, ctypes.c_char_p)),
		("deleteData", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_char_p)),
	]
BNStackVariableReference._fields_ = [
		("sourceOperand", ctypes.c_uint),
		("typeConfidence", ctypes.c_ubyte),
		("type", ctypes.POINTER(BNType)),
		("_name", ctypes.c_char_p),
		("varIdentifier", ctypes.c_ulonglong),
		("referencedOffset", ctypes.c_longlong),
		("size", ctypes.c_ulonglong),
	]
BNStringReference._fields_ = [
		("type", StringTypeEnum),
		("start", ctypes.c_ulonglong),
		("length", ctypes.c_ulonglong),
	]
BNStructureMember._fields_ = [
		("type", ctypes.POINTER(BNType)),
		("_name", ctypes.c_char_p),
		("offset", ctypes.c_ulonglong),
		("typeConfidence", ctypes.c_ubyte),
		("access", MemberAccessEnum),
		("scope", MemberScopeEnum),
	]
BNSystemCallInfo._fields_ = [
		("number", ctypes.c_uint),
		("name", BNQualifiedName),
		("type", ctypes.POINTER(BNType)),
	]
BNTagReference._fields_ = [
		("refType", TagReferenceTypeEnum),
		("autoDefined", ctypes.c_bool),
		("tag", ctypes.POINTER(BNTag)),
		("arch", ctypes.POINTER(BNArchitecture)),
		("func", ctypes.POINTER(BNFunction)),
		("addr", ctypes.c_ulonglong),
	]
BNTransformParameter._fields_ = [
		("_name", ctypes.c_char_p),
		("value", ctypes.POINTER(BNDataBuffer)),
	]
BNTransformParameterInfo._fields_ = [
		("_name", ctypes.c_char_p),
		("_longName", ctypes.c_char_p),
		("fixedLength", ctypes.c_ulonglong),
	]
BNTypeContext._fields_ = [
		("type", ctypes.POINTER(BNType)),
		("offset", ctypes.c_ulonglong),
	]
BNTypeDefinitionLine._fields_ = [
		("lineType", TypeDefinitionLineTypeEnum),
		("tokens", ctypes.POINTER(BNInstructionTextToken)),
		("count", ctypes.c_ulonglong),
		("type", ctypes.POINTER(BNType)),
		("rootType", ctypes.POINTER(BNType)),
		("_rootTypeName", ctypes.c_char_p),
		("offset", ctypes.c_ulonglong),
		("fieldIndex", ctypes.c_ulonglong),
	]
BNTypeField._fields_ = [
		("name", BNQualifiedName),
		("offset", ctypes.c_ulonglong),
	]
BNTypeFieldReferenceSizeInfo._fields_ = [
		("offset", ctypes.c_ulonglong),
		("sizes", ctypes.POINTER(ctypes.c_ulonglong)),
		("count", ctypes.c_ulonglong),
	]
BNTypeFieldReferenceTypeInfo._fields_ = [
		("offset", ctypes.c_ulonglong),
		("types", ctypes.POINTER(BNTypeWithConfidence)),
		("count", ctypes.c_ulonglong),
	]
BNTypeParserCallbacks._fields_ = [
		("context", ctypes.c_void_p),
		("getOptionText", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, TypeParserOptionEnum, ctypes.c_char_p, ctypes.POINTER(ctypes.c_char_p))),
		("preprocessSource", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_char_p, ctypes.c_char_p, ctypes.POINTER(BNPlatform), ctypes.POINTER(BNQualifiedNameTypeAndId), ctypes.c_ulonglong, ctypes.POINTER(ctypes.c_char_p), ctypes.c_ulonglong, ctypes.POINTER(ctypes.c_char_p), ctypes.c_ulonglong, ctypes.POINTER(ctypes.c_char_p), ctypes.POINTER(ctypes.POINTER(BNTypeParserError)), ctypes.POINTER(ctypes.c_ulonglong))),
		("parseTypesFromSource", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_char_p, ctypes.c_char_p, ctypes.POINTER(BNPlatform), ctypes.POINTER(BNQualifiedNameTypeAndId), ctypes.c_ulonglong, ctypes.POINTER(ctypes.c_char_p), ctypes.c_ulonglong, ctypes.POINTER(ctypes.c_char_p), ctypes.c_ulonglong, ctypes.c_char_p, ctypes.POINTER(BNTypeParserResult), ctypes.POINTER(ctypes.POINTER(BNTypeParserError)), ctypes.POINTER(ctypes.c_ulonglong))),
		("parseTypeString", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_char_p, ctypes.POINTER(BNPlatform), ctypes.POINTER(BNQualifiedNameTypeAndId), ctypes.c_ulonglong, ctypes.POINTER(BNQualifiedNameAndType), ctypes.POINTER(ctypes.POINTER(BNTypeParserError)), ctypes.POINTER(ctypes.c_ulonglong))),
		("freeString", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_char_p)),
		("freeResult", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNTypeParserResult))),
		("freeErrorList", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNTypeParserError), ctypes.c_ulonglong)),
	]
BNTypeParserError._fields_ = [
		("severity", TypeParserErrorSeverityEnum),
		("_message", ctypes.c_char_p),
		("_fileName", ctypes.c_char_p),
		("line", ctypes.c_ulonglong),
		("column", ctypes.c_ulonglong),
	]
BNTypeParserResult._fields_ = [
		("types", ctypes.POINTER(BNParsedType)),
		("variables", ctypes.POINTER(BNParsedType)),
		("functions", ctypes.POINTER(BNParsedType)),
		("typeCount", ctypes.c_ulonglong),
		("variableCount", ctypes.c_ulonglong),
		("functionCount", ctypes.c_ulonglong),
	]
BNTypePrinterCallbacks._fields_ = [
		("context", ctypes.c_void_p),
		("getTypeTokens", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNType), ctypes.POINTER(BNPlatform), ctypes.POINTER(BNQualifiedName), ctypes.c_ubyte, TokenEscapingTypeEnum, ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)), ctypes.POINTER(ctypes.c_ulonglong))),
		("getTypeTokensBeforeName", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNType), ctypes.POINTER(BNPlatform), ctypes.c_ubyte, ctypes.POINTER(BNType), TokenEscapingTypeEnum, ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)), ctypes.POINTER(ctypes.c_ulonglong))),
		("getTypeTokensAfterName", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNType), ctypes.POINTER(BNPlatform), ctypes.c_ubyte, ctypes.POINTER(BNType), TokenEscapingTypeEnum, ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)), ctypes.POINTER(ctypes.c_ulonglong))),
		("getTypeString", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNType), ctypes.POINTER(BNPlatform), ctypes.POINTER(BNQualifiedName), TokenEscapingTypeEnum, ctypes.POINTER(ctypes.c_char_p))),
		("getTypeStringBeforeName", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNType), ctypes.POINTER(BNPlatform), TokenEscapingTypeEnum, ctypes.POINTER(ctypes.c_char_p))),
		("getTypeStringAfterName", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNType), ctypes.POINTER(BNPlatform), TokenEscapingTypeEnum, ctypes.POINTER(ctypes.c_char_p))),
		("getTypeLines", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNType), ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNQualifiedName), ctypes.c_int, ctypes.c_bool, TokenEscapingTypeEnum, ctypes.POINTER(ctypes.POINTER(BNTypeDefinitionLine)), ctypes.POINTER(ctypes.c_ulonglong))),
		("printAllTypes", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNQualifiedName), ctypes.POINTER(ctypes.POINTER(BNType)), ctypes.c_ulonglong, ctypes.POINTER(BNBinaryView), ctypes.c_int, TokenEscapingTypeEnum, ctypes.POINTER(ctypes.c_char_p))),
		("freeTokens", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNInstructionTextToken), ctypes.c_ulonglong)),
		("freeString", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_char_p)),
		("freeLines", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNTypeDefinitionLine), ctypes.c_ulonglong)),
	]
BNTypeReferenceSource._fields_ = [
		("name", BNQualifiedName),
		("offset", ctypes.c_ulonglong),
		("type", TypeReferenceTypeEnum),
	]
BNTypeWithConfidence._fields_ = [
		("type", ctypes.POINTER(BNType)),
		("confidence", ctypes.c_ubyte),
	]
BNUndoAction._fields_ = [
		("actionType", ActionTypeEnum),
		("_summaryText", ctypes.c_char_p),
		("summaryTokens", ctypes.POINTER(BNInstructionTextToken)),
		("summaryTokenCount", ctypes.c_ulonglong),
	]
BNUndoEntry._fields_ = [
		("valid", ctypes.c_bool),
		("user", ctypes.POINTER(BNUser)),
		("_hash", ctypes.c_char_p),
		("actions", ctypes.POINTER(BNUndoAction)),
		("actionCount", ctypes.c_ulonglong),
		("timestamp", ctypes.c_ulonglong),
	]
BNUpdateChannel._fields_ = [
		("_name", ctypes.c_char_p),
		("_description", ctypes.c_char_p),
		("_latestVersion", ctypes.c_char_p),
	]
BNUpdateVersion._fields_ = [
		("_version", ctypes.c_char_p),
		("_notes", ctypes.c_char_p),
		("time", ctypes.c_ulonglong),
	]
BNValueRange._fields_ = [
		("start", ctypes.c_ulonglong),
		("end", ctypes.c_ulonglong),
		("step", ctypes.c_ulonglong),
	]
BNVariable._fields_ = [
		("type", VariableSourceTypeEnum),
		("index", ctypes.c_uint),
		("storage", ctypes.c_longlong),
	]
BNVariableNameAndType._fields_ = [
		("var", BNVariable),
		("type", ctypes.POINTER(BNType)),
		("_name", ctypes.c_char_p),
		("autoDefined", ctypes.c_bool),
		("typeConfidence", ctypes.c_ubyte),
	]
BNVariableReferenceSource._fields_ = [
		("var", BNVariable),
		("source", BNILReferenceSource),
	]
BNVersionInfo._fields_ = [
		("major", ctypes.c_uint),
		("minor", ctypes.c_uint),
		("build", ctypes.c_uint),
		("_channel", ctypes.c_char_p),
	]
BNWebsocketClientCallbacks._fields_ = [
		("context", ctypes.c_void_p),
		("destroyClient", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
		("connect", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_char_p, ctypes.c_ulonglong, ctypes.POINTER(ctypes.c_char_p), ctypes.POINTER(ctypes.c_char_p))),
		("write", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_void_p)),
		("disconnect", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p)),
	]
BNWebsocketClientOutputCallbacks._fields_ = [
		("context", ctypes.c_void_p),
		("connectedCallback", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p)),
		("disconnectedCallback", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
		("errorCallback", ctypes.CFUNCTYPE(None, ctypes.c_char_p, ctypes.c_void_p)),
		("readCallback", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_void_p)),
	]
BNWebsocketProviderCallbacks._fields_ = [
		("context", ctypes.c_void_p),
		("createClient", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p)),
	]
BNDisassemblyTextLine._fields_ = [
		("addr", ctypes.c_ulonglong),
		("instrIndex", ctypes.c_ulonglong),
		("tokens", ctypes.POINTER(BNInstructionTextToken)),
		("count", ctypes.c_ulonglong),
		("highlight", BNHighlightColor),
		("tags", ctypes.POINTER(ctypes.POINTER(BNTag))),
		("tagCount", ctypes.c_ulonglong),
		("typeInfo", BNDisassemblyTextLineTypeInfo),
	]
BNFunctionParameter._fields_ = [
		("_name", ctypes.c_char_p),
		("type", ctypes.POINTER(BNType)),
		("typeConfidence", ctypes.c_ubyte),
		("defaultLocation", ctypes.c_bool),
		("location", BNVariable),
	]
BNLinearDisassemblyLine._fields_ = [
		("type", LinearDisassemblyLineTypeEnum),
		("function", ctypes.POINTER(BNFunction)),
		("block", ctypes.POINTER(BNBasicBlock)),
		("contents", BNDisassemblyTextLine),
	]
BNMergeResult._fields_ = [
		("status", MergeStatusEnum),
		("action", BNUndoAction),
		("_hash", ctypes.c_char_p),
	]
BNMergedVariable._fields_ = [
		("target", BNVariable),
		("sources", ctypes.POINTER(BNVariable)),
		("sourceCount", ctypes.c_ulonglong),
	]
BNParsedType._fields_ = [
		("name", BNQualifiedName),
		("type", ctypes.POINTER(BNType)),
		("isUser", ctypes.c_bool),
	]
BNTypeFieldReference._fields_ = [
		("func", ctypes.POINTER(BNFunction)),
		("arch", ctypes.POINTER(BNArchitecture)),
		("addr", ctypes.c_ulonglong),
		("size", ctypes.c_ulonglong),
		("incomingType", BNTypeWithConfidence),
	]
BNUserVariableValue._fields_ = [
		("var", BNVariable),
		("defSite", BNArchitectureAndAddress),
		("value", BNPossibleValueSet),
	]

# Function definitions
# -------------------------------------------------------
# _BNAbortAnalysis

_BNAbortAnalysis = core.BNAbortAnalysis
_BNAbortAnalysis.restype = None
_BNAbortAnalysis.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNAbortAnalysis(
		view: ctypes.POINTER(BNBinaryView)
		) -> None:
	return _BNAbortAnalysis(view)


# -------------------------------------------------------
# _BNAbortFlowGraphLayoutRequest

_BNAbortFlowGraphLayoutRequest = core.BNAbortFlowGraphLayoutRequest
_BNAbortFlowGraphLayoutRequest.restype = None
_BNAbortFlowGraphLayoutRequest.argtypes = [
		ctypes.POINTER(BNFlowGraphLayoutRequest),
	]


# noinspection PyPep8Naming
def BNAbortFlowGraphLayoutRequest(
		graph: ctypes.POINTER(BNFlowGraphLayoutRequest)
		) -> None:
	return _BNAbortFlowGraphLayoutRequest(graph)


# -------------------------------------------------------
# _BNAcquireEnterpriseServerLicense

_BNAcquireEnterpriseServerLicense = core.BNAcquireEnterpriseServerLicense
_BNAcquireEnterpriseServerLicense.restype = ctypes.c_bool
_BNAcquireEnterpriseServerLicense.argtypes = [
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNAcquireEnterpriseServerLicense(
		timeout: int
		) -> bool:
	return _BNAcquireEnterpriseServerLicense(timeout)


# -------------------------------------------------------
# _BNActivityGetName

_BNActivityGetName = core.BNActivityGetName
_BNActivityGetName.restype = ctypes.POINTER(ctypes.c_byte)
_BNActivityGetName.argtypes = [
		ctypes.POINTER(BNActivity),
	]


# noinspection PyPep8Naming
def BNActivityGetName(
		activity: ctypes.POINTER(BNActivity)
		) -> Optional[Optional[str]]:
	result = _BNActivityGetName(activity)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNAddAnalysisCompletionEvent

_BNAddAnalysisCompletionEvent = core.BNAddAnalysisCompletionEvent
_BNAddAnalysisCompletionEvent.restype = ctypes.POINTER(BNAnalysisCompletionEvent)
_BNAddAnalysisCompletionEvent.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_void_p,
		ctypes.CFUNCTYPE(None, ctypes.c_void_p),
	]


# noinspection PyPep8Naming
def BNAddAnalysisCompletionEvent(
		view: ctypes.POINTER(BNBinaryView), 
		ctxt: Optional[ctypes.c_void_p], 
		callback: ctypes.CFUNCTYPE(None, ctypes.c_void_p)
		) -> Optional[ctypes.POINTER(BNAnalysisCompletionEvent)]:
	result = _BNAddAnalysisCompletionEvent(view, ctxt, callback)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNAddAnalysisOption

_BNAddAnalysisOption = core.BNAddAnalysisOption
_BNAddAnalysisOption.restype = None
_BNAddAnalysisOption.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNAddAnalysisOption(
		view: ctypes.POINTER(BNBinaryView), 
		name: Optional[str]
		) -> None:
	return _BNAddAnalysisOption(view, cstr(name))


# -------------------------------------------------------
# _BNAddArchitectureRedirection

_BNAddArchitectureRedirection = core.BNAddArchitectureRedirection
_BNAddArchitectureRedirection.restype = None
_BNAddArchitectureRedirection.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(BNArchitecture),
	]


# noinspection PyPep8Naming
def BNAddArchitectureRedirection(
		arch: ctypes.POINTER(BNArchitecture), 
		from_: ctypes.POINTER(BNArchitecture), 
		to: ctypes.POINTER(BNArchitecture)
		) -> None:
	return _BNAddArchitectureRedirection(arch, from_, to)


# -------------------------------------------------------
# _BNAddAutoAddressTag

_BNAddAutoAddressTag = core.BNAddAutoAddressTag
_BNAddAutoAddressTag.restype = None
_BNAddAutoAddressTag.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNTag),
	]


# noinspection PyPep8Naming
def BNAddAutoAddressTag(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		tag: ctypes.POINTER(BNTag)
		) -> None:
	return _BNAddAutoAddressTag(func, arch, addr, tag)


# -------------------------------------------------------
# _BNAddAutoDataTag

_BNAddAutoDataTag = core.BNAddAutoDataTag
_BNAddAutoDataTag.restype = None
_BNAddAutoDataTag.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNTag),
	]


# noinspection PyPep8Naming
def BNAddAutoDataTag(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int, 
		tag: ctypes.POINTER(BNTag)
		) -> None:
	return _BNAddAutoDataTag(view, addr, tag)


# -------------------------------------------------------
# _BNAddAutoFunctionTag

_BNAddAutoFunctionTag = core.BNAddAutoFunctionTag
_BNAddAutoFunctionTag.restype = None
_BNAddAutoFunctionTag.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNTag),
	]


# noinspection PyPep8Naming
def BNAddAutoFunctionTag(
		func: ctypes.POINTER(BNFunction), 
		tag: ctypes.POINTER(BNTag)
		) -> None:
	return _BNAddAutoFunctionTag(func, tag)


# -------------------------------------------------------
# _BNAddAutoSection

_BNAddAutoSection = core.BNAddAutoSection
_BNAddAutoSection.restype = None
_BNAddAutoSection.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		SectionSemanticsEnum,
		ctypes.c_char_p,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNAddAutoSection(
		view: ctypes.POINTER(BNBinaryView), 
		name: Optional[str], 
		start: int, 
		length: int, 
		semantics: SectionSemanticsEnum, 
		type: Optional[str], 
		align: int, 
		entrySize: int, 
		linkedSection: Optional[str], 
		infoSection: Optional[str], 
		infoData: int
		) -> None:
	return _BNAddAutoSection(view, cstr(name), start, length, semantics, cstr(type), align, entrySize, cstr(linkedSection), cstr(infoSection), infoData)


# -------------------------------------------------------
# _BNAddAutoSegment

_BNAddAutoSegment = core.BNAddAutoSegment
_BNAddAutoSegment.restype = None
_BNAddAutoSegment.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_uint,
	]


# noinspection PyPep8Naming
def BNAddAutoSegment(
		view: ctypes.POINTER(BNBinaryView), 
		start: int, 
		length: int, 
		dataOffset: int, 
		dataLength: int, 
		flags: int
		) -> None:
	return _BNAddAutoSegment(view, start, length, dataOffset, dataLength, flags)


# -------------------------------------------------------
# _BNAddBinaryViewTypeLibrary

_BNAddBinaryViewTypeLibrary = core.BNAddBinaryViewTypeLibrary
_BNAddBinaryViewTypeLibrary.restype = None
_BNAddBinaryViewTypeLibrary.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNTypeLibrary),
	]


# noinspection PyPep8Naming
def BNAddBinaryViewTypeLibrary(
		view: ctypes.POINTER(BNBinaryView), 
		lib: ctypes.POINTER(BNTypeLibrary)
		) -> None:
	return _BNAddBinaryViewTypeLibrary(view, lib)


# -------------------------------------------------------
# _BNAddDebugDataVariable

_BNAddDebugDataVariable = core.BNAddDebugDataVariable
_BNAddDebugDataVariable.restype = ctypes.c_bool
_BNAddDebugDataVariable.argtypes = [
		ctypes.POINTER(BNDebugInfo),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNType),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNAddDebugDataVariable(
		debugInfo: ctypes.POINTER(BNDebugInfo), 
		address: int, 
		type: ctypes.POINTER(BNType), 
		name: Optional[str]
		) -> bool:
	return _BNAddDebugDataVariable(debugInfo, address, type, cstr(name))


# -------------------------------------------------------
# _BNAddDebugFunction

_BNAddDebugFunction = core.BNAddDebugFunction
_BNAddDebugFunction.restype = ctypes.c_bool
_BNAddDebugFunction.argtypes = [
		ctypes.POINTER(BNDebugInfo),
		ctypes.POINTER(BNDebugFunctionInfo),
	]


# noinspection PyPep8Naming
def BNAddDebugFunction(
		debugInfo: ctypes.POINTER(BNDebugInfo), 
		func: ctypes.POINTER(BNDebugFunctionInfo)
		) -> bool:
	return _BNAddDebugFunction(debugInfo, func)


# -------------------------------------------------------
# _BNAddDebugType

_BNAddDebugType = core.BNAddDebugType
_BNAddDebugType.restype = ctypes.c_bool
_BNAddDebugType.argtypes = [
		ctypes.POINTER(BNDebugInfo),
		ctypes.c_char_p,
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNAddDebugType(
		debugInfo: ctypes.POINTER(BNDebugInfo), 
		name: Optional[str], 
		type: ctypes.POINTER(BNType)
		) -> bool:
	return _BNAddDebugType(debugInfo, cstr(name), type)


# -------------------------------------------------------
# _BNAddEntryPointForAnalysis

_BNAddEntryPointForAnalysis = core.BNAddEntryPointForAnalysis
_BNAddEntryPointForAnalysis.restype = None
_BNAddEntryPointForAnalysis.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNPlatform),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNAddEntryPointForAnalysis(
		view: ctypes.POINTER(BNBinaryView), 
		platform: ctypes.POINTER(BNPlatform), 
		addr: int
		) -> None:
	return _BNAddEntryPointForAnalysis(view, platform, addr)


# -------------------------------------------------------
# _BNAddEnumerationBuilderMember

_BNAddEnumerationBuilderMember = core.BNAddEnumerationBuilderMember
_BNAddEnumerationBuilderMember.restype = None
_BNAddEnumerationBuilderMember.argtypes = [
		ctypes.POINTER(BNEnumerationBuilder),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNAddEnumerationBuilderMember(
		e: ctypes.POINTER(BNEnumerationBuilder), 
		name: Optional[str]
		) -> None:
	return _BNAddEnumerationBuilderMember(e, cstr(name))


# -------------------------------------------------------
# _BNAddEnumerationBuilderMemberWithValue

_BNAddEnumerationBuilderMemberWithValue = core.BNAddEnumerationBuilderMemberWithValue
_BNAddEnumerationBuilderMemberWithValue.restype = None
_BNAddEnumerationBuilderMemberWithValue.argtypes = [
		ctypes.POINTER(BNEnumerationBuilder),
		ctypes.c_char_p,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNAddEnumerationBuilderMemberWithValue(
		e: ctypes.POINTER(BNEnumerationBuilder), 
		name: Optional[str], 
		value: int
		) -> None:
	return _BNAddEnumerationBuilderMemberWithValue(e, cstr(name), value)


# -------------------------------------------------------
# _BNAddFlowGraphNode

_BNAddFlowGraphNode = core.BNAddFlowGraphNode
_BNAddFlowGraphNode.restype = ctypes.c_ulonglong
_BNAddFlowGraphNode.argtypes = [
		ctypes.POINTER(BNFlowGraph),
		ctypes.POINTER(BNFlowGraphNode),
	]


# noinspection PyPep8Naming
def BNAddFlowGraphNode(
		graph: ctypes.POINTER(BNFlowGraph), 
		node: ctypes.POINTER(BNFlowGraphNode)
		) -> int:
	return _BNAddFlowGraphNode(graph, node)


# -------------------------------------------------------
# _BNAddFlowGraphNodeOutgoingEdge

_BNAddFlowGraphNodeOutgoingEdge = core.BNAddFlowGraphNodeOutgoingEdge
_BNAddFlowGraphNodeOutgoingEdge.restype = None
_BNAddFlowGraphNodeOutgoingEdge.argtypes = [
		ctypes.POINTER(BNFlowGraphNode),
		BranchTypeEnum,
		ctypes.POINTER(BNFlowGraphNode),
		BNEdgeStyle,
	]


# noinspection PyPep8Naming
def BNAddFlowGraphNodeOutgoingEdge(
		node: ctypes.POINTER(BNFlowGraphNode), 
		type: BranchTypeEnum, 
		target: ctypes.POINTER(BNFlowGraphNode), 
		edgeStyle: BNEdgeStyle
		) -> None:
	return _BNAddFlowGraphNodeOutgoingEdge(node, type, target, edgeStyle)


# -------------------------------------------------------
# _BNAddFunctionForAnalysis

_BNAddFunctionForAnalysis = core.BNAddFunctionForAnalysis
_BNAddFunctionForAnalysis.restype = None
_BNAddFunctionForAnalysis.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNPlatform),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNAddFunctionForAnalysis(
		view: ctypes.POINTER(BNBinaryView), 
		platform: ctypes.POINTER(BNPlatform), 
		addr: int
		) -> None:
	return _BNAddFunctionForAnalysis(view, platform, addr)


# -------------------------------------------------------
# _BNAddGraphReportToCollection

_BNAddGraphReportToCollection = core.BNAddGraphReportToCollection
_BNAddGraphReportToCollection.restype = None
_BNAddGraphReportToCollection.argtypes = [
		ctypes.POINTER(BNReportCollection),
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.POINTER(BNFlowGraph),
	]


# noinspection PyPep8Naming
def BNAddGraphReportToCollection(
		reports: ctypes.POINTER(BNReportCollection), 
		view: ctypes.POINTER(BNBinaryView), 
		title: Optional[str], 
		graph: ctypes.POINTER(BNFlowGraph)
		) -> None:
	return _BNAddGraphReportToCollection(reports, view, cstr(title), graph)


# -------------------------------------------------------
# _BNAddHTMLReportToCollection

_BNAddHTMLReportToCollection = core.BNAddHTMLReportToCollection
_BNAddHTMLReportToCollection.restype = None
_BNAddHTMLReportToCollection.argtypes = [
		ctypes.POINTER(BNReportCollection),
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNAddHTMLReportToCollection(
		reports: ctypes.POINTER(BNReportCollection), 
		view: ctypes.POINTER(BNBinaryView), 
		title: Optional[str], 
		contents: Optional[str], 
		plaintext: Optional[str]
		) -> None:
	return _BNAddHTMLReportToCollection(reports, view, cstr(title), cstr(contents), cstr(plaintext))


# -------------------------------------------------------
# _BNAddLowLevelILLabelForAddress

_BNAddLowLevelILLabelForAddress = core.BNAddLowLevelILLabelForAddress
_BNAddLowLevelILLabelForAddress.restype = None
_BNAddLowLevelILLabelForAddress.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNAddLowLevelILLabelForAddress(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int
		) -> None:
	return _BNAddLowLevelILLabelForAddress(func, arch, addr)


# -------------------------------------------------------
# _BNAddMarkdownReportToCollection

_BNAddMarkdownReportToCollection = core.BNAddMarkdownReportToCollection
_BNAddMarkdownReportToCollection.restype = None
_BNAddMarkdownReportToCollection.argtypes = [
		ctypes.POINTER(BNReportCollection),
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNAddMarkdownReportToCollection(
		reports: ctypes.POINTER(BNReportCollection), 
		view: ctypes.POINTER(BNBinaryView), 
		title: Optional[str], 
		contents: Optional[str], 
		plaintext: Optional[str]
		) -> None:
	return _BNAddMarkdownReportToCollection(reports, view, cstr(title), cstr(contents), cstr(plaintext))


# -------------------------------------------------------
# _BNAddOptionalPluginDependency

_BNAddOptionalPluginDependency = core.BNAddOptionalPluginDependency
_BNAddOptionalPluginDependency.restype = None
_BNAddOptionalPluginDependency.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNAddOptionalPluginDependency(
		name: Optional[str]
		) -> None:
	return _BNAddOptionalPluginDependency(cstr(name))


# -------------------------------------------------------
# _BNAddPlainTextReportToCollection

_BNAddPlainTextReportToCollection = core.BNAddPlainTextReportToCollection
_BNAddPlainTextReportToCollection.restype = None
_BNAddPlainTextReportToCollection.argtypes = [
		ctypes.POINTER(BNReportCollection),
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNAddPlainTextReportToCollection(
		reports: ctypes.POINTER(BNReportCollection), 
		view: ctypes.POINTER(BNBinaryView), 
		title: Optional[str], 
		contents: Optional[str]
		) -> None:
	return _BNAddPlainTextReportToCollection(reports, view, cstr(title), cstr(contents))


# -------------------------------------------------------
# _BNAddRelatedPlatform

_BNAddRelatedPlatform = core.BNAddRelatedPlatform
_BNAddRelatedPlatform.restype = None
_BNAddRelatedPlatform.argtypes = [
		ctypes.POINTER(BNPlatform),
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(BNPlatform),
	]


# noinspection PyPep8Naming
def BNAddRelatedPlatform(
		platform: ctypes.POINTER(BNPlatform), 
		arch: ctypes.POINTER(BNArchitecture), 
		related: ctypes.POINTER(BNPlatform)
		) -> None:
	return _BNAddRelatedPlatform(platform, arch, related)


# -------------------------------------------------------
# _BNAddRequiredPluginDependency

_BNAddRequiredPluginDependency = core.BNAddRequiredPluginDependency
_BNAddRequiredPluginDependency.restype = None
_BNAddRequiredPluginDependency.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNAddRequiredPluginDependency(
		name: Optional[str]
		) -> None:
	return _BNAddRequiredPluginDependency(cstr(name))


# -------------------------------------------------------
# _BNAddStructureBuilderMember

_BNAddStructureBuilderMember = core.BNAddStructureBuilderMember
_BNAddStructureBuilderMember.restype = None
_BNAddStructureBuilderMember.argtypes = [
		ctypes.POINTER(BNStructureBuilder),
		ctypes.POINTER(BNTypeWithConfidence),
		ctypes.c_char_p,
		MemberAccessEnum,
		MemberScopeEnum,
	]


# noinspection PyPep8Naming
def BNAddStructureBuilderMember(
		s: ctypes.POINTER(BNStructureBuilder), 
		type: ctypes.POINTER(BNTypeWithConfidence), 
		name: Optional[str], 
		access: MemberAccessEnum, 
		scope: MemberScopeEnum
		) -> None:
	return _BNAddStructureBuilderMember(s, type, cstr(name), access, scope)


# -------------------------------------------------------
# _BNAddStructureBuilderMemberAtOffset

_BNAddStructureBuilderMemberAtOffset = core.BNAddStructureBuilderMemberAtOffset
_BNAddStructureBuilderMemberAtOffset.restype = None
_BNAddStructureBuilderMemberAtOffset.argtypes = [
		ctypes.POINTER(BNStructureBuilder),
		ctypes.POINTER(BNTypeWithConfidence),
		ctypes.c_char_p,
		ctypes.c_ulonglong,
		ctypes.c_bool,
		MemberAccessEnum,
		MemberScopeEnum,
	]


# noinspection PyPep8Naming
def BNAddStructureBuilderMemberAtOffset(
		s: ctypes.POINTER(BNStructureBuilder), 
		type: ctypes.POINTER(BNTypeWithConfidence), 
		name: Optional[str], 
		offset: int, 
		overwriteExisting: bool, 
		access: MemberAccessEnum, 
		scope: MemberScopeEnum
		) -> None:
	return _BNAddStructureBuilderMemberAtOffset(s, type, cstr(name), offset, overwriteExisting, access, scope)


# -------------------------------------------------------
# _BNAddTag

_BNAddTag = core.BNAddTag
_BNAddTag.restype = None
_BNAddTag.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNTag),
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNAddTag(
		view: ctypes.POINTER(BNBinaryView), 
		tag: ctypes.POINTER(BNTag), 
		user: bool
		) -> None:
	return _BNAddTag(view, tag, user)


# -------------------------------------------------------
# _BNAddTagType

_BNAddTagType = core.BNAddTagType
_BNAddTagType.restype = None
_BNAddTagType.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNTagType),
	]


# noinspection PyPep8Naming
def BNAddTagType(
		view: ctypes.POINTER(BNBinaryView), 
		tagType: ctypes.POINTER(BNTagType)
		) -> None:
	return _BNAddTagType(view, tagType)


# -------------------------------------------------------
# _BNAddTypeLibraryAlternateName

_BNAddTypeLibraryAlternateName = core.BNAddTypeLibraryAlternateName
_BNAddTypeLibraryAlternateName.restype = None
_BNAddTypeLibraryAlternateName.argtypes = [
		ctypes.POINTER(BNTypeLibrary),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNAddTypeLibraryAlternateName(
		lib: ctypes.POINTER(BNTypeLibrary), 
		name: Optional[str]
		) -> None:
	return _BNAddTypeLibraryAlternateName(lib, cstr(name))


# -------------------------------------------------------
# _BNAddTypeLibraryNamedObject

_BNAddTypeLibraryNamedObject = core.BNAddTypeLibraryNamedObject
_BNAddTypeLibraryNamedObject.restype = None
_BNAddTypeLibraryNamedObject.argtypes = [
		ctypes.POINTER(BNTypeLibrary),
		ctypes.POINTER(BNQualifiedName),
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNAddTypeLibraryNamedObject(
		lib: ctypes.POINTER(BNTypeLibrary), 
		name: ctypes.POINTER(BNQualifiedName), 
		type: ctypes.POINTER(BNType)
		) -> None:
	return _BNAddTypeLibraryNamedObject(lib, name, type)


# -------------------------------------------------------
# _BNAddTypeLibraryNamedType

_BNAddTypeLibraryNamedType = core.BNAddTypeLibraryNamedType
_BNAddTypeLibraryNamedType.restype = None
_BNAddTypeLibraryNamedType.argtypes = [
		ctypes.POINTER(BNTypeLibrary),
		ctypes.POINTER(BNQualifiedName),
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNAddTypeLibraryNamedType(
		lib: ctypes.POINTER(BNTypeLibrary), 
		name: ctypes.POINTER(BNQualifiedName), 
		type: ctypes.POINTER(BNType)
		) -> None:
	return _BNAddTypeLibraryNamedType(lib, name, type)


# -------------------------------------------------------
# _BNAddTypeLibraryNamedTypeSource

_BNAddTypeLibraryNamedTypeSource = core.BNAddTypeLibraryNamedTypeSource
_BNAddTypeLibraryNamedTypeSource.restype = None
_BNAddTypeLibraryNamedTypeSource.argtypes = [
		ctypes.POINTER(BNTypeLibrary),
		ctypes.POINTER(BNQualifiedName),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNAddTypeLibraryNamedTypeSource(
		lib: ctypes.POINTER(BNTypeLibrary), 
		name: ctypes.POINTER(BNQualifiedName), 
		source: Optional[str]
		) -> None:
	return _BNAddTypeLibraryNamedTypeSource(lib, name, cstr(source))


# -------------------------------------------------------
# _BNAddTypeLibraryPlatform

_BNAddTypeLibraryPlatform = core.BNAddTypeLibraryPlatform
_BNAddTypeLibraryPlatform.restype = None
_BNAddTypeLibraryPlatform.argtypes = [
		ctypes.POINTER(BNTypeLibrary),
		ctypes.POINTER(BNPlatform),
	]


# noinspection PyPep8Naming
def BNAddTypeLibraryPlatform(
		lib: ctypes.POINTER(BNTypeLibrary), 
		platform: ctypes.POINTER(BNPlatform)
		) -> None:
	return _BNAddTypeLibraryPlatform(lib, platform)


# -------------------------------------------------------
# _BNAddTypeMemberTokens

_BNAddTypeMemberTokens = core.BNAddTypeMemberTokens
_BNAddTypeMemberTokens.restype = ctypes.c_bool
_BNAddTypeMemberTokens.argtypes = [
		ctypes.POINTER(BNType),
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)),
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.c_longlong,
		ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.c_ulonglong,
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNAddTypeMemberTokens(
		type: ctypes.POINTER(BNType), 
		data: ctypes.POINTER(BNBinaryView), 
		tokens: ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)), 
		tokenCount: ctypes.POINTER(ctypes.c_ulonglong), 
		offset: int, 
		nameList: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)), 
		nameCount: ctypes.POINTER(ctypes.c_ulonglong), 
		size: int, 
		indirect: bool
		) -> bool:
	return _BNAddTypeMemberTokens(type, data, tokens, tokenCount, offset, nameList, nameCount, size, indirect)


# -------------------------------------------------------
# _BNAddUserAddressTag

_BNAddUserAddressTag = core.BNAddUserAddressTag
_BNAddUserAddressTag.restype = None
_BNAddUserAddressTag.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNTag),
	]


# noinspection PyPep8Naming
def BNAddUserAddressTag(
		func: ctypes.POINTER(BNFunction), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int, 
		tag: ctypes.POINTER(BNTag)
		) -> None:
	return _BNAddUserAddressTag(func, arch, addr, tag)


# -------------------------------------------------------
# _BNAddUserCodeReference

_BNAddUserCodeReference = core.BNAddUserCodeReference
_BNAddUserCodeReference.restype = None
_BNAddUserCodeReference.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNAddUserCodeReference(
		func: ctypes.POINTER(BNFunction), 
		fromArch: ctypes.POINTER(BNArchitecture), 
		fromAddr: int, 
		toAddr: int
		) -> None:
	return _BNAddUserCodeReference(func, fromArch, fromAddr, toAddr)


# -------------------------------------------------------
# _BNAddUserDataReference

_BNAddUserDataReference = core.BNAddUserDataReference
_BNAddUserDataReference.restype = None
_BNAddUserDataReference.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNAddUserDataReference(
		view: ctypes.POINTER(BNBinaryView), 
		fromAddr: int, 
		toAddr: int
		) -> None:
	return _BNAddUserDataReference(view, fromAddr, toAddr)


# -------------------------------------------------------
# _BNAddUserDataTag

_BNAddUserDataTag = core.BNAddUserDataTag
_BNAddUserDataTag.restype = None
_BNAddUserDataTag.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNTag),
	]


# noinspection PyPep8Naming
def BNAddUserDataTag(
		view: ctypes.POINTER(BNBinaryView), 
		addr: int, 
		tag: ctypes.POINTER(BNTag)
		) -> None:
	return _BNAddUserDataTag(view, addr, tag)


# -------------------------------------------------------
# _BNAddUserFunctionTag

_BNAddUserFunctionTag = core.BNAddUserFunctionTag
_BNAddUserFunctionTag.restype = None
_BNAddUserFunctionTag.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNTag),
	]


# noinspection PyPep8Naming
def BNAddUserFunctionTag(
		func: ctypes.POINTER(BNFunction), 
		tag: ctypes.POINTER(BNTag)
		) -> None:
	return _BNAddUserFunctionTag(func, tag)


# -------------------------------------------------------
# _BNAddUserSection

_BNAddUserSection = core.BNAddUserSection
_BNAddUserSection.restype = None
_BNAddUserSection.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		SectionSemanticsEnum,
		ctypes.c_char_p,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNAddUserSection(
		view: ctypes.POINTER(BNBinaryView), 
		name: Optional[str], 
		start: int, 
		length: int, 
		semantics: SectionSemanticsEnum, 
		type: Optional[str], 
		align: int, 
		entrySize: int, 
		linkedSection: Optional[str], 
		infoSection: Optional[str], 
		infoData: int
		) -> None:
	return _BNAddUserSection(view, cstr(name), start, length, semantics, cstr(type), align, entrySize, cstr(linkedSection), cstr(infoSection), infoData)


# -------------------------------------------------------
# _BNAddUserSegment

_BNAddUserSegment = core.BNAddUserSegment
_BNAddUserSegment.restype = None
_BNAddUserSegment.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_uint,
	]


# noinspection PyPep8Naming
def BNAddUserSegment(
		view: ctypes.POINTER(BNBinaryView), 
		start: int, 
		length: int, 
		dataOffset: int, 
		dataLength: int, 
		flags: int
		) -> None:
	return _BNAddUserSegment(view, start, length, dataOffset, dataLength, flags)


# -------------------------------------------------------
# _BNAddUserTypeFieldReference

_BNAddUserTypeFieldReference = core.BNAddUserTypeFieldReference
_BNAddUserTypeFieldReference.restype = None
_BNAddUserTypeFieldReference.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNQualifiedName),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNAddUserTypeFieldReference(
		func: ctypes.POINTER(BNFunction), 
		fromArch: ctypes.POINTER(BNArchitecture), 
		fromAddr: int, 
		name: ctypes.POINTER(BNQualifiedName), 
		offset: int, 
		size: int
		) -> None:
	return _BNAddUserTypeFieldReference(func, fromArch, fromAddr, name, offset, size)


# -------------------------------------------------------
# _BNAddUserTypeReference

_BNAddUserTypeReference = core.BNAddUserTypeReference
_BNAddUserTypeReference.restype = None
_BNAddUserTypeReference.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNQualifiedName),
	]


# noinspection PyPep8Naming
def BNAddUserTypeReference(
		func: ctypes.POINTER(BNFunction), 
		fromArch: ctypes.POINTER(BNArchitecture), 
		fromAddr: int, 
		name: ctypes.POINTER(BNQualifiedName)
		) -> None:
	return _BNAddUserTypeReference(func, fromArch, fromAddr, name)


# -------------------------------------------------------
# _BNAllocString

_BNAllocString = core.BNAllocString
_BNAllocString.restype = ctypes.c_void_p
_BNAllocString.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNAllocString(
		contents: Optional[str]
		) -> Optional[Optional[str]]:
	result = _BNAllocString(cstr(contents))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNAllocStringList

_BNAllocStringList = core.BNAllocStringList
_BNAllocStringList.restype = ctypes.POINTER(ctypes.c_char_p)
_BNAllocStringList.argtypes = [
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNAllocStringList(
		contents: ctypes.POINTER(ctypes.c_char_p), 
		size: int
		) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
	result = _BNAllocStringList(contents, size)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNAlwaysBranch

_BNAlwaysBranch = core.BNAlwaysBranch
_BNAlwaysBranch.restype = ctypes.c_bool
_BNAlwaysBranch.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNAlwaysBranch(
		view: ctypes.POINTER(BNBinaryView), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int
		) -> bool:
	return _BNAlwaysBranch(view, arch, addr)


# -------------------------------------------------------
# _BNAnalysisContextGetFunction

_BNAnalysisContextGetFunction = core.BNAnalysisContextGetFunction
_BNAnalysisContextGetFunction.restype = ctypes.POINTER(BNFunction)
_BNAnalysisContextGetFunction.argtypes = [
		ctypes.POINTER(BNAnalysisContext),
	]


# noinspection PyPep8Naming
def BNAnalysisContextGetFunction(
		analysisContext: ctypes.POINTER(BNAnalysisContext)
		) -> Optional[ctypes.POINTER(BNFunction)]:
	result = _BNAnalysisContextGetFunction(analysisContext)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNAnalysisContextGetHighLevelILFunction

_BNAnalysisContextGetHighLevelILFunction = core.BNAnalysisContextGetHighLevelILFunction
_BNAnalysisContextGetHighLevelILFunction.restype = ctypes.POINTER(BNHighLevelILFunction)
_BNAnalysisContextGetHighLevelILFunction.argtypes = [
		ctypes.POINTER(BNAnalysisContext),
	]


# noinspection PyPep8Naming
def BNAnalysisContextGetHighLevelILFunction(
		analysisContext: ctypes.POINTER(BNAnalysisContext)
		) -> Optional[ctypes.POINTER(BNHighLevelILFunction)]:
	result = _BNAnalysisContextGetHighLevelILFunction(analysisContext)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNAnalysisContextGetLowLevelILFunction

_BNAnalysisContextGetLowLevelILFunction = core.BNAnalysisContextGetLowLevelILFunction
_BNAnalysisContextGetLowLevelILFunction.restype = ctypes.POINTER(BNLowLevelILFunction)
_BNAnalysisContextGetLowLevelILFunction.argtypes = [
		ctypes.POINTER(BNAnalysisContext),
	]


# noinspection PyPep8Naming
def BNAnalysisContextGetLowLevelILFunction(
		analysisContext: ctypes.POINTER(BNAnalysisContext)
		) -> Optional[ctypes.POINTER(BNLowLevelILFunction)]:
	result = _BNAnalysisContextGetLowLevelILFunction(analysisContext)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNAnalysisContextGetMediumLevelILFunction

_BNAnalysisContextGetMediumLevelILFunction = core.BNAnalysisContextGetMediumLevelILFunction
_BNAnalysisContextGetMediumLevelILFunction.restype = ctypes.POINTER(BNMediumLevelILFunction)
_BNAnalysisContextGetMediumLevelILFunction.argtypes = [
		ctypes.POINTER(BNAnalysisContext),
	]


# noinspection PyPep8Naming
def BNAnalysisContextGetMediumLevelILFunction(
		analysisContext: ctypes.POINTER(BNAnalysisContext)
		) -> Optional[ctypes.POINTER(BNMediumLevelILFunction)]:
	result = _BNAnalysisContextGetMediumLevelILFunction(analysisContext)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNAnalysisContextInform

_BNAnalysisContextInform = core.BNAnalysisContextInform
_BNAnalysisContextInform.restype = ctypes.c_bool
_BNAnalysisContextInform.argtypes = [
		ctypes.POINTER(BNAnalysisContext),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNAnalysisContextInform(
		analysisContext: ctypes.POINTER(BNAnalysisContext), 
		request: Optional[str]
		) -> bool:
	return _BNAnalysisContextInform(analysisContext, cstr(request))


# -------------------------------------------------------
# _BNAppendDataBuffer

_BNAppendDataBuffer = core.BNAppendDataBuffer
_BNAppendDataBuffer.restype = None
_BNAppendDataBuffer.argtypes = [
		ctypes.POINTER(BNDataBuffer),
		ctypes.POINTER(BNDataBuffer),
	]


# noinspection PyPep8Naming
def BNAppendDataBuffer(
		dest: ctypes.POINTER(BNDataBuffer), 
		src: ctypes.POINTER(BNDataBuffer)
		) -> None:
	return _BNAppendDataBuffer(dest, src)


# -------------------------------------------------------
# _BNAppendDataBufferContents

_BNAppendDataBufferContents = core.BNAppendDataBufferContents
_BNAppendDataBufferContents.restype = None
_BNAppendDataBufferContents.argtypes = [
		ctypes.POINTER(BNDataBuffer),
		ctypes.c_void_p,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNAppendDataBufferContents(
		dest: ctypes.POINTER(BNDataBuffer), 
		src: Optional[ctypes.c_void_p], 
		len: int
		) -> None:
	return _BNAppendDataBufferContents(dest, src, len)


# -------------------------------------------------------
# _BNAppendPath

_BNAppendPath = core.BNAppendPath
_BNAppendPath.restype = ctypes.POINTER(ctypes.c_byte)
_BNAppendPath.argtypes = [
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNAppendPath(
		path: Optional[str], 
		part: Optional[str]
		) -> Optional[Optional[str]]:
	result = _BNAppendPath(cstr(path), cstr(part))
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNApplyAutoDiscoveredFunctionType

_BNApplyAutoDiscoveredFunctionType = core.BNApplyAutoDiscoveredFunctionType
_BNApplyAutoDiscoveredFunctionType.restype = None
_BNApplyAutoDiscoveredFunctionType.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNApplyAutoDiscoveredFunctionType(
		func: ctypes.POINTER(BNFunction), 
		type: ctypes.POINTER(BNType)
		) -> None:
	return _BNApplyAutoDiscoveredFunctionType(func, type)


# -------------------------------------------------------
# _BNApplyDebugInfo

_BNApplyDebugInfo = core.BNApplyDebugInfo
_BNApplyDebugInfo.restype = None
_BNApplyDebugInfo.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNDebugInfo),
	]


# noinspection PyPep8Naming
def BNApplyDebugInfo(
		view: ctypes.POINTER(BNBinaryView), 
		newDebugInfo: ctypes.POINTER(BNDebugInfo)
		) -> None:
	return _BNApplyDebugInfo(view, newDebugInfo)


# -------------------------------------------------------
# _BNApplyImportedTypes

_BNApplyImportedTypes = core.BNApplyImportedTypes
_BNApplyImportedTypes.restype = None
_BNApplyImportedTypes.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNSymbol),
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNApplyImportedTypes(
		func: ctypes.POINTER(BNFunction), 
		sym: ctypes.POINTER(BNSymbol), 
		type: ctypes.POINTER(BNType)
		) -> None:
	return _BNApplyImportedTypes(func, sym, type)


# -------------------------------------------------------
# _BNApplySnapshotData

_BNApplySnapshotData = core.BNApplySnapshotData
_BNApplySnapshotData.restype = None
_BNApplySnapshotData.argtypes = [
		ctypes.POINTER(BNFileMetadata),
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNKeyValueStore),
		ctypes.POINTER(BNKeyValueStore),
		ctypes.c_void_p,
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
		ctypes.c_bool,
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNApplySnapshotData(
		file: ctypes.POINTER(BNFileMetadata), 
		view: ctypes.POINTER(BNBinaryView), 
		data: ctypes.POINTER(BNKeyValueStore), 
		cache: ctypes.POINTER(BNKeyValueStore), 
		ctxt: Optional[ctypes.c_void_p], 
		progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong), 
		openForConfiguration: bool, 
		restoreRawView: bool
		) -> None:
	return _BNApplySnapshotData(file, view, data, cache, ctxt, progress, openForConfiguration, restoreRawView)


# -------------------------------------------------------
# _BNArchitectureAlwaysBranch

_BNArchitectureAlwaysBranch = core.BNArchitectureAlwaysBranch
_BNArchitectureAlwaysBranch.restype = ctypes.c_bool
_BNArchitectureAlwaysBranch.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(ctypes.c_ubyte),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNArchitectureAlwaysBranch(
		arch: ctypes.POINTER(BNArchitecture), 
		data: ctypes.POINTER(ctypes.c_ubyte), 
		addr: int, 
		len: int
		) -> bool:
	return _BNArchitectureAlwaysBranch(arch, data, addr, len)


# -------------------------------------------------------
# _BNArchitectureConvertToNop

_BNArchitectureConvertToNop = core.BNArchitectureConvertToNop
_BNArchitectureConvertToNop.restype = ctypes.c_bool
_BNArchitectureConvertToNop.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(ctypes.c_ubyte),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNArchitectureConvertToNop(
		arch: ctypes.POINTER(BNArchitecture), 
		data: ctypes.POINTER(ctypes.c_ubyte), 
		addr: int, 
		len: int
		) -> bool:
	return _BNArchitectureConvertToNop(arch, data, addr, len)


# -------------------------------------------------------
# _BNArchitectureGetRelocationHandler

_BNArchitectureGetRelocationHandler = core.BNArchitectureGetRelocationHandler
_BNArchitectureGetRelocationHandler.restype = ctypes.POINTER(BNRelocationHandler)
_BNArchitectureGetRelocationHandler.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNArchitectureGetRelocationHandler(
		arch: ctypes.POINTER(BNArchitecture), 
		viewName: Optional[str]
		) -> Optional[ctypes.POINTER(BNRelocationHandler)]:
	result = _BNArchitectureGetRelocationHandler(arch, cstr(viewName))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNArchitectureInvertBranch

_BNArchitectureInvertBranch = core.BNArchitectureInvertBranch
_BNArchitectureInvertBranch.restype = ctypes.c_bool
_BNArchitectureInvertBranch.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(ctypes.c_ubyte),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNArchitectureInvertBranch(
		arch: ctypes.POINTER(BNArchitecture), 
		data: ctypes.POINTER(ctypes.c_ubyte), 
		addr: int, 
		len: int
		) -> bool:
	return _BNArchitectureInvertBranch(arch, data, addr, len)


# -------------------------------------------------------
# _BNArchitectureRegisterRelocationHandler

_BNArchitectureRegisterRelocationHandler = core.BNArchitectureRegisterRelocationHandler
_BNArchitectureRegisterRelocationHandler.restype = None
_BNArchitectureRegisterRelocationHandler.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.c_char_p,
		ctypes.POINTER(BNRelocationHandler),
	]


# noinspection PyPep8Naming
def BNArchitectureRegisterRelocationHandler(
		arch: ctypes.POINTER(BNArchitecture), 
		viewName: Optional[str], 
		handler: ctypes.POINTER(BNRelocationHandler)
		) -> None:
	return _BNArchitectureRegisterRelocationHandler(arch, cstr(viewName), handler)


# -------------------------------------------------------
# _BNArchitectureSkipAndReturnValue

_BNArchitectureSkipAndReturnValue = core.BNArchitectureSkipAndReturnValue
_BNArchitectureSkipAndReturnValue.restype = ctypes.c_bool
_BNArchitectureSkipAndReturnValue.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(ctypes.c_ubyte),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNArchitectureSkipAndReturnValue(
		arch: ctypes.POINTER(BNArchitecture), 
		data: ctypes.POINTER(ctypes.c_ubyte), 
		addr: int, 
		len: int, 
		value: int
		) -> bool:
	return _BNArchitectureSkipAndReturnValue(arch, data, addr, len, value)


# -------------------------------------------------------
# _BNAreArgumentRegistersSharedIndex

_BNAreArgumentRegistersSharedIndex = core.BNAreArgumentRegistersSharedIndex
_BNAreArgumentRegistersSharedIndex.restype = ctypes.c_bool
_BNAreArgumentRegistersSharedIndex.argtypes = [
		ctypes.POINTER(BNCallingConvention),
	]


# noinspection PyPep8Naming
def BNAreArgumentRegistersSharedIndex(
		cc: ctypes.POINTER(BNCallingConvention)
		) -> bool:
	return _BNAreArgumentRegistersSharedIndex(cc)


# -------------------------------------------------------
# _BNAreArgumentRegistersUsedForVarArgs

_BNAreArgumentRegistersUsedForVarArgs = core.BNAreArgumentRegistersUsedForVarArgs
_BNAreArgumentRegistersUsedForVarArgs.restype = ctypes.c_bool
_BNAreArgumentRegistersUsedForVarArgs.argtypes = [
		ctypes.POINTER(BNCallingConvention),
	]


# noinspection PyPep8Naming
def BNAreArgumentRegistersUsedForVarArgs(
		cc: ctypes.POINTER(BNCallingConvention)
		) -> bool:
	return _BNAreArgumentRegistersUsedForVarArgs(cc)


# -------------------------------------------------------
# _BNAreAutoUpdatesEnabled

_BNAreAutoUpdatesEnabled = core.BNAreAutoUpdatesEnabled
_BNAreAutoUpdatesEnabled.restype = ctypes.c_bool
_BNAreAutoUpdatesEnabled.argtypes = [
	]


# noinspection PyPep8Naming
def BNAreAutoUpdatesEnabled(
		) -> bool:
	return _BNAreAutoUpdatesEnabled()


# -------------------------------------------------------
# _BNAreUpdatesAvailable

_BNAreUpdatesAvailable = core.BNAreUpdatesAvailable
_BNAreUpdatesAvailable.restype = ctypes.c_bool
_BNAreUpdatesAvailable.argtypes = [
		ctypes.c_char_p,
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.POINTER(ctypes.c_char_p),
	]


# noinspection PyPep8Naming
def BNAreUpdatesAvailable(
		channel: Optional[str], 
		expireTime: ctypes.POINTER(ctypes.c_ulonglong), 
		serverTime: ctypes.POINTER(ctypes.c_ulonglong), 
		errors: ctypes.POINTER(ctypes.c_char_p)
		) -> bool:
	return _BNAreUpdatesAvailable(cstr(channel), expireTime, serverTime, errors)


# -------------------------------------------------------
# _BNAssemble

_BNAssemble = core.BNAssemble
_BNAssemble.restype = ctypes.c_bool
_BNAssemble.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.c_char_p,
		ctypes.c_ulonglong,
		ctypes.POINTER(BNDataBuffer),
		ctypes.POINTER(ctypes.c_char_p),
	]


# noinspection PyPep8Naming
def BNAssemble(
		arch: ctypes.POINTER(BNArchitecture), 
		code: Optional[str], 
		addr: int, 
		result: ctypes.POINTER(BNDataBuffer), 
		errors: ctypes.POINTER(ctypes.c_char_p)
		) -> bool:
	return _BNAssemble(arch, cstr(code), addr, result, errors)


# -------------------------------------------------------
# _BNAssignDataBuffer

_BNAssignDataBuffer = core.BNAssignDataBuffer
_BNAssignDataBuffer.restype = None
_BNAssignDataBuffer.argtypes = [
		ctypes.POINTER(BNDataBuffer),
		ctypes.POINTER(BNDataBuffer),
	]


# noinspection PyPep8Naming
def BNAssignDataBuffer(
		dest: ctypes.POINTER(BNDataBuffer), 
		src: ctypes.POINTER(BNDataBuffer)
		) -> None:
	return _BNAssignDataBuffer(dest, src)


# -------------------------------------------------------
# _BNAuthenticateEnterpriseServerWithCredentials

_BNAuthenticateEnterpriseServerWithCredentials = core.BNAuthenticateEnterpriseServerWithCredentials
_BNAuthenticateEnterpriseServerWithCredentials.restype = ctypes.c_bool
_BNAuthenticateEnterpriseServerWithCredentials.argtypes = [
		ctypes.c_char_p,
		ctypes.c_char_p,
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNAuthenticateEnterpriseServerWithCredentials(
		username: Optional[str], 
		password: Optional[str], 
		remember: bool
		) -> bool:
	return _BNAuthenticateEnterpriseServerWithCredentials(cstr(username), cstr(password), remember)


# -------------------------------------------------------
# _BNAuthenticateEnterpriseServerWithMethod

_BNAuthenticateEnterpriseServerWithMethod = core.BNAuthenticateEnterpriseServerWithMethod
_BNAuthenticateEnterpriseServerWithMethod.restype = ctypes.c_bool
_BNAuthenticateEnterpriseServerWithMethod.argtypes = [
		ctypes.c_char_p,
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNAuthenticateEnterpriseServerWithMethod(
		method: Optional[str], 
		remember: bool
		) -> bool:
	return _BNAuthenticateEnterpriseServerWithMethod(cstr(method), remember)


# -------------------------------------------------------
# _BNBasicBlockCanExit

_BNBasicBlockCanExit = core.BNBasicBlockCanExit
_BNBasicBlockCanExit.restype = ctypes.c_bool
_BNBasicBlockCanExit.argtypes = [
		ctypes.POINTER(BNBasicBlock),
	]


# noinspection PyPep8Naming
def BNBasicBlockCanExit(
		block: ctypes.POINTER(BNBasicBlock)
		) -> bool:
	return _BNBasicBlockCanExit(block)


# -------------------------------------------------------
# _BNBasicBlockHasInvalidInstructions

_BNBasicBlockHasInvalidInstructions = core.BNBasicBlockHasInvalidInstructions
_BNBasicBlockHasInvalidInstructions.restype = ctypes.c_bool
_BNBasicBlockHasInvalidInstructions.argtypes = [
		ctypes.POINTER(BNBasicBlock),
	]


# noinspection PyPep8Naming
def BNBasicBlockHasInvalidInstructions(
		block: ctypes.POINTER(BNBasicBlock)
		) -> bool:
	return _BNBasicBlockHasInvalidInstructions(block)


# -------------------------------------------------------
# _BNBasicBlockHasUndeterminedOutgoingEdges

_BNBasicBlockHasUndeterminedOutgoingEdges = core.BNBasicBlockHasUndeterminedOutgoingEdges
_BNBasicBlockHasUndeterminedOutgoingEdges.restype = ctypes.c_bool
_BNBasicBlockHasUndeterminedOutgoingEdges.argtypes = [
		ctypes.POINTER(BNBasicBlock),
	]


# noinspection PyPep8Naming
def BNBasicBlockHasUndeterminedOutgoingEdges(
		block: ctypes.POINTER(BNBasicBlock)
		) -> bool:
	return _BNBasicBlockHasUndeterminedOutgoingEdges(block)


# -------------------------------------------------------
# _BNBasicBlockSetCanExit

_BNBasicBlockSetCanExit = core.BNBasicBlockSetCanExit
_BNBasicBlockSetCanExit.restype = None
_BNBasicBlockSetCanExit.argtypes = [
		ctypes.POINTER(BNBasicBlock),
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNBasicBlockSetCanExit(
		block: ctypes.POINTER(BNBasicBlock), 
		value: bool
		) -> None:
	return _BNBasicBlockSetCanExit(block, value)


# -------------------------------------------------------
# _BNBeginBackgroundTask

_BNBeginBackgroundTask = core.BNBeginBackgroundTask
_BNBeginBackgroundTask.restype = ctypes.POINTER(BNBackgroundTask)
_BNBeginBackgroundTask.argtypes = [
		ctypes.c_char_p,
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNBeginBackgroundTask(
		initialText: Optional[str], 
		canCancel: bool
		) -> Optional[ctypes.POINTER(BNBackgroundTask)]:
	result = _BNBeginBackgroundTask(cstr(initialText), canCancel)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNBeginBulkModifySymbols

_BNBeginBulkModifySymbols = core.BNBeginBulkModifySymbols
_BNBeginBulkModifySymbols.restype = None
_BNBeginBulkModifySymbols.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNBeginBulkModifySymbols(
		view: ctypes.POINTER(BNBinaryView)
		) -> None:
	return _BNBeginBulkModifySymbols(view)


# -------------------------------------------------------
# _BNBeginKeyValueStoreNamespace

_BNBeginKeyValueStoreNamespace = core.BNBeginKeyValueStoreNamespace
_BNBeginKeyValueStoreNamespace.restype = None
_BNBeginKeyValueStoreNamespace.argtypes = [
		ctypes.POINTER(BNKeyValueStore),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNBeginKeyValueStoreNamespace(
		store: ctypes.POINTER(BNKeyValueStore), 
		name: Optional[str]
		) -> None:
	return _BNBeginKeyValueStoreNamespace(store, cstr(name))


# -------------------------------------------------------
# _BNBeginUndoActions

_BNBeginUndoActions = core.BNBeginUndoActions
_BNBeginUndoActions.restype = None
_BNBeginUndoActions.argtypes = [
		ctypes.POINTER(BNFileMetadata),
	]


# noinspection PyPep8Naming
def BNBeginUndoActions(
		file: ctypes.POINTER(BNFileMetadata)
		) -> None:
	return _BNBeginUndoActions(file)


# -------------------------------------------------------
# _BNBinaryViewExportObjectToTypeLibrary

_BNBinaryViewExportObjectToTypeLibrary = core.BNBinaryViewExportObjectToTypeLibrary
_BNBinaryViewExportObjectToTypeLibrary.restype = None
_BNBinaryViewExportObjectToTypeLibrary.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNTypeLibrary),
		ctypes.POINTER(BNQualifiedName),
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNBinaryViewExportObjectToTypeLibrary(
		view: ctypes.POINTER(BNBinaryView), 
		lib: ctypes.POINTER(BNTypeLibrary), 
		name: ctypes.POINTER(BNQualifiedName), 
		type: ctypes.POINTER(BNType)
		) -> None:
	return _BNBinaryViewExportObjectToTypeLibrary(view, lib, name, type)


# -------------------------------------------------------
# _BNBinaryViewExportTypeToTypeLibrary

_BNBinaryViewExportTypeToTypeLibrary = core.BNBinaryViewExportTypeToTypeLibrary
_BNBinaryViewExportTypeToTypeLibrary.restype = None
_BNBinaryViewExportTypeToTypeLibrary.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNTypeLibrary),
		ctypes.POINTER(BNQualifiedName),
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNBinaryViewExportTypeToTypeLibrary(
		view: ctypes.POINTER(BNBinaryView), 
		lib: ctypes.POINTER(BNTypeLibrary), 
		name: ctypes.POINTER(BNQualifiedName), 
		type: ctypes.POINTER(BNType)
		) -> None:
	return _BNBinaryViewExportTypeToTypeLibrary(view, lib, name, type)


# -------------------------------------------------------
# _BNBinaryViewGetLoadSettings

_BNBinaryViewGetLoadSettings = core.BNBinaryViewGetLoadSettings
_BNBinaryViewGetLoadSettings.restype = ctypes.POINTER(BNSettings)
_BNBinaryViewGetLoadSettings.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNBinaryViewGetLoadSettings(
		view: ctypes.POINTER(BNBinaryView), 
		typeName: Optional[str]
		) -> Optional[ctypes.POINTER(BNSettings)]:
	result = _BNBinaryViewGetLoadSettings(view, cstr(typeName))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNBinaryViewGetLoadSettingsTypeNames

_BNBinaryViewGetLoadSettingsTypeNames = core.BNBinaryViewGetLoadSettingsTypeNames
_BNBinaryViewGetLoadSettingsTypeNames.restype = ctypes.POINTER(ctypes.c_char_p)
_BNBinaryViewGetLoadSettingsTypeNames.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNBinaryViewGetLoadSettingsTypeNames(
		view: ctypes.POINTER(BNBinaryView), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
	result = _BNBinaryViewGetLoadSettingsTypeNames(view, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNBinaryViewImportTypeLibraryObject

_BNBinaryViewImportTypeLibraryObject = core.BNBinaryViewImportTypeLibraryObject
_BNBinaryViewImportTypeLibraryObject.restype = ctypes.POINTER(BNType)
_BNBinaryViewImportTypeLibraryObject.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(ctypes.POINTER(BNTypeLibrary)),
		ctypes.POINTER(BNQualifiedName),
	]


# noinspection PyPep8Naming
def BNBinaryViewImportTypeLibraryObject(
		view: ctypes.POINTER(BNBinaryView), 
		lib: ctypes.POINTER(ctypes.POINTER(BNTypeLibrary)), 
		name: ctypes.POINTER(BNQualifiedName)
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNBinaryViewImportTypeLibraryObject(view, lib, name)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNBinaryViewImportTypeLibraryType

_BNBinaryViewImportTypeLibraryType = core.BNBinaryViewImportTypeLibraryType
_BNBinaryViewImportTypeLibraryType.restype = ctypes.POINTER(BNType)
_BNBinaryViewImportTypeLibraryType.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(ctypes.POINTER(BNTypeLibrary)),
		ctypes.POINTER(BNQualifiedName),
	]


# noinspection PyPep8Naming
def BNBinaryViewImportTypeLibraryType(
		view: ctypes.POINTER(BNBinaryView), 
		lib: ctypes.POINTER(ctypes.POINTER(BNTypeLibrary)), 
		name: ctypes.POINTER(BNQualifiedName)
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNBinaryViewImportTypeLibraryType(view, lib, name)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNBinaryViewLookupImportedObjectLibrary

_BNBinaryViewLookupImportedObjectLibrary = core.BNBinaryViewLookupImportedObjectLibrary
_BNBinaryViewLookupImportedObjectLibrary.restype = ctypes.c_bool
_BNBinaryViewLookupImportedObjectLibrary.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNPlatform),
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.POINTER(BNTypeLibrary)),
		ctypes.POINTER(BNQualifiedName),
	]


# noinspection PyPep8Naming
def BNBinaryViewLookupImportedObjectLibrary(
		view: ctypes.POINTER(BNBinaryView), 
		tgtPlatform: ctypes.POINTER(BNPlatform), 
		tgtAddr: int, 
		lib: ctypes.POINTER(ctypes.POINTER(BNTypeLibrary)), 
		name: ctypes.POINTER(BNQualifiedName)
		) -> bool:
	return _BNBinaryViewLookupImportedObjectLibrary(view, tgtPlatform, tgtAddr, lib, name)


# -------------------------------------------------------
# _BNBinaryViewQueryMetadata

_BNBinaryViewQueryMetadata = core.BNBinaryViewQueryMetadata
_BNBinaryViewQueryMetadata.restype = ctypes.POINTER(BNMetadata)
_BNBinaryViewQueryMetadata.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNBinaryViewQueryMetadata(
		view: ctypes.POINTER(BNBinaryView), 
		key: Optional[str]
		) -> Optional[ctypes.POINTER(BNMetadata)]:
	result = _BNBinaryViewQueryMetadata(view, cstr(key))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNBinaryViewRecordImportedObjectLibrary

_BNBinaryViewRecordImportedObjectLibrary = core.BNBinaryViewRecordImportedObjectLibrary
_BNBinaryViewRecordImportedObjectLibrary.restype = None
_BNBinaryViewRecordImportedObjectLibrary.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNPlatform),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNTypeLibrary),
		ctypes.POINTER(BNQualifiedName),
	]


# noinspection PyPep8Naming
def BNBinaryViewRecordImportedObjectLibrary(
		view: ctypes.POINTER(BNBinaryView), 
		tgtPlatform: ctypes.POINTER(BNPlatform), 
		tgtAddr: int, 
		lib: ctypes.POINTER(BNTypeLibrary), 
		name: ctypes.POINTER(BNQualifiedName)
		) -> None:
	return _BNBinaryViewRecordImportedObjectLibrary(view, tgtPlatform, tgtAddr, lib, name)


# -------------------------------------------------------
# _BNBinaryViewRemoveMetadata

_BNBinaryViewRemoveMetadata = core.BNBinaryViewRemoveMetadata
_BNBinaryViewRemoveMetadata.restype = None
_BNBinaryViewRemoveMetadata.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNBinaryViewRemoveMetadata(
		view: ctypes.POINTER(BNBinaryView), 
		key: Optional[str]
		) -> None:
	return _BNBinaryViewRemoveMetadata(view, cstr(key))


# -------------------------------------------------------
# _BNBinaryViewSetLoadSettings

_BNBinaryViewSetLoadSettings = core.BNBinaryViewSetLoadSettings
_BNBinaryViewSetLoadSettings.restype = None
_BNBinaryViewSetLoadSettings.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.POINTER(BNSettings),
	]


# noinspection PyPep8Naming
def BNBinaryViewSetLoadSettings(
		view: ctypes.POINTER(BNBinaryView), 
		typeName: Optional[str], 
		settings: ctypes.POINTER(BNSettings)
		) -> None:
	return _BNBinaryViewSetLoadSettings(view, cstr(typeName), settings)


# -------------------------------------------------------
# _BNBinaryViewStoreMetadata

_BNBinaryViewStoreMetadata = core.BNBinaryViewStoreMetadata
_BNBinaryViewStoreMetadata.restype = None
_BNBinaryViewStoreMetadata.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.POINTER(BNMetadata),
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNBinaryViewStoreMetadata(
		view: ctypes.POINTER(BNBinaryView), 
		key: Optional[str], 
		value: ctypes.POINTER(BNMetadata), 
		isAuto: bool
		) -> None:
	return _BNBinaryViewStoreMetadata(view, cstr(key), value, isAuto)


# -------------------------------------------------------
# _BNCanArchitectureAssemble

_BNCanArchitectureAssemble = core.BNCanArchitectureAssemble
_BNCanArchitectureAssemble.restype = ctypes.c_bool
_BNCanArchitectureAssemble.argtypes = [
		ctypes.POINTER(BNArchitecture),
	]


# noinspection PyPep8Naming
def BNCanArchitectureAssemble(
		arch: ctypes.POINTER(BNArchitecture)
		) -> bool:
	return _BNCanArchitectureAssemble(arch)


# -------------------------------------------------------
# _BNCanAssemble

_BNCanAssemble = core.BNCanAssemble
_BNCanAssemble.restype = ctypes.c_bool
_BNCanAssemble.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNArchitecture),
	]


# noinspection PyPep8Naming
def BNCanAssemble(
		view: ctypes.POINTER(BNBinaryView), 
		arch: ctypes.POINTER(BNArchitecture)
		) -> bool:
	return _BNCanAssemble(view, arch)


# -------------------------------------------------------
# _BNCanCancelBackgroundTask

_BNCanCancelBackgroundTask = core.BNCanCancelBackgroundTask
_BNCanCancelBackgroundTask.restype = ctypes.c_bool
_BNCanCancelBackgroundTask.argtypes = [
		ctypes.POINTER(BNBackgroundTask),
	]


# noinspection PyPep8Naming
def BNCanCancelBackgroundTask(
		task: ctypes.POINTER(BNBackgroundTask)
		) -> bool:
	return _BNCanCancelBackgroundTask(task)


# -------------------------------------------------------
# _BNCanFunctionReturn

_BNCanFunctionReturn = core.BNCanFunctionReturn
_BNCanFunctionReturn.restype = BNBoolWithConfidence
_BNCanFunctionReturn.argtypes = [
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNCanFunctionReturn(
		func: ctypes.POINTER(BNFunction)
		) -> BNBoolWithConfidence:
	return _BNCanFunctionReturn(func)


# -------------------------------------------------------
# _BNCanRedo

_BNCanRedo = core.BNCanRedo
_BNCanRedo.restype = ctypes.c_bool
_BNCanRedo.argtypes = [
		ctypes.POINTER(BNFileMetadata),
	]


# noinspection PyPep8Naming
def BNCanRedo(
		file: ctypes.POINTER(BNFileMetadata)
		) -> bool:
	return _BNCanRedo(file)


# -------------------------------------------------------
# _BNCanUndo

_BNCanUndo = core.BNCanUndo
_BNCanUndo.restype = ctypes.c_bool
_BNCanUndo.argtypes = [
		ctypes.POINTER(BNFileMetadata),
	]


# noinspection PyPep8Naming
def BNCanUndo(
		file: ctypes.POINTER(BNFileMetadata)
		) -> bool:
	return _BNCanUndo(file)


# -------------------------------------------------------
# _BNCancelAnalysisCompletionEvent

_BNCancelAnalysisCompletionEvent = core.BNCancelAnalysisCompletionEvent
_BNCancelAnalysisCompletionEvent.restype = None
_BNCancelAnalysisCompletionEvent.argtypes = [
		ctypes.POINTER(BNAnalysisCompletionEvent),
	]


# noinspection PyPep8Naming
def BNCancelAnalysisCompletionEvent(
		event: ctypes.POINTER(BNAnalysisCompletionEvent)
		) -> None:
	return _BNCancelAnalysisCompletionEvent(event)


# -------------------------------------------------------
# _BNCancelBackgroundTask

_BNCancelBackgroundTask = core.BNCancelBackgroundTask
_BNCancelBackgroundTask.restype = None
_BNCancelBackgroundTask.argtypes = [
		ctypes.POINTER(BNBackgroundTask),
	]


# noinspection PyPep8Naming
def BNCancelBackgroundTask(
		task: ctypes.POINTER(BNBackgroundTask)
		) -> None:
	return _BNCancelBackgroundTask(task)


# -------------------------------------------------------
# _BNCancelEnterpriseServerAuthentication

_BNCancelEnterpriseServerAuthentication = core.BNCancelEnterpriseServerAuthentication
_BNCancelEnterpriseServerAuthentication.restype = None
_BNCancelEnterpriseServerAuthentication.argtypes = [
	]


# noinspection PyPep8Naming
def BNCancelEnterpriseServerAuthentication(
		) -> None:
	return _BNCancelEnterpriseServerAuthentication()


# -------------------------------------------------------
# _BNCancelScriptInput

_BNCancelScriptInput = core.BNCancelScriptInput
_BNCancelScriptInput.restype = None
_BNCancelScriptInput.argtypes = [
		ctypes.POINTER(BNScriptingInstance),
	]


# noinspection PyPep8Naming
def BNCancelScriptInput(
		instance: ctypes.POINTER(BNScriptingInstance)
		) -> None:
	return _BNCancelScriptInput(instance)


# -------------------------------------------------------
# _BNClearDataBuffer

_BNClearDataBuffer = core.BNClearDataBuffer
_BNClearDataBuffer.restype = None
_BNClearDataBuffer.argtypes = [
		ctypes.POINTER(BNDataBuffer),
	]


# noinspection PyPep8Naming
def BNClearDataBuffer(
		buf: ctypes.POINTER(BNDataBuffer)
		) -> None:
	return _BNClearDataBuffer(buf)


# -------------------------------------------------------
# _BNClearTypeLibraryPlatforms

_BNClearTypeLibraryPlatforms = core.BNClearTypeLibraryPlatforms
_BNClearTypeLibraryPlatforms.restype = None
_BNClearTypeLibraryPlatforms.argtypes = [
		ctypes.POINTER(BNTypeLibrary),
	]


# noinspection PyPep8Naming
def BNClearTypeLibraryPlatforms(
		lib: ctypes.POINTER(BNTypeLibrary)
		) -> None:
	return _BNClearTypeLibraryPlatforms(lib)


# -------------------------------------------------------
# _BNClearUndoEntries

_BNClearUndoEntries = core.BNClearUndoEntries
_BNClearUndoEntries.restype = None
_BNClearUndoEntries.argtypes = [
		ctypes.POINTER(BNFileMetadata),
	]


# noinspection PyPep8Naming
def BNClearUndoEntries(
		file: ctypes.POINTER(BNFileMetadata)
		) -> None:
	return _BNClearUndoEntries(file)


# -------------------------------------------------------
# _BNClearUserVariableValue

_BNClearUserVariableValue = core.BNClearUserVariableValue
_BNClearUserVariableValue.restype = None
_BNClearUserVariableValue.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNVariable),
		ctypes.POINTER(BNArchitectureAndAddress),
	]


# noinspection PyPep8Naming
def BNClearUserVariableValue(
		func: ctypes.POINTER(BNFunction), 
		var: ctypes.POINTER(BNVariable), 
		defSite: ctypes.POINTER(BNArchitectureAndAddress)
		) -> None:
	return _BNClearUserVariableValue(func, var, defSite)


# -------------------------------------------------------
# _BNCloseFile

_BNCloseFile = core.BNCloseFile
_BNCloseFile.restype = None
_BNCloseFile.argtypes = [
		ctypes.POINTER(BNFileMetadata),
	]


# noinspection PyPep8Naming
def BNCloseFile(
		file: ctypes.POINTER(BNFileMetadata)
		) -> None:
	return _BNCloseFile(file)


# -------------------------------------------------------
# _BNCloseLogs

_BNCloseLogs = core.BNCloseLogs
_BNCloseLogs.restype = None
_BNCloseLogs.argtypes = [
	]


# noinspection PyPep8Naming
def BNCloseLogs(
		) -> None:
	return _BNCloseLogs()


# -------------------------------------------------------
# _BNCloseProject

_BNCloseProject = core.BNCloseProject
_BNCloseProject.restype = None
_BNCloseProject.argtypes = [
		ctypes.POINTER(BNFileMetadata),
	]


# noinspection PyPep8Naming
def BNCloseProject(
		file: ctypes.POINTER(BNFileMetadata)
		) -> None:
	return _BNCloseProject(file)


# -------------------------------------------------------
# _BNCommitUndoActions

_BNCommitUndoActions = core.BNCommitUndoActions
_BNCommitUndoActions.restype = None
_BNCommitUndoActions.argtypes = [
		ctypes.POINTER(BNFileMetadata),
	]


# noinspection PyPep8Naming
def BNCommitUndoActions(
		file: ctypes.POINTER(BNFileMetadata)
		) -> None:
	return _BNCommitUndoActions(file)


# -------------------------------------------------------
# _BNCompareLinearViewCursors

_BNCompareLinearViewCursors = core.BNCompareLinearViewCursors
_BNCompareLinearViewCursors.restype = ctypes.c_int
_BNCompareLinearViewCursors.argtypes = [
		ctypes.POINTER(BNLinearViewCursor),
		ctypes.POINTER(BNLinearViewCursor),
	]


# noinspection PyPep8Naming
def BNCompareLinearViewCursors(
		a: ctypes.POINTER(BNLinearViewCursor), 
		b: ctypes.POINTER(BNLinearViewCursor)
		) -> int:
	return _BNCompareLinearViewCursors(a, b)


# -------------------------------------------------------
# _BNCompareLinearViewObjectChildren

_BNCompareLinearViewObjectChildren = core.BNCompareLinearViewObjectChildren
_BNCompareLinearViewObjectChildren.restype = ctypes.c_int
_BNCompareLinearViewObjectChildren.argtypes = [
		ctypes.POINTER(BNLinearViewObject),
		ctypes.POINTER(BNLinearViewObject),
		ctypes.POINTER(BNLinearViewObject),
	]


# noinspection PyPep8Naming
def BNCompareLinearViewObjectChildren(
		obj: ctypes.POINTER(BNLinearViewObject), 
		a: ctypes.POINTER(BNLinearViewObject), 
		b: ctypes.POINTER(BNLinearViewObject)
		) -> int:
	return _BNCompareLinearViewObjectChildren(obj, a, b)


# -------------------------------------------------------
# _BNComponentAddAllMembersFromComponent

_BNComponentAddAllMembersFromComponent = core.BNComponentAddAllMembersFromComponent
_BNComponentAddAllMembersFromComponent.restype = None
_BNComponentAddAllMembersFromComponent.argtypes = [
		ctypes.POINTER(BNComponent),
		ctypes.POINTER(BNComponent),
	]


# noinspection PyPep8Naming
def BNComponentAddAllMembersFromComponent(
		component: ctypes.POINTER(BNComponent), 
		fromComponent: ctypes.POINTER(BNComponent)
		) -> None:
	return _BNComponentAddAllMembersFromComponent(component, fromComponent)


# -------------------------------------------------------
# _BNComponentAddComponent

_BNComponentAddComponent = core.BNComponentAddComponent
_BNComponentAddComponent.restype = ctypes.c_bool
_BNComponentAddComponent.argtypes = [
		ctypes.POINTER(BNComponent),
		ctypes.POINTER(BNComponent),
	]


# noinspection PyPep8Naming
def BNComponentAddComponent(
		parent: ctypes.POINTER(BNComponent), 
		component: ctypes.POINTER(BNComponent)
		) -> bool:
	return _BNComponentAddComponent(parent, component)


# -------------------------------------------------------
# _BNComponentAddFunctionReference

_BNComponentAddFunctionReference = core.BNComponentAddFunctionReference
_BNComponentAddFunctionReference.restype = ctypes.c_bool
_BNComponentAddFunctionReference.argtypes = [
		ctypes.POINTER(BNComponent),
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNComponentAddFunctionReference(
		component: ctypes.POINTER(BNComponent), 
		function: ctypes.POINTER(BNFunction)
		) -> bool:
	return _BNComponentAddFunctionReference(component, function)


# -------------------------------------------------------
# _BNComponentContainsComponent

_BNComponentContainsComponent = core.BNComponentContainsComponent
_BNComponentContainsComponent.restype = ctypes.c_bool
_BNComponentContainsComponent.argtypes = [
		ctypes.POINTER(BNComponent),
		ctypes.POINTER(BNComponent),
	]


# noinspection PyPep8Naming
def BNComponentContainsComponent(
		parent: ctypes.POINTER(BNComponent), 
		component: ctypes.POINTER(BNComponent)
		) -> bool:
	return _BNComponentContainsComponent(parent, component)


# -------------------------------------------------------
# _BNComponentContainsFunction

_BNComponentContainsFunction = core.BNComponentContainsFunction
_BNComponentContainsFunction.restype = ctypes.c_bool
_BNComponentContainsFunction.argtypes = [
		ctypes.POINTER(BNComponent),
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNComponentContainsFunction(
		component: ctypes.POINTER(BNComponent), 
		function: ctypes.POINTER(BNFunction)
		) -> bool:
	return _BNComponentContainsFunction(component, function)


# -------------------------------------------------------
# _BNComponentFreeReferencedTypes

_BNComponentFreeReferencedTypes = core.BNComponentFreeReferencedTypes
_BNComponentFreeReferencedTypes.restype = None
_BNComponentFreeReferencedTypes.argtypes = [
		ctypes.POINTER(ctypes.POINTER(BNType)),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNComponentFreeReferencedTypes(
		types: ctypes.POINTER(ctypes.POINTER(BNType)), 
		count: int
		) -> None:
	return _BNComponentFreeReferencedTypes(types, count)


# -------------------------------------------------------
# _BNComponentGetContainedComponents

_BNComponentGetContainedComponents = core.BNComponentGetContainedComponents
_BNComponentGetContainedComponents.restype = ctypes.POINTER(ctypes.POINTER(BNComponent))
_BNComponentGetContainedComponents.argtypes = [
		ctypes.POINTER(BNComponent),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNComponentGetContainedComponents(
		component: ctypes.POINTER(BNComponent), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNComponent))]:
	result = _BNComponentGetContainedComponents(component, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNComponentGetContainedFunctions

_BNComponentGetContainedFunctions = core.BNComponentGetContainedFunctions
_BNComponentGetContainedFunctions.restype = ctypes.POINTER(ctypes.POINTER(BNFunction))
_BNComponentGetContainedFunctions.argtypes = [
		ctypes.POINTER(BNComponent),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNComponentGetContainedFunctions(
		component: ctypes.POINTER(BNComponent), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNFunction))]:
	result = _BNComponentGetContainedFunctions(component, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNComponentGetDisplayName

_BNComponentGetDisplayName = core.BNComponentGetDisplayName
_BNComponentGetDisplayName.restype = ctypes.POINTER(ctypes.c_byte)
_BNComponentGetDisplayName.argtypes = [
		ctypes.POINTER(BNComponent),
	]


# noinspection PyPep8Naming
def BNComponentGetDisplayName(
		component: ctypes.POINTER(BNComponent)
		) -> Optional[Optional[str]]:
	result = _BNComponentGetDisplayName(component)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNComponentGetGuid

_BNComponentGetGuid = core.BNComponentGetGuid
_BNComponentGetGuid.restype = ctypes.POINTER(ctypes.c_byte)
_BNComponentGetGuid.argtypes = [
		ctypes.POINTER(BNComponent),
	]


# noinspection PyPep8Naming
def BNComponentGetGuid(
		component: ctypes.POINTER(BNComponent)
		) -> Optional[Optional[str]]:
	result = _BNComponentGetGuid(component)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNComponentGetOriginalName

_BNComponentGetOriginalName = core.BNComponentGetOriginalName
_BNComponentGetOriginalName.restype = ctypes.POINTER(ctypes.c_byte)
_BNComponentGetOriginalName.argtypes = [
		ctypes.POINTER(BNComponent),
	]


# noinspection PyPep8Naming
def BNComponentGetOriginalName(
		component: ctypes.POINTER(BNComponent)
		) -> Optional[Optional[str]]:
	result = _BNComponentGetOriginalName(component)
	string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
	BNFreeString(result)
	return string


# -------------------------------------------------------
# _BNComponentGetParent

_BNComponentGetParent = core.BNComponentGetParent
_BNComponentGetParent.restype = ctypes.POINTER(BNComponent)
_BNComponentGetParent.argtypes = [
		ctypes.POINTER(BNComponent),
	]


# noinspection PyPep8Naming
def BNComponentGetParent(
		component: ctypes.POINTER(BNComponent)
		) -> Optional[ctypes.POINTER(BNComponent)]:
	result = _BNComponentGetParent(component)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNComponentGetReferencedDataVariables

_BNComponentGetReferencedDataVariables = core.BNComponentGetReferencedDataVariables
_BNComponentGetReferencedDataVariables.restype = ctypes.POINTER(BNDataVariable)
_BNComponentGetReferencedDataVariables.argtypes = [
		ctypes.POINTER(BNComponent),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNComponentGetReferencedDataVariables(
		component: ctypes.POINTER(BNComponent), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNDataVariable)]:
	result = _BNComponentGetReferencedDataVariables(component, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNComponentGetReferencedDataVariablesRecursive

_BNComponentGetReferencedDataVariablesRecursive = core.BNComponentGetReferencedDataVariablesRecursive
_BNComponentGetReferencedDataVariablesRecursive.restype = ctypes.POINTER(BNDataVariable)
_BNComponentGetReferencedDataVariablesRecursive.argtypes = [
		ctypes.POINTER(BNComponent),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNComponentGetReferencedDataVariablesRecursive(
		component: ctypes.POINTER(BNComponent), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(BNDataVariable)]:
	result = _BNComponentGetReferencedDataVariablesRecursive(component, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNComponentGetReferencedTypes

_BNComponentGetReferencedTypes = core.BNComponentGetReferencedTypes
_BNComponentGetReferencedTypes.restype = ctypes.POINTER(ctypes.POINTER(BNType))
_BNComponentGetReferencedTypes.argtypes = [
		ctypes.POINTER(BNComponent),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNComponentGetReferencedTypes(
		component: ctypes.POINTER(BNComponent), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNType))]:
	result = _BNComponentGetReferencedTypes(component, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNComponentGetReferencedTypesRecursive

_BNComponentGetReferencedTypesRecursive = core.BNComponentGetReferencedTypesRecursive
_BNComponentGetReferencedTypesRecursive.restype = ctypes.POINTER(ctypes.POINTER(BNType))
_BNComponentGetReferencedTypesRecursive.argtypes = [
		ctypes.POINTER(BNComponent),
		ctypes.POINTER(ctypes.c_ulonglong),
	]


# noinspection PyPep8Naming
def BNComponentGetReferencedTypesRecursive(
		component: ctypes.POINTER(BNComponent), 
		count: ctypes.POINTER(ctypes.c_ulonglong)
		) -> Optional[ctypes.POINTER(ctypes.POINTER(BNType))]:
	result = _BNComponentGetReferencedTypesRecursive(component, count)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNComponentGetView

_BNComponentGetView = core.BNComponentGetView
_BNComponentGetView.restype = ctypes.POINTER(BNBinaryView)
_BNComponentGetView.argtypes = [
		ctypes.POINTER(BNComponent),
	]


# noinspection PyPep8Naming
def BNComponentGetView(
		component: ctypes.POINTER(BNComponent)
		) -> Optional[ctypes.POINTER(BNBinaryView)]:
	result = _BNComponentGetView(component)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNComponentRemoveAllFunctions

_BNComponentRemoveAllFunctions = core.BNComponentRemoveAllFunctions
_BNComponentRemoveAllFunctions.restype = None
_BNComponentRemoveAllFunctions.argtypes = [
		ctypes.POINTER(BNComponent),
	]


# noinspection PyPep8Naming
def BNComponentRemoveAllFunctions(
		component: ctypes.POINTER(BNComponent)
		) -> None:
	return _BNComponentRemoveAllFunctions(component)


# -------------------------------------------------------
# _BNComponentRemoveComponent

_BNComponentRemoveComponent = core.BNComponentRemoveComponent
_BNComponentRemoveComponent.restype = ctypes.c_bool
_BNComponentRemoveComponent.argtypes = [
		ctypes.POINTER(BNComponent),
	]


# noinspection PyPep8Naming
def BNComponentRemoveComponent(
		component: ctypes.POINTER(BNComponent)
		) -> bool:
	return _BNComponentRemoveComponent(component)


# -------------------------------------------------------
# _BNComponentRemoveFunctionReference

_BNComponentRemoveFunctionReference = core.BNComponentRemoveFunctionReference
_BNComponentRemoveFunctionReference.restype = ctypes.c_bool
_BNComponentRemoveFunctionReference.argtypes = [
		ctypes.POINTER(BNComponent),
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNComponentRemoveFunctionReference(
		component: ctypes.POINTER(BNComponent), 
		function: ctypes.POINTER(BNFunction)
		) -> bool:
	return _BNComponentRemoveFunctionReference(component, function)


# -------------------------------------------------------
# _BNComponentSetName

_BNComponentSetName = core.BNComponentSetName
_BNComponentSetName.restype = None
_BNComponentSetName.argtypes = [
		ctypes.POINTER(BNComponent),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNComponentSetName(
		component: ctypes.POINTER(BNComponent), 
		name: Optional[str]
		) -> None:
	return _BNComponentSetName(component, cstr(name))


# -------------------------------------------------------
# _BNComponentsEqual

_BNComponentsEqual = core.BNComponentsEqual
_BNComponentsEqual.restype = ctypes.c_bool
_BNComponentsEqual.argtypes = [
		ctypes.POINTER(BNComponent),
		ctypes.POINTER(BNComponent),
	]


# noinspection PyPep8Naming
def BNComponentsEqual(
		a: ctypes.POINTER(BNComponent), 
		b: ctypes.POINTER(BNComponent)
		) -> bool:
	return _BNComponentsEqual(a, b)


# -------------------------------------------------------
# _BNComponentsNotEqual

_BNComponentsNotEqual = core.BNComponentsNotEqual
_BNComponentsNotEqual.restype = ctypes.c_bool
_BNComponentsNotEqual.argtypes = [
		ctypes.POINTER(BNComponent),
		ctypes.POINTER(BNComponent),
	]


# noinspection PyPep8Naming
def BNComponentsNotEqual(
		a: ctypes.POINTER(BNComponent), 
		b: ctypes.POINTER(BNComponent)
		) -> bool:
	return _BNComponentsNotEqual(a, b)


# -------------------------------------------------------
# _BNConnectEnterpriseServer

_BNConnectEnterpriseServer = core.BNConnectEnterpriseServer
_BNConnectEnterpriseServer.restype = ctypes.c_bool
_BNConnectEnterpriseServer.argtypes = [
	]


# noinspection PyPep8Naming
def BNConnectEnterpriseServer(
		) -> bool:
	return _BNConnectEnterpriseServer()


# -------------------------------------------------------
# _BNConnectWebsocketClient

_BNConnectWebsocketClient = core.BNConnectWebsocketClient
_BNConnectWebsocketClient.restype = ctypes.c_bool
_BNConnectWebsocketClient.argtypes = [
		ctypes.POINTER(BNWebsocketClient),
		ctypes.c_char_p,
		ctypes.c_ulonglong,
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.POINTER(BNWebsocketClientOutputCallbacks),
	]


# noinspection PyPep8Naming
def BNConnectWebsocketClient(
		client: ctypes.POINTER(BNWebsocketClient), 
		url: Optional[str], 
		headerCount: int, 
		headerKeys: ctypes.POINTER(ctypes.c_char_p), 
		headerValues: ctypes.POINTER(ctypes.c_char_p), 
		callbacks: ctypes.POINTER(BNWebsocketClientOutputCallbacks)
		) -> bool:
	return _BNConnectWebsocketClient(client, cstr(url), headerCount, headerKeys, headerValues, callbacks)


# -------------------------------------------------------
# _BNConvertToNop

_BNConvertToNop = core.BNConvertToNop
_BNConvertToNop.restype = ctypes.c_bool
_BNConvertToNop.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNArchitecture),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNConvertToNop(
		view: ctypes.POINTER(BNBinaryView), 
		arch: ctypes.POINTER(BNArchitecture), 
		addr: int
		) -> bool:
	return _BNConvertToNop(view, arch, addr)


# -------------------------------------------------------
# _BNCopyFile

_BNCopyFile = core.BNCopyFile
_BNCopyFile.restype = ctypes.c_bool
_BNCopyFile.argtypes = [
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNCopyFile(
		source: Optional[str], 
		dest: Optional[str]
		) -> bool:
	return _BNCopyFile(cstr(source), cstr(dest))


# -------------------------------------------------------
# _BNCreateActivity

_BNCreateActivity = core.BNCreateActivity
_BNCreateActivity.restype = ctypes.POINTER(BNActivity)
_BNCreateActivity.argtypes = [
		ctypes.c_char_p,
		ctypes.c_void_p,
		ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNAnalysisContext)),
	]


# noinspection PyPep8Naming
def BNCreateActivity(
		name: Optional[str], 
		ctxt: Optional[ctypes.c_void_p], 
		action: ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNAnalysisContext))
		) -> Optional[ctypes.POINTER(BNActivity)]:
	result = _BNCreateActivity(cstr(name), ctxt, action)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateAnalysisContext

_BNCreateAnalysisContext = core.BNCreateAnalysisContext
_BNCreateAnalysisContext.restype = ctypes.POINTER(BNAnalysisContext)
_BNCreateAnalysisContext.argtypes = [
	]


# noinspection PyPep8Naming
def BNCreateAnalysisContext(
		) -> Optional[ctypes.POINTER(BNAnalysisContext)]:
	result = _BNCreateAnalysisContext()
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateArrayType

_BNCreateArrayType = core.BNCreateArrayType
_BNCreateArrayType.restype = ctypes.POINTER(BNType)
_BNCreateArrayType.argtypes = [
		ctypes.POINTER(BNTypeWithConfidence),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNCreateArrayType(
		type: ctypes.POINTER(BNTypeWithConfidence), 
		elem: int
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNCreateArrayType(type, elem)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateArrayTypeBuilder

_BNCreateArrayTypeBuilder = core.BNCreateArrayTypeBuilder
_BNCreateArrayTypeBuilder.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreateArrayTypeBuilder.argtypes = [
		ctypes.POINTER(BNTypeWithConfidence),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNCreateArrayTypeBuilder(
		type: ctypes.POINTER(BNTypeWithConfidence), 
		elem: int
		) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
	result = _BNCreateArrayTypeBuilder(type, elem)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateAutoStackVariable

_BNCreateAutoStackVariable = core.BNCreateAutoStackVariable
_BNCreateAutoStackVariable.restype = None
_BNCreateAutoStackVariable.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.c_longlong,
		ctypes.POINTER(BNTypeWithConfidence),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNCreateAutoStackVariable(
		func: ctypes.POINTER(BNFunction), 
		offset: int, 
		type: ctypes.POINTER(BNTypeWithConfidence), 
		name: Optional[str]
		) -> None:
	return _BNCreateAutoStackVariable(func, offset, type, cstr(name))


# -------------------------------------------------------
# _BNCreateAutoVariable

_BNCreateAutoVariable = core.BNCreateAutoVariable
_BNCreateAutoVariable.restype = None
_BNCreateAutoVariable.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNVariable),
		ctypes.POINTER(BNTypeWithConfidence),
		ctypes.c_char_p,
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNCreateAutoVariable(
		func: ctypes.POINTER(BNFunction), 
		var: ctypes.POINTER(BNVariable), 
		type: ctypes.POINTER(BNTypeWithConfidence), 
		name: Optional[str], 
		ignoreDisjointUses: bool
		) -> None:
	return _BNCreateAutoVariable(func, var, type, cstr(name), ignoreDisjointUses)


# -------------------------------------------------------
# _BNCreateBinaryDataView

_BNCreateBinaryDataView = core.BNCreateBinaryDataView
_BNCreateBinaryDataView.restype = ctypes.POINTER(BNBinaryView)
_BNCreateBinaryDataView.argtypes = [
		ctypes.POINTER(BNFileMetadata),
	]


# noinspection PyPep8Naming
def BNCreateBinaryDataView(
		file: ctypes.POINTER(BNFileMetadata)
		) -> Optional[ctypes.POINTER(BNBinaryView)]:
	result = _BNCreateBinaryDataView(file)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateBinaryDataViewFromBuffer

_BNCreateBinaryDataViewFromBuffer = core.BNCreateBinaryDataViewFromBuffer
_BNCreateBinaryDataViewFromBuffer.restype = ctypes.POINTER(BNBinaryView)
_BNCreateBinaryDataViewFromBuffer.argtypes = [
		ctypes.POINTER(BNFileMetadata),
		ctypes.POINTER(BNDataBuffer),
	]


# noinspection PyPep8Naming
def BNCreateBinaryDataViewFromBuffer(
		file: ctypes.POINTER(BNFileMetadata), 
		buf: ctypes.POINTER(BNDataBuffer)
		) -> Optional[ctypes.POINTER(BNBinaryView)]:
	result = _BNCreateBinaryDataViewFromBuffer(file, buf)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateBinaryDataViewFromData

_BNCreateBinaryDataViewFromData = core.BNCreateBinaryDataViewFromData
_BNCreateBinaryDataViewFromData.restype = ctypes.POINTER(BNBinaryView)
_BNCreateBinaryDataViewFromData.argtypes = [
		ctypes.POINTER(BNFileMetadata),
		ctypes.c_void_p,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNCreateBinaryDataViewFromData(
		file: ctypes.POINTER(BNFileMetadata), 
		data: Optional[ctypes.c_void_p], 
		len: int
		) -> Optional[ctypes.POINTER(BNBinaryView)]:
	result = _BNCreateBinaryDataViewFromData(file, data, len)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateBinaryDataViewFromFile

_BNCreateBinaryDataViewFromFile = core.BNCreateBinaryDataViewFromFile
_BNCreateBinaryDataViewFromFile.restype = ctypes.POINTER(BNBinaryView)
_BNCreateBinaryDataViewFromFile.argtypes = [
		ctypes.POINTER(BNFileMetadata),
		ctypes.POINTER(BNFileAccessor),
	]


# noinspection PyPep8Naming
def BNCreateBinaryDataViewFromFile(
		file: ctypes.POINTER(BNFileMetadata), 
		accessor: ctypes.POINTER(BNFileAccessor)
		) -> Optional[ctypes.POINTER(BNBinaryView)]:
	result = _BNCreateBinaryDataViewFromFile(file, accessor)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateBinaryDataViewFromFilename

_BNCreateBinaryDataViewFromFilename = core.BNCreateBinaryDataViewFromFilename
_BNCreateBinaryDataViewFromFilename.restype = ctypes.POINTER(BNBinaryView)
_BNCreateBinaryDataViewFromFilename.argtypes = [
		ctypes.POINTER(BNFileMetadata),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNCreateBinaryDataViewFromFilename(
		file: ctypes.POINTER(BNFileMetadata), 
		filename: Optional[str]
		) -> Optional[ctypes.POINTER(BNBinaryView)]:
	result = _BNCreateBinaryDataViewFromFilename(file, cstr(filename))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateBinaryReader

_BNCreateBinaryReader = core.BNCreateBinaryReader
_BNCreateBinaryReader.restype = ctypes.POINTER(BNBinaryReader)
_BNCreateBinaryReader.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNCreateBinaryReader(
		view: ctypes.POINTER(BNBinaryView)
		) -> Optional[ctypes.POINTER(BNBinaryReader)]:
	result = _BNCreateBinaryReader(view)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateBinaryViewOfType

_BNCreateBinaryViewOfType = core.BNCreateBinaryViewOfType
_BNCreateBinaryViewOfType.restype = ctypes.POINTER(BNBinaryView)
_BNCreateBinaryViewOfType.argtypes = [
		ctypes.POINTER(BNBinaryViewType),
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNCreateBinaryViewOfType(
		type: ctypes.POINTER(BNBinaryViewType), 
		data: ctypes.POINTER(BNBinaryView)
		) -> Optional[ctypes.POINTER(BNBinaryView)]:
	result = _BNCreateBinaryViewOfType(type, data)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateBinaryWriter

_BNCreateBinaryWriter = core.BNCreateBinaryWriter
_BNCreateBinaryWriter.restype = ctypes.POINTER(BNBinaryWriter)
_BNCreateBinaryWriter.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNCreateBinaryWriter(
		view: ctypes.POINTER(BNBinaryView)
		) -> Optional[ctypes.POINTER(BNBinaryWriter)]:
	result = _BNCreateBinaryWriter(view)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateBoolType

_BNCreateBoolType = core.BNCreateBoolType
_BNCreateBoolType.restype = ctypes.POINTER(BNType)
_BNCreateBoolType.argtypes = [
	]


# noinspection PyPep8Naming
def BNCreateBoolType(
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNCreateBoolType()
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateBoolTypeBuilder

_BNCreateBoolTypeBuilder = core.BNCreateBoolTypeBuilder
_BNCreateBoolTypeBuilder.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreateBoolTypeBuilder.argtypes = [
	]


# noinspection PyPep8Naming
def BNCreateBoolTypeBuilder(
		) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
	result = _BNCreateBoolTypeBuilder()
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateCallingConvention

_BNCreateCallingConvention = core.BNCreateCallingConvention
_BNCreateCallingConvention.restype = ctypes.POINTER(BNCallingConvention)
_BNCreateCallingConvention.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.c_char_p,
		ctypes.POINTER(BNCustomCallingConvention),
	]


# noinspection PyPep8Naming
def BNCreateCallingConvention(
		arch: ctypes.POINTER(BNArchitecture), 
		name: Optional[str], 
		cc: ctypes.POINTER(BNCustomCallingConvention)
		) -> Optional[ctypes.POINTER(BNCallingConvention)]:
	result = _BNCreateCallingConvention(arch, cstr(name), cc)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateComponent

_BNCreateComponent = core.BNCreateComponent
_BNCreateComponent.restype = ctypes.POINTER(BNComponent)
_BNCreateComponent.argtypes = [
		ctypes.POINTER(BNBinaryView),
	]


# noinspection PyPep8Naming
def BNCreateComponent(
		view: ctypes.POINTER(BNBinaryView)
		) -> Optional[ctypes.POINTER(BNComponent)]:
	result = _BNCreateComponent(view)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateComponentWithName

_BNCreateComponentWithName = core.BNCreateComponentWithName
_BNCreateComponentWithName.restype = ctypes.POINTER(BNComponent)
_BNCreateComponentWithName.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNCreateComponentWithName(
		view: ctypes.POINTER(BNBinaryView), 
		name: Optional[str]
		) -> Optional[ctypes.POINTER(BNComponent)]:
	result = _BNCreateComponentWithName(view, cstr(name))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateComponentWithParent

_BNCreateComponentWithParent = core.BNCreateComponentWithParent
_BNCreateComponentWithParent.restype = ctypes.POINTER(BNComponent)
_BNCreateComponentWithParent.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNCreateComponentWithParent(
		view: ctypes.POINTER(BNBinaryView), 
		parentGUID: Optional[str]
		) -> Optional[ctypes.POINTER(BNComponent)]:
	result = _BNCreateComponentWithParent(view, cstr(parentGUID))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateComponentWithParentAndName

_BNCreateComponentWithParentAndName = core.BNCreateComponentWithParentAndName
_BNCreateComponentWithParentAndName.restype = ctypes.POINTER(BNComponent)
_BNCreateComponentWithParentAndName.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNCreateComponentWithParentAndName(
		view: ctypes.POINTER(BNBinaryView), 
		parentGUID: Optional[str], 
		name: Optional[str]
		) -> Optional[ctypes.POINTER(BNComponent)]:
	result = _BNCreateComponentWithParentAndName(view, cstr(parentGUID), cstr(name))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateCustomBinaryView

_BNCreateCustomBinaryView = core.BNCreateCustomBinaryView
_BNCreateCustomBinaryView.restype = ctypes.POINTER(BNBinaryView)
_BNCreateCustomBinaryView.argtypes = [
		ctypes.c_char_p,
		ctypes.POINTER(BNFileMetadata),
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNCustomBinaryView),
	]


# noinspection PyPep8Naming
def BNCreateCustomBinaryView(
		name: Optional[str], 
		file: ctypes.POINTER(BNFileMetadata), 
		parent: ctypes.POINTER(BNBinaryView), 
		view: ctypes.POINTER(BNCustomBinaryView)
		) -> Optional[ctypes.POINTER(BNBinaryView)]:
	result = _BNCreateCustomBinaryView(cstr(name), file, parent, view)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateCustomFlowGraph

_BNCreateCustomFlowGraph = core.BNCreateCustomFlowGraph
_BNCreateCustomFlowGraph.restype = ctypes.POINTER(BNFlowGraph)
_BNCreateCustomFlowGraph.argtypes = [
		ctypes.POINTER(BNCustomFlowGraph),
	]


# noinspection PyPep8Naming
def BNCreateCustomFlowGraph(
		callbacks: ctypes.POINTER(BNCustomFlowGraph)
		) -> Optional[ctypes.POINTER(BNFlowGraph)]:
	result = _BNCreateCustomFlowGraph(callbacks)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateDataBuffer

_BNCreateDataBuffer = core.BNCreateDataBuffer
_BNCreateDataBuffer.restype = ctypes.POINTER(BNDataBuffer)
_BNCreateDataBuffer.argtypes = [
		ctypes.c_void_p,
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNCreateDataBuffer(
		data: Optional[ctypes.c_void_p], 
		len: int
		) -> Optional[ctypes.POINTER(BNDataBuffer)]:
	result = _BNCreateDataBuffer(data, len)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateDataRenderer

_BNCreateDataRenderer = core.BNCreateDataRenderer
_BNCreateDataRenderer.restype = ctypes.POINTER(BNDataRenderer)
_BNCreateDataRenderer.argtypes = [
		ctypes.POINTER(BNCustomDataRenderer),
	]


# noinspection PyPep8Naming
def BNCreateDataRenderer(
		renderer: ctypes.POINTER(BNCustomDataRenderer)
		) -> Optional[ctypes.POINTER(BNDataRenderer)]:
	result = _BNCreateDataRenderer(renderer)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateDatabase

_BNCreateDatabase = core.BNCreateDatabase
_BNCreateDatabase.restype = ctypes.c_bool
_BNCreateDatabase.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.POINTER(BNSaveSettings),
	]


# noinspection PyPep8Naming
def BNCreateDatabase(
		data: ctypes.POINTER(BNBinaryView), 
		path: Optional[str], 
		settings: ctypes.POINTER(BNSaveSettings)
		) -> bool:
	return _BNCreateDatabase(data, cstr(path), settings)


# -------------------------------------------------------
# _BNCreateDatabaseWithProgress

_BNCreateDatabaseWithProgress = core.BNCreateDatabaseWithProgress
_BNCreateDatabaseWithProgress.restype = ctypes.c_bool
_BNCreateDatabaseWithProgress.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.c_char_p,
		ctypes.c_void_p,
		ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
		ctypes.POINTER(BNSaveSettings),
	]


# noinspection PyPep8Naming
def BNCreateDatabaseWithProgress(
		data: ctypes.POINTER(BNBinaryView), 
		path: Optional[str], 
		ctxt: Optional[ctypes.c_void_p], 
		progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong), 
		settings: ctypes.POINTER(BNSaveSettings)
		) -> bool:
	return _BNCreateDatabaseWithProgress(data, cstr(path), ctxt, progress, settings)


# -------------------------------------------------------
# _BNCreateDirectory

_BNCreateDirectory = core.BNCreateDirectory
_BNCreateDirectory.restype = ctypes.c_bool
_BNCreateDirectory.argtypes = [
		ctypes.c_char_p,
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNCreateDirectory(
		path: Optional[str], 
		createSubdirectories: bool
		) -> bool:
	return _BNCreateDirectory(cstr(path), createSubdirectories)


# -------------------------------------------------------
# _BNCreateDisassemblySettings

_BNCreateDisassemblySettings = core.BNCreateDisassemblySettings
_BNCreateDisassemblySettings.restype = ctypes.POINTER(BNDisassemblySettings)
_BNCreateDisassemblySettings.argtypes = [
	]


# noinspection PyPep8Naming
def BNCreateDisassemblySettings(
		) -> Optional[ctypes.POINTER(BNDisassemblySettings)]:
	result = _BNCreateDisassemblySettings()
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateDisassemblyTextRenderer

_BNCreateDisassemblyTextRenderer = core.BNCreateDisassemblyTextRenderer
_BNCreateDisassemblyTextRenderer.restype = ctypes.POINTER(BNDisassemblyTextRenderer)
_BNCreateDisassemblyTextRenderer.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateDisassemblyTextRenderer(
		func: ctypes.POINTER(BNFunction), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNDisassemblyTextRenderer)]:
	result = _BNCreateDisassemblyTextRenderer(func, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateDownloadProviderInstance

_BNCreateDownloadProviderInstance = core.BNCreateDownloadProviderInstance
_BNCreateDownloadProviderInstance.restype = ctypes.POINTER(BNDownloadInstance)
_BNCreateDownloadProviderInstance.argtypes = [
		ctypes.POINTER(BNDownloadProvider),
	]


# noinspection PyPep8Naming
def BNCreateDownloadProviderInstance(
		provider: ctypes.POINTER(BNDownloadProvider)
		) -> Optional[ctypes.POINTER(BNDownloadInstance)]:
	result = _BNCreateDownloadProviderInstance(provider)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateEnumerationBuilder

_BNCreateEnumerationBuilder = core.BNCreateEnumerationBuilder
_BNCreateEnumerationBuilder.restype = ctypes.POINTER(BNEnumerationBuilder)
_BNCreateEnumerationBuilder.argtypes = [
	]


# noinspection PyPep8Naming
def BNCreateEnumerationBuilder(
		) -> Optional[ctypes.POINTER(BNEnumerationBuilder)]:
	result = _BNCreateEnumerationBuilder()
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateEnumerationBuilderFromEnumeration

_BNCreateEnumerationBuilderFromEnumeration = core.BNCreateEnumerationBuilderFromEnumeration
_BNCreateEnumerationBuilderFromEnumeration.restype = ctypes.POINTER(BNEnumerationBuilder)
_BNCreateEnumerationBuilderFromEnumeration.argtypes = [
		ctypes.POINTER(BNEnumeration),
	]


# noinspection PyPep8Naming
def BNCreateEnumerationBuilderFromEnumeration(
		e: ctypes.POINTER(BNEnumeration)
		) -> Optional[ctypes.POINTER(BNEnumerationBuilder)]:
	result = _BNCreateEnumerationBuilderFromEnumeration(e)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateEnumerationType

_BNCreateEnumerationType = core.BNCreateEnumerationType
_BNCreateEnumerationType.restype = ctypes.POINTER(BNType)
_BNCreateEnumerationType.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(BNEnumeration),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNBoolWithConfidence),
	]


# noinspection PyPep8Naming
def BNCreateEnumerationType(
		arch: ctypes.POINTER(BNArchitecture), 
		e: ctypes.POINTER(BNEnumeration), 
		width: int, 
		isSigned: ctypes.POINTER(BNBoolWithConfidence)
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNCreateEnumerationType(arch, e, width, isSigned)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateEnumerationTypeBuilder

_BNCreateEnumerationTypeBuilder = core.BNCreateEnumerationTypeBuilder
_BNCreateEnumerationTypeBuilder.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreateEnumerationTypeBuilder.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(BNEnumeration),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNBoolWithConfidence),
	]


# noinspection PyPep8Naming
def BNCreateEnumerationTypeBuilder(
		arch: ctypes.POINTER(BNArchitecture), 
		e: ctypes.POINTER(BNEnumeration), 
		width: int, 
		isSigned: ctypes.POINTER(BNBoolWithConfidence)
		) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
	result = _BNCreateEnumerationTypeBuilder(arch, e, width, isSigned)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateEnumerationTypeBuilderWithBuilder

_BNCreateEnumerationTypeBuilderWithBuilder = core.BNCreateEnumerationTypeBuilderWithBuilder
_BNCreateEnumerationTypeBuilderWithBuilder.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreateEnumerationTypeBuilderWithBuilder.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(BNEnumerationBuilder),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNBoolWithConfidence),
	]


# noinspection PyPep8Naming
def BNCreateEnumerationTypeBuilderWithBuilder(
		arch: ctypes.POINTER(BNArchitecture), 
		e: ctypes.POINTER(BNEnumerationBuilder), 
		width: int, 
		isSigned: ctypes.POINTER(BNBoolWithConfidence)
		) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
	result = _BNCreateEnumerationTypeBuilderWithBuilder(arch, e, width, isSigned)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateEnumerationTypeOfWidth

_BNCreateEnumerationTypeOfWidth = core.BNCreateEnumerationTypeOfWidth
_BNCreateEnumerationTypeOfWidth.restype = ctypes.POINTER(BNType)
_BNCreateEnumerationTypeOfWidth.argtypes = [
		ctypes.POINTER(BNEnumeration),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNBoolWithConfidence),
	]


# noinspection PyPep8Naming
def BNCreateEnumerationTypeOfWidth(
		e: ctypes.POINTER(BNEnumeration), 
		width: int, 
		isSigned: ctypes.POINTER(BNBoolWithConfidence)
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNCreateEnumerationTypeOfWidth(e, width, isSigned)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateFileMetadata

_BNCreateFileMetadata = core.BNCreateFileMetadata
_BNCreateFileMetadata.restype = ctypes.POINTER(BNFileMetadata)
_BNCreateFileMetadata.argtypes = [
	]


# noinspection PyPep8Naming
def BNCreateFileMetadata(
		) -> Optional[ctypes.POINTER(BNFileMetadata)]:
	result = _BNCreateFileMetadata()
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateFloatType

_BNCreateFloatType = core.BNCreateFloatType
_BNCreateFloatType.restype = ctypes.POINTER(BNType)
_BNCreateFloatType.argtypes = [
		ctypes.c_ulonglong,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNCreateFloatType(
		width: int, 
		altName: Optional[str]
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNCreateFloatType(width, cstr(altName))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateFloatTypeBuilder

_BNCreateFloatTypeBuilder = core.BNCreateFloatTypeBuilder
_BNCreateFloatTypeBuilder.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreateFloatTypeBuilder.argtypes = [
		ctypes.c_ulonglong,
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNCreateFloatTypeBuilder(
		width: int, 
		altName: Optional[str]
		) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
	result = _BNCreateFloatTypeBuilder(width, cstr(altName))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateFlowGraph

_BNCreateFlowGraph = core.BNCreateFlowGraph
_BNCreateFlowGraph.restype = ctypes.POINTER(BNFlowGraph)
_BNCreateFlowGraph.argtypes = [
	]


# noinspection PyPep8Naming
def BNCreateFlowGraph(
		) -> Optional[ctypes.POINTER(BNFlowGraph)]:
	result = _BNCreateFlowGraph()
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateFlowGraphNode

_BNCreateFlowGraphNode = core.BNCreateFlowGraphNode
_BNCreateFlowGraphNode.restype = ctypes.POINTER(BNFlowGraphNode)
_BNCreateFlowGraphNode.argtypes = [
		ctypes.POINTER(BNFlowGraph),
	]


# noinspection PyPep8Naming
def BNCreateFlowGraphNode(
		graph: ctypes.POINTER(BNFlowGraph)
		) -> Optional[ctypes.POINTER(BNFlowGraphNode)]:
	result = _BNCreateFlowGraphNode(graph)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateFunctionGraph

_BNCreateFunctionGraph = core.BNCreateFunctionGraph
_BNCreateFunctionGraph.restype = ctypes.POINTER(BNFlowGraph)
_BNCreateFunctionGraph.argtypes = [
		ctypes.POINTER(BNFunction),
		FunctionGraphTypeEnum,
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateFunctionGraph(
		func: ctypes.POINTER(BNFunction), 
		type: FunctionGraphTypeEnum, 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNFlowGraph)]:
	result = _BNCreateFunctionGraph(func, type, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateFunctionType

_BNCreateFunctionType = core.BNCreateFunctionType
_BNCreateFunctionType.restype = ctypes.POINTER(BNType)
_BNCreateFunctionType.argtypes = [
		ctypes.POINTER(BNTypeWithConfidence),
		ctypes.POINTER(BNCallingConventionWithConfidence),
		ctypes.POINTER(BNFunctionParameter),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNBoolWithConfidence),
		ctypes.POINTER(BNBoolWithConfidence),
		ctypes.POINTER(BNOffsetWithConfidence),
		ctypes.POINTER(ctypes.c_uint),
		ctypes.POINTER(BNOffsetWithConfidence),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNRegisterSetWithConfidence),
		NameTypeEnum,
	]


# noinspection PyPep8Naming
def BNCreateFunctionType(
		returnValue: ctypes.POINTER(BNTypeWithConfidence), 
		callingConvention: ctypes.POINTER(BNCallingConventionWithConfidence), 
		params: ctypes.POINTER(BNFunctionParameter), 
		paramCount: int, 
		varArg: ctypes.POINTER(BNBoolWithConfidence), 
		canReturn: ctypes.POINTER(BNBoolWithConfidence), 
		stackAdjust: ctypes.POINTER(BNOffsetWithConfidence), 
		regStackAdjustRegs: ctypes.POINTER(ctypes.c_uint), 
		regStackAdjustValues: ctypes.POINTER(BNOffsetWithConfidence), 
		regStackAdjustCount: int, 
		returnRegs: ctypes.POINTER(BNRegisterSetWithConfidence), 
		ft: NameTypeEnum
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNCreateFunctionType(returnValue, callingConvention, params, paramCount, varArg, canReturn, stackAdjust, regStackAdjustRegs, regStackAdjustValues, regStackAdjustCount, returnRegs, ft)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateFunctionTypeBuilder

_BNCreateFunctionTypeBuilder = core.BNCreateFunctionTypeBuilder
_BNCreateFunctionTypeBuilder.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreateFunctionTypeBuilder.argtypes = [
		ctypes.POINTER(BNTypeWithConfidence),
		ctypes.POINTER(BNCallingConventionWithConfidence),
		ctypes.POINTER(BNFunctionParameter),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNBoolWithConfidence),
		ctypes.POINTER(BNBoolWithConfidence),
		ctypes.POINTER(BNOffsetWithConfidence),
		ctypes.POINTER(ctypes.c_uint),
		ctypes.POINTER(BNOffsetWithConfidence),
		ctypes.c_ulonglong,
		ctypes.POINTER(BNRegisterSetWithConfidence),
		NameTypeEnum,
	]


# noinspection PyPep8Naming
def BNCreateFunctionTypeBuilder(
		returnValue: ctypes.POINTER(BNTypeWithConfidence), 
		callingConvention: ctypes.POINTER(BNCallingConventionWithConfidence), 
		params: ctypes.POINTER(BNFunctionParameter), 
		paramCount: int, 
		varArg: ctypes.POINTER(BNBoolWithConfidence), 
		canReturn: ctypes.POINTER(BNBoolWithConfidence), 
		stackAdjust: ctypes.POINTER(BNOffsetWithConfidence), 
		regStackAdjustRegs: ctypes.POINTER(ctypes.c_uint), 
		regStackAdjustValues: ctypes.POINTER(BNOffsetWithConfidence), 
		regStackAdjustCount: int, 
		returnRegs: ctypes.POINTER(BNRegisterSetWithConfidence), 
		ft: NameTypeEnum
		) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
	result = _BNCreateFunctionTypeBuilder(returnValue, callingConvention, params, paramCount, varArg, canReturn, stackAdjust, regStackAdjustRegs, regStackAdjustValues, regStackAdjustCount, returnRegs, ft)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateHighLevelILDisassemblyTextRenderer

_BNCreateHighLevelILDisassemblyTextRenderer = core.BNCreateHighLevelILDisassemblyTextRenderer
_BNCreateHighLevelILDisassemblyTextRenderer.restype = ctypes.POINTER(BNDisassemblyTextRenderer)
_BNCreateHighLevelILDisassemblyTextRenderer.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateHighLevelILDisassemblyTextRenderer(
		func: ctypes.POINTER(BNHighLevelILFunction), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNDisassemblyTextRenderer)]:
	result = _BNCreateHighLevelILDisassemblyTextRenderer(func, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateHighLevelILFunction

_BNCreateHighLevelILFunction = core.BNCreateHighLevelILFunction
_BNCreateHighLevelILFunction.restype = ctypes.POINTER(BNHighLevelILFunction)
_BNCreateHighLevelILFunction.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNCreateHighLevelILFunction(
		arch: ctypes.POINTER(BNArchitecture), 
		func: ctypes.POINTER(BNFunction)
		) -> Optional[ctypes.POINTER(BNHighLevelILFunction)]:
	result = _BNCreateHighLevelILFunction(arch, func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateHighLevelILFunctionGraph

_BNCreateHighLevelILFunctionGraph = core.BNCreateHighLevelILFunctionGraph
_BNCreateHighLevelILFunctionGraph.restype = ctypes.POINTER(BNFlowGraph)
_BNCreateHighLevelILFunctionGraph.argtypes = [
		ctypes.POINTER(BNHighLevelILFunction),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateHighLevelILFunctionGraph(
		func: ctypes.POINTER(BNHighLevelILFunction), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNFlowGraph)]:
	result = _BNCreateHighLevelILFunctionGraph(func, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateIntegerType

_BNCreateIntegerType = core.BNCreateIntegerType
_BNCreateIntegerType.restype = ctypes.POINTER(BNType)
_BNCreateIntegerType.argtypes = [
		ctypes.c_ulonglong,
		ctypes.POINTER(BNBoolWithConfidence),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNCreateIntegerType(
		width: int, 
		sign: ctypes.POINTER(BNBoolWithConfidence), 
		altName: Optional[str]
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNCreateIntegerType(width, sign, cstr(altName))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateIntegerTypeBuilder

_BNCreateIntegerTypeBuilder = core.BNCreateIntegerTypeBuilder
_BNCreateIntegerTypeBuilder.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreateIntegerTypeBuilder.argtypes = [
		ctypes.c_ulonglong,
		ctypes.POINTER(BNBoolWithConfidence),
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNCreateIntegerTypeBuilder(
		width: int, 
		sign: ctypes.POINTER(BNBoolWithConfidence), 
		altName: Optional[str]
		) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
	result = _BNCreateIntegerTypeBuilder(width, sign, cstr(altName))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateKeyValueStore

_BNCreateKeyValueStore = core.BNCreateKeyValueStore
_BNCreateKeyValueStore.restype = ctypes.POINTER(BNKeyValueStore)
_BNCreateKeyValueStore.argtypes = [
	]


# noinspection PyPep8Naming
def BNCreateKeyValueStore(
		) -> Optional[ctypes.POINTER(BNKeyValueStore)]:
	result = _BNCreateKeyValueStore()
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateKeyValueStoreFromDataBuffer

_BNCreateKeyValueStoreFromDataBuffer = core.BNCreateKeyValueStoreFromDataBuffer
_BNCreateKeyValueStoreFromDataBuffer.restype = ctypes.POINTER(BNKeyValueStore)
_BNCreateKeyValueStoreFromDataBuffer.argtypes = [
		ctypes.POINTER(BNDataBuffer),
	]


# noinspection PyPep8Naming
def BNCreateKeyValueStoreFromDataBuffer(
		buffer: ctypes.POINTER(BNDataBuffer)
		) -> Optional[ctypes.POINTER(BNKeyValueStore)]:
	result = _BNCreateKeyValueStoreFromDataBuffer(buffer)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLanguageRepresentationFunction

_BNCreateLanguageRepresentationFunction = core.BNCreateLanguageRepresentationFunction
_BNCreateLanguageRepresentationFunction.restype = ctypes.POINTER(BNLanguageRepresentationFunction)
_BNCreateLanguageRepresentationFunction.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNCreateLanguageRepresentationFunction(
		arch: ctypes.POINTER(BNArchitecture), 
		func: ctypes.POINTER(BNFunction)
		) -> Optional[ctypes.POINTER(BNLanguageRepresentationFunction)]:
	result = _BNCreateLanguageRepresentationFunction(arch, func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewCursor

_BNCreateLinearViewCursor = core.BNCreateLinearViewCursor
_BNCreateLinearViewCursor.restype = ctypes.POINTER(BNLinearViewCursor)
_BNCreateLinearViewCursor.argtypes = [
		ctypes.POINTER(BNLinearViewObject),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewCursor(
		root: ctypes.POINTER(BNLinearViewObject)
		) -> Optional[ctypes.POINTER(BNLinearViewCursor)]:
	result = _BNCreateLinearViewCursor(root)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewDataOnly

_BNCreateLinearViewDataOnly = core.BNCreateLinearViewDataOnly
_BNCreateLinearViewDataOnly.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewDataOnly.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewDataOnly(
		view: ctypes.POINTER(BNBinaryView), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewDataOnly(view, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewDisassembly

_BNCreateLinearViewDisassembly = core.BNCreateLinearViewDisassembly
_BNCreateLinearViewDisassembly.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewDisassembly.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewDisassembly(
		view: ctypes.POINTER(BNBinaryView), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewDisassembly(view, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewHighLevelIL

_BNCreateLinearViewHighLevelIL = core.BNCreateLinearViewHighLevelIL
_BNCreateLinearViewHighLevelIL.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewHighLevelIL.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewHighLevelIL(
		view: ctypes.POINTER(BNBinaryView), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewHighLevelIL(view, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewHighLevelILSSAForm

_BNCreateLinearViewHighLevelILSSAForm = core.BNCreateLinearViewHighLevelILSSAForm
_BNCreateLinearViewHighLevelILSSAForm.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewHighLevelILSSAForm.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewHighLevelILSSAForm(
		view: ctypes.POINTER(BNBinaryView), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewHighLevelILSSAForm(view, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewLanguageRepresentation

_BNCreateLinearViewLanguageRepresentation = core.BNCreateLinearViewLanguageRepresentation
_BNCreateLinearViewLanguageRepresentation.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewLanguageRepresentation.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewLanguageRepresentation(
		view: ctypes.POINTER(BNBinaryView), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewLanguageRepresentation(view, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewLiftedIL

_BNCreateLinearViewLiftedIL = core.BNCreateLinearViewLiftedIL
_BNCreateLinearViewLiftedIL.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewLiftedIL.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewLiftedIL(
		view: ctypes.POINTER(BNBinaryView), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewLiftedIL(view, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewLowLevelIL

_BNCreateLinearViewLowLevelIL = core.BNCreateLinearViewLowLevelIL
_BNCreateLinearViewLowLevelIL.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewLowLevelIL.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewLowLevelIL(
		view: ctypes.POINTER(BNBinaryView), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewLowLevelIL(view, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewLowLevelILSSAForm

_BNCreateLinearViewLowLevelILSSAForm = core.BNCreateLinearViewLowLevelILSSAForm
_BNCreateLinearViewLowLevelILSSAForm.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewLowLevelILSSAForm.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewLowLevelILSSAForm(
		view: ctypes.POINTER(BNBinaryView), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewLowLevelILSSAForm(view, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewMappedMediumLevelIL

_BNCreateLinearViewMappedMediumLevelIL = core.BNCreateLinearViewMappedMediumLevelIL
_BNCreateLinearViewMappedMediumLevelIL.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewMappedMediumLevelIL.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewMappedMediumLevelIL(
		view: ctypes.POINTER(BNBinaryView), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewMappedMediumLevelIL(view, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewMappedMediumLevelILSSAForm

_BNCreateLinearViewMappedMediumLevelILSSAForm = core.BNCreateLinearViewMappedMediumLevelILSSAForm
_BNCreateLinearViewMappedMediumLevelILSSAForm.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewMappedMediumLevelILSSAForm.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewMappedMediumLevelILSSAForm(
		view: ctypes.POINTER(BNBinaryView), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewMappedMediumLevelILSSAForm(view, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewMediumLevelIL

_BNCreateLinearViewMediumLevelIL = core.BNCreateLinearViewMediumLevelIL
_BNCreateLinearViewMediumLevelIL.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewMediumLevelIL.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewMediumLevelIL(
		view: ctypes.POINTER(BNBinaryView), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewMediumLevelIL(view, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewMediumLevelILSSAForm

_BNCreateLinearViewMediumLevelILSSAForm = core.BNCreateLinearViewMediumLevelILSSAForm
_BNCreateLinearViewMediumLevelILSSAForm.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewMediumLevelILSSAForm.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewMediumLevelILSSAForm(
		view: ctypes.POINTER(BNBinaryView), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewMediumLevelILSSAForm(view, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewSingleFunctionDisassembly

_BNCreateLinearViewSingleFunctionDisassembly = core.BNCreateLinearViewSingleFunctionDisassembly
_BNCreateLinearViewSingleFunctionDisassembly.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewSingleFunctionDisassembly.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewSingleFunctionDisassembly(
		func: ctypes.POINTER(BNFunction), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewSingleFunctionDisassembly(func, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewSingleFunctionHighLevelIL

_BNCreateLinearViewSingleFunctionHighLevelIL = core.BNCreateLinearViewSingleFunctionHighLevelIL
_BNCreateLinearViewSingleFunctionHighLevelIL.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewSingleFunctionHighLevelIL.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewSingleFunctionHighLevelIL(
		func: ctypes.POINTER(BNFunction), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewSingleFunctionHighLevelIL(func, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewSingleFunctionHighLevelILSSAForm

_BNCreateLinearViewSingleFunctionHighLevelILSSAForm = core.BNCreateLinearViewSingleFunctionHighLevelILSSAForm
_BNCreateLinearViewSingleFunctionHighLevelILSSAForm.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewSingleFunctionHighLevelILSSAForm.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewSingleFunctionHighLevelILSSAForm(
		func: ctypes.POINTER(BNFunction), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewSingleFunctionHighLevelILSSAForm(func, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewSingleFunctionLanguageRepresentation

_BNCreateLinearViewSingleFunctionLanguageRepresentation = core.BNCreateLinearViewSingleFunctionLanguageRepresentation
_BNCreateLinearViewSingleFunctionLanguageRepresentation.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewSingleFunctionLanguageRepresentation.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewSingleFunctionLanguageRepresentation(
		func: ctypes.POINTER(BNFunction), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewSingleFunctionLanguageRepresentation(func, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewSingleFunctionLiftedIL

_BNCreateLinearViewSingleFunctionLiftedIL = core.BNCreateLinearViewSingleFunctionLiftedIL
_BNCreateLinearViewSingleFunctionLiftedIL.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewSingleFunctionLiftedIL.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewSingleFunctionLiftedIL(
		func: ctypes.POINTER(BNFunction), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewSingleFunctionLiftedIL(func, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewSingleFunctionLowLevelIL

_BNCreateLinearViewSingleFunctionLowLevelIL = core.BNCreateLinearViewSingleFunctionLowLevelIL
_BNCreateLinearViewSingleFunctionLowLevelIL.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewSingleFunctionLowLevelIL.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewSingleFunctionLowLevelIL(
		func: ctypes.POINTER(BNFunction), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewSingleFunctionLowLevelIL(func, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewSingleFunctionLowLevelILSSAForm

_BNCreateLinearViewSingleFunctionLowLevelILSSAForm = core.BNCreateLinearViewSingleFunctionLowLevelILSSAForm
_BNCreateLinearViewSingleFunctionLowLevelILSSAForm.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewSingleFunctionLowLevelILSSAForm.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewSingleFunctionLowLevelILSSAForm(
		func: ctypes.POINTER(BNFunction), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewSingleFunctionLowLevelILSSAForm(func, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewSingleFunctionMappedMediumLevelIL

_BNCreateLinearViewSingleFunctionMappedMediumLevelIL = core.BNCreateLinearViewSingleFunctionMappedMediumLevelIL
_BNCreateLinearViewSingleFunctionMappedMediumLevelIL.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewSingleFunctionMappedMediumLevelIL.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewSingleFunctionMappedMediumLevelIL(
		func: ctypes.POINTER(BNFunction), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewSingleFunctionMappedMediumLevelIL(func, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewSingleFunctionMappedMediumLevelILSSAForm

_BNCreateLinearViewSingleFunctionMappedMediumLevelILSSAForm = core.BNCreateLinearViewSingleFunctionMappedMediumLevelILSSAForm
_BNCreateLinearViewSingleFunctionMappedMediumLevelILSSAForm.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewSingleFunctionMappedMediumLevelILSSAForm.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewSingleFunctionMappedMediumLevelILSSAForm(
		func: ctypes.POINTER(BNFunction), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewSingleFunctionMappedMediumLevelILSSAForm(func, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewSingleFunctionMediumLevelIL

_BNCreateLinearViewSingleFunctionMediumLevelIL = core.BNCreateLinearViewSingleFunctionMediumLevelIL
_BNCreateLinearViewSingleFunctionMediumLevelIL.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewSingleFunctionMediumLevelIL.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewSingleFunctionMediumLevelIL(
		func: ctypes.POINTER(BNFunction), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewSingleFunctionMediumLevelIL(func, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLinearViewSingleFunctionMediumLevelILSSAForm

_BNCreateLinearViewSingleFunctionMediumLevelILSSAForm = core.BNCreateLinearViewSingleFunctionMediumLevelILSSAForm
_BNCreateLinearViewSingleFunctionMediumLevelILSSAForm.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewSingleFunctionMediumLevelILSSAForm.argtypes = [
		ctypes.POINTER(BNFunction),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLinearViewSingleFunctionMediumLevelILSSAForm(
		func: ctypes.POINTER(BNFunction), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
	result = _BNCreateLinearViewSingleFunctionMediumLevelILSSAForm(func, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLowLevelILDisassemblyTextRenderer

_BNCreateLowLevelILDisassemblyTextRenderer = core.BNCreateLowLevelILDisassemblyTextRenderer
_BNCreateLowLevelILDisassemblyTextRenderer.restype = ctypes.POINTER(BNDisassemblyTextRenderer)
_BNCreateLowLevelILDisassemblyTextRenderer.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLowLevelILDisassemblyTextRenderer(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNDisassemblyTextRenderer)]:
	result = _BNCreateLowLevelILDisassemblyTextRenderer(func, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLowLevelILFunction

_BNCreateLowLevelILFunction = core.BNCreateLowLevelILFunction
_BNCreateLowLevelILFunction.restype = ctypes.POINTER(BNLowLevelILFunction)
_BNCreateLowLevelILFunction.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNCreateLowLevelILFunction(
		arch: ctypes.POINTER(BNArchitecture), 
		func: ctypes.POINTER(BNFunction)
		) -> Optional[ctypes.POINTER(BNLowLevelILFunction)]:
	result = _BNCreateLowLevelILFunction(arch, func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateLowLevelILFunctionGraph

_BNCreateLowLevelILFunctionGraph = core.BNCreateLowLevelILFunctionGraph
_BNCreateLowLevelILFunctionGraph.restype = ctypes.POINTER(BNFlowGraph)
_BNCreateLowLevelILFunctionGraph.argtypes = [
		ctypes.POINTER(BNLowLevelILFunction),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateLowLevelILFunctionGraph(
		func: ctypes.POINTER(BNLowLevelILFunction), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNFlowGraph)]:
	result = _BNCreateLowLevelILFunctionGraph(func, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateMediumLevelILDisassemblyTextRenderer

_BNCreateMediumLevelILDisassemblyTextRenderer = core.BNCreateMediumLevelILDisassemblyTextRenderer
_BNCreateMediumLevelILDisassemblyTextRenderer.restype = ctypes.POINTER(BNDisassemblyTextRenderer)
_BNCreateMediumLevelILDisassemblyTextRenderer.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateMediumLevelILDisassemblyTextRenderer(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNDisassemblyTextRenderer)]:
	result = _BNCreateMediumLevelILDisassemblyTextRenderer(func, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateMediumLevelILFunction

_BNCreateMediumLevelILFunction = core.BNCreateMediumLevelILFunction
_BNCreateMediumLevelILFunction.restype = ctypes.POINTER(BNMediumLevelILFunction)
_BNCreateMediumLevelILFunction.argtypes = [
		ctypes.POINTER(BNArchitecture),
		ctypes.POINTER(BNFunction),
	]


# noinspection PyPep8Naming
def BNCreateMediumLevelILFunction(
		arch: ctypes.POINTER(BNArchitecture), 
		func: ctypes.POINTER(BNFunction)
		) -> Optional[ctypes.POINTER(BNMediumLevelILFunction)]:
	result = _BNCreateMediumLevelILFunction(arch, func)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateMediumLevelILFunctionGraph

_BNCreateMediumLevelILFunctionGraph = core.BNCreateMediumLevelILFunctionGraph
_BNCreateMediumLevelILFunctionGraph.restype = ctypes.POINTER(BNFlowGraph)
_BNCreateMediumLevelILFunctionGraph.argtypes = [
		ctypes.POINTER(BNMediumLevelILFunction),
		ctypes.POINTER(BNDisassemblySettings),
	]


# noinspection PyPep8Naming
def BNCreateMediumLevelILFunctionGraph(
		func: ctypes.POINTER(BNMediumLevelILFunction), 
		settings: ctypes.POINTER(BNDisassemblySettings)
		) -> Optional[ctypes.POINTER(BNFlowGraph)]:
	result = _BNCreateMediumLevelILFunctionGraph(func, settings)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateMetadataArray

_BNCreateMetadataArray = core.BNCreateMetadataArray
_BNCreateMetadataArray.restype = ctypes.POINTER(BNMetadata)
_BNCreateMetadataArray.argtypes = [
		ctypes.POINTER(ctypes.POINTER(BNMetadata)),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNCreateMetadataArray(
		data: ctypes.POINTER(ctypes.POINTER(BNMetadata)), 
		size: int
		) -> Optional[ctypes.POINTER(BNMetadata)]:
	result = _BNCreateMetadataArray(data, size)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateMetadataBooleanData

_BNCreateMetadataBooleanData = core.BNCreateMetadataBooleanData
_BNCreateMetadataBooleanData.restype = ctypes.POINTER(BNMetadata)
_BNCreateMetadataBooleanData.argtypes = [
		ctypes.c_bool,
	]


# noinspection PyPep8Naming
def BNCreateMetadataBooleanData(
		data: bool
		) -> Optional[ctypes.POINTER(BNMetadata)]:
	result = _BNCreateMetadataBooleanData(data)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateMetadataBooleanListData

_BNCreateMetadataBooleanListData = core.BNCreateMetadataBooleanListData
_BNCreateMetadataBooleanListData.restype = ctypes.POINTER(BNMetadata)
_BNCreateMetadataBooleanListData.argtypes = [
		ctypes.POINTER(ctypes.c_bool),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNCreateMetadataBooleanListData(
		data: ctypes.POINTER(ctypes.c_bool), 
		size: int
		) -> Optional[ctypes.POINTER(BNMetadata)]:
	result = _BNCreateMetadataBooleanListData(data, size)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateMetadataDoubleData

_BNCreateMetadataDoubleData = core.BNCreateMetadataDoubleData
_BNCreateMetadataDoubleData.restype = ctypes.POINTER(BNMetadata)
_BNCreateMetadataDoubleData.argtypes = [
		ctypes.c_double,
	]


# noinspection PyPep8Naming
def BNCreateMetadataDoubleData(
		data: float
		) -> Optional[ctypes.POINTER(BNMetadata)]:
	result = _BNCreateMetadataDoubleData(data)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateMetadataDoubleListData

_BNCreateMetadataDoubleListData = core.BNCreateMetadataDoubleListData
_BNCreateMetadataDoubleListData.restype = ctypes.POINTER(BNMetadata)
_BNCreateMetadataDoubleListData.argtypes = [
		ctypes.POINTER(ctypes.c_double),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNCreateMetadataDoubleListData(
		data: ctypes.POINTER(ctypes.c_double), 
		size: int
		) -> Optional[ctypes.POINTER(BNMetadata)]:
	result = _BNCreateMetadataDoubleListData(data, size)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateMetadataOfType

_BNCreateMetadataOfType = core.BNCreateMetadataOfType
_BNCreateMetadataOfType.restype = ctypes.POINTER(BNMetadata)
_BNCreateMetadataOfType.argtypes = [
		MetadataTypeEnum,
	]


# noinspection PyPep8Naming
def BNCreateMetadataOfType(
		type: MetadataTypeEnum
		) -> Optional[ctypes.POINTER(BNMetadata)]:
	result = _BNCreateMetadataOfType(type)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateMetadataRawData

_BNCreateMetadataRawData = core.BNCreateMetadataRawData
_BNCreateMetadataRawData.restype = ctypes.POINTER(BNMetadata)
_BNCreateMetadataRawData.argtypes = [
		ctypes.POINTER(ctypes.c_ubyte),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNCreateMetadataRawData(
		data: ctypes.POINTER(ctypes.c_ubyte), 
		size: int
		) -> Optional[ctypes.POINTER(BNMetadata)]:
	result = _BNCreateMetadataRawData(data, size)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateMetadataSignedIntegerData

_BNCreateMetadataSignedIntegerData = core.BNCreateMetadataSignedIntegerData
_BNCreateMetadataSignedIntegerData.restype = ctypes.POINTER(BNMetadata)
_BNCreateMetadataSignedIntegerData.argtypes = [
		ctypes.c_longlong,
	]


# noinspection PyPep8Naming
def BNCreateMetadataSignedIntegerData(
		data: int
		) -> Optional[ctypes.POINTER(BNMetadata)]:
	result = _BNCreateMetadataSignedIntegerData(data)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateMetadataSignedIntegerListData

_BNCreateMetadataSignedIntegerListData = core.BNCreateMetadataSignedIntegerListData
_BNCreateMetadataSignedIntegerListData.restype = ctypes.POINTER(BNMetadata)
_BNCreateMetadataSignedIntegerListData.argtypes = [
		ctypes.POINTER(ctypes.c_longlong),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNCreateMetadataSignedIntegerListData(
		data: ctypes.POINTER(ctypes.c_longlong), 
		size: int
		) -> Optional[ctypes.POINTER(BNMetadata)]:
	result = _BNCreateMetadataSignedIntegerListData(data, size)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateMetadataStringData

_BNCreateMetadataStringData = core.BNCreateMetadataStringData
_BNCreateMetadataStringData.restype = ctypes.POINTER(BNMetadata)
_BNCreateMetadataStringData.argtypes = [
		ctypes.c_char_p,
	]


# noinspection PyPep8Naming
def BNCreateMetadataStringData(
		data: Optional[str]
		) -> Optional[ctypes.POINTER(BNMetadata)]:
	result = _BNCreateMetadataStringData(cstr(data))
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateMetadataStringListData

_BNCreateMetadataStringListData = core.BNCreateMetadataStringListData
_BNCreateMetadataStringListData.restype = ctypes.POINTER(BNMetadata)
_BNCreateMetadataStringListData.argtypes = [
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNCreateMetadataStringListData(
		data: ctypes.POINTER(ctypes.c_char_p), 
		size: int
		) -> Optional[ctypes.POINTER(BNMetadata)]:
	result = _BNCreateMetadataStringListData(data, size)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateMetadataUnsignedIntegerData

_BNCreateMetadataUnsignedIntegerData = core.BNCreateMetadataUnsignedIntegerData
_BNCreateMetadataUnsignedIntegerData.restype = ctypes.POINTER(BNMetadata)
_BNCreateMetadataUnsignedIntegerData.argtypes = [
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNCreateMetadataUnsignedIntegerData(
		data: int
		) -> Optional[ctypes.POINTER(BNMetadata)]:
	result = _BNCreateMetadataUnsignedIntegerData(data)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateMetadataUnsignedIntegerListData

_BNCreateMetadataUnsignedIntegerListData = core.BNCreateMetadataUnsignedIntegerListData
_BNCreateMetadataUnsignedIntegerListData.restype = ctypes.POINTER(BNMetadata)
_BNCreateMetadataUnsignedIntegerListData.argtypes = [
		ctypes.POINTER(ctypes.c_ulonglong),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNCreateMetadataUnsignedIntegerListData(
		data: ctypes.POINTER(ctypes.c_ulonglong), 
		size: int
		) -> Optional[ctypes.POINTER(BNMetadata)]:
	result = _BNCreateMetadataUnsignedIntegerListData(data, size)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateMetadataValueStore

_BNCreateMetadataValueStore = core.BNCreateMetadataValueStore
_BNCreateMetadataValueStore.restype = ctypes.POINTER(BNMetadata)
_BNCreateMetadataValueStore.argtypes = [
		ctypes.POINTER(ctypes.c_char_p),
		ctypes.POINTER(ctypes.POINTER(BNMetadata)),
		ctypes.c_ulonglong,
	]


# noinspection PyPep8Naming
def BNCreateMetadataValueStore(
		keys: ctypes.POINTER(ctypes.c_char_p), 
		values: ctypes.POINTER(ctypes.POINTER(BNMetadata)), 
		size: int
		) -> Optional[ctypes.POINTER(BNMetadata)]:
	result = _BNCreateMetadataValueStore(keys, values, size)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateNamedType

_BNCreateNamedType = core.BNCreateNamedType
_BNCreateNamedType.restype = ctypes.POINTER(BNNamedTypeReference)
_BNCreateNamedType.argtypes = [
		NamedTypeReferenceClassEnum,
		ctypes.c_char_p,
		ctypes.POINTER(BNQualifiedName),
	]


# noinspection PyPep8Naming
def BNCreateNamedType(
		cls: NamedTypeReferenceClassEnum, 
		id: Optional[str], 
		name: ctypes.POINTER(BNQualifiedName)
		) -> Optional[ctypes.POINTER(BNNamedTypeReference)]:
	result = _BNCreateNamedType(cls, cstr(id), name)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateNamedTypeBuilder

_BNCreateNamedTypeBuilder = core.BNCreateNamedTypeBuilder
_BNCreateNamedTypeBuilder.restype = ctypes.POINTER(BNNamedTypeReferenceBuilder)
_BNCreateNamedTypeBuilder.argtypes = [
		NamedTypeReferenceClassEnum,
		ctypes.c_char_p,
		ctypes.POINTER(BNQualifiedName),
	]


# noinspection PyPep8Naming
def BNCreateNamedTypeBuilder(
		cls: NamedTypeReferenceClassEnum, 
		id: Optional[str], 
		name: ctypes.POINTER(BNQualifiedName)
		) -> Optional[ctypes.POINTER(BNNamedTypeReferenceBuilder)]:
	result = _BNCreateNamedTypeBuilder(cls, cstr(id), name)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateNamedTypeReference

_BNCreateNamedTypeReference = core.BNCreateNamedTypeReference
_BNCreateNamedTypeReference.restype = ctypes.POINTER(BNType)
_BNCreateNamedTypeReference.argtypes = [
		ctypes.POINTER(BNNamedTypeReference),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.POINTER(BNBoolWithConfidence),
		ctypes.POINTER(BNBoolWithConfidence),
	]


# noinspection PyPep8Naming
def BNCreateNamedTypeReference(
		nt: ctypes.POINTER(BNNamedTypeReference), 
		width: int, 
		align: int, 
		cnst: ctypes.POINTER(BNBoolWithConfidence), 
		vltl: ctypes.POINTER(BNBoolWithConfidence)
		) -> Optional[ctypes.POINTER(BNType)]:
	result = _BNCreateNamedTypeReference(nt, width, align, cnst, vltl)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateNamedTypeReferenceBuilder

_BNCreateNamedTypeReferenceBuilder = core.BNCreateNamedTypeReferenceBuilder
_BNCreateNamedTypeReferenceBuilder.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreateNamedTypeReferenceBuilder.argtypes = [
		ctypes.POINTER(BNNamedTypeReference),
		ctypes.c_ulonglong,
		ctypes.c_ulonglong,
		ctypes.POINTER(BNBoolWithConfidence),
		ctypes.POINTER(BNBoolWithConfidence),
	]


# noinspection PyPep8Naming
def BNCreateNamedTypeReferenceBuilder(
		nt: ctypes.POINTER(BNNamedTypeReference), 
		width: int, 
		align: int, 
		cnst: ctypes.POINTER(BNBoolWithConfidence), 
		vltl: ctypes.POINTER(BNBoolWithConfidence)
		) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
	result = _BNCreateNamedTypeReferenceBuilder(nt, width, align, cnst, vltl)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateNamedTypeReferenceBuilderFromType

_BNCreateNamedTypeReferenceBuilderFromType = core.BNCreateNamedTypeReferenceBuilderFromType
_BNCreateNamedTypeReferenceBuilderFromType.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreateNamedTypeReferenceBuilderFromType.argtypes = [
		ctypes.POINTER(BNBinaryView),
		ctypes.POINTER(BNQualifiedName),
	]


# noinspection PyPep8Naming
def BNCreateNamedTypeReferenceBuilderFromType(
		view: ctypes.POINTER(BNBinaryView), 
		name: ctypes.POINTER(BNQualifiedName)
		) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
	result = _BNCreateNamedTypeReferenceBuilderFromType(view, name)
	if not result:
		return None
	return result


# -------------------------------------------------------
# _BNCreateNamedTypeReferenceBuilderFromTypeAndId

_BNCreateNamedTypeReferenceBuilderFromTypeAndId = core.BNCreateNamedTypeReferenceBuilderFromTypeAndId
_BNCreateNamedTypeReferenceBuilderFromTypeAndId.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreateNamedTypeReferenceBuilderFromTypeAndId.argtypes = [
		ctypes.c_char_p,
		ctypes.POINTER(BNQualifiedName),
		ctypes.POINTER(BNType),
	]


# noinspection PyPep8Naming
def BNCreateNamedTypeReferenceBuilderFromTypeAndId(
		id: Optional[str], 
		name: ctypes.POINTER(BNQualifiedName), 
		type: ctypes.POINTER(BNType)
		) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
	result = _BNCreateNamedTypeReferenceBuilderFromTypeAndId(cstr(id