package vendor:darwin/Foundation

Source

ActivationPolicy :: enum UInteger {
	Regular    = 0, 
	Accessory  = 1, 
	Prohibited = 2, 
}

Application :: struct {
	_: Object,
}

ApplicationDelegate :: struct {
	willFinishLaunching:                  proc "cdecl" (self: ^ApplicationDelegate, notification: ^Notification),
	didFinishLaunching:                   proc "cdecl" (self: ^ApplicationDelegate, notification: ^Notification),
	shouldTerminateAfterLastWindowClosed: proc "cdecl" (self: ^ApplicationDelegate, sender: ^Application),
	user_data:                            rawptr,
}

Array :: struct {
	_: Copying(Array),
}

AutoreleasePool :: struct {
	_: Object,
}

BOOL :: bool

BackingStoreType :: enum UInteger {
	Retained    = 0, 
	Nonretained = 1, 
	Buffered    = 2, 
}

Block :: struct {
	_: Object,
}

Bundle :: struct {
	_: Object,
}

Class :: ^.objc_class

Coder :: struct {
	_: Object,
}

Color :: struct {
	_: Object,
}

ComparisonResult :: enum Integer {
	OrderedAscending  = -1, 
	OrderedSame       = 0, 
	OrderedDescending = 1, 
}

Condition :: struct {
	_: Locking(Condition),
}

Copying :: struct($Key: typeid, $Value: typeid) where intrinsics.type_is_valid_map_key(Key) {}

Data :: struct {
	_: Copying(Data),
}

Date :: struct {
	_: Copying(Date),
}

Dictionary :: struct {
	_: Copying(Dictionary),
}

Enumerator :: struct($Key: typeid, $Value: typeid) where intrinsics.type_is_valid_map_key(Key) {}

Error :: struct {
	_: Copying(Error),
}

ErrorDomain :: ^String

ErrorUserInfoKey :: ^String

FastEnumeration :: struct {
	_: Object,
}

FastEnumerationState :: struct #packed {
	state:        u32,
	itemsPtr:     [^]^Object,
	mutationsPtr: [^]u32,
	extra:        [5]u32,
}

Float :: distinct f64

IMP :: proc "cdecl" (object: ^.objc_object, sel: ^.objc_selector, args: ..any) -> ^.objc_object

Integer :: distinct int

KeyEquivalentModifierFlag :: enum UInteger {
	CapsLock   = 16, // Set if Caps Lock key is pressed.
	Shift      = 17, // Set if Shift key is pressed.
	Control    = 18, // Set if Control key is pressed.
	Option     = 19, // Set if Option or Alternate key is pressed.
	Command    = 20, // Set if Command key is pressed.
	NumericPad = 21, // Set if any key in the numeric keypad is pressed.
	Help       = 22, // Set if the Help key is pressed.
	Function   = 23, // Set if any function key is pressed.
}

KeyEquivalentModifierMask :: distinct bit_set[KeyEquivalentModifierFlag; UInteger]

Layer :: struct {
	_: Object,
}

Locking :: struct($Key: typeid, $Value: typeid) where intrinsics.type_is_valid_map_key(Key) {}

Menu :: struct {
	_: Object,
}

MenuItem :: struct {
	_: Object,
}

MenuItemCallback :: proc "cdecl" (unused: rawptr, name: ^.objc_selector, sender: ^Object)

Method :: ^objc_method

Notification :: struct {
	_: Object,
}

Number :: struct {
	_: Copying(Number),
	_: Value,
}

Object :: struct {
	_: .objc_object,
}

OperatingSystemVersion :: struct #packed {
	majorVersion: Integer,
	minorVersion: Integer,
	patchVersion: Integer,
}

Point :: struct {
	x: Float,
	y: Float,
}

Protocol :: struct {
	_: .objc_object,
}

Range :: struct {
	location: UInteger,
	length:   UInteger,
}

Rect :: struct {
	origin: Point,
	size:   Size,
}

Responder :: struct {
	_: Object,
}

RunningApplication :: struct {
	_: Object,
}

SEL :: ^.objc_selector

Size :: struct {
	width:  Float,
	height: Float,
}

String :: struct {
	_: Copying(String),
}

StringCompareOption :: enum UInteger {
	CaseInsensitive      = 0, 
	LiteralSearch        = 1, 
	BackwardsSearch      = 2, 
	AnchoredSearch       = 3, 
	NumericSearch        = 6, 
	DiacriticInsensitive = 7, 
	WidthInsensitive     = 8, 
	ForcedOrdering       = 9, 
	RegularExpression    = 10, 
}

StringCompareOptions :: distinct bit_set[StringCompareOption; UInteger]

StringEncoding :: enum UInteger {
	ASCII             = 1, 
	NEXTSTEP          = 2, 
	JapaneseEUC       = 3, 
	UTF8              = 4, 
	ISOLatin1         = 5, 
	Symbol            = 6, 
	NonLossyASCII     = 7, 
	ShiftJIS          = 8, 
	ISOLatin2         = 9, 
	Unicode           = 10, 
	WindowsCP1251     = 11, 
	WindowsCP1252     = 12, 
	WindowsCP1253     = 13, 
	WindowsCP1254     = 14, 
	WindowsCP1250     = 15, 
	ISO2022JP         = 21, 
	MacOSRoman        = 30, 
	UTF16             = 10, 
	UTF16BigEndian    = 2415919360, 
	UTF16LittleEndian = 2483028224, 
	UTF32             = 2348810496, 
	UTF32BigEndian    = 2550137088, 
	UTF32LittleEndian = 2617245952, 
}

TimeInterval :: distinct f64

UInteger :: distinct uint

URL :: struct {
	_: Copying(URL),
}

Value :: struct {
	_: Copying(Value),
}

View :: struct {
	_: Responder,
}

Window :: struct {
	_: Responder,
}

WindowStyleFlag :: enum UInteger {
	Titled                 = 0, 
	Closable               = 1, 
	Miniaturizable         = 2, 
	Resizable              = 3, 
	TexturedBackground     = 8, 
	UnifiedTitleAndToolbar = 12, 
	FullScreen             = 14, 
	FullSizeContentView    = 15, 
	UtilityWindow          = 4, 
	DocModalWindow         = 6, 
	NonactivatingPanel     = 7, 
	HUDWindow              = 13, 
}

WindowStyleMask :: distinct bit_set[WindowStyleFlag; UInteger]

Zone :: struct {
	_: Object,
}

id :: ^.objc_object

objc_cache :: struct {
	mask:     u32,
	occupied: u32,
	buckets:  [1]^objc_method,
}

objc_class_internals :: struct {
	isa:           ^.objc_class,
	super_class:   ^.objc_class,
	name:          cstring,
	version:       i32,
	info:          i32,
	instance_size: i32,
	ivars:         ^objc_ivar_list,
	methodLists:   ^^objc_method_list,
	cache:         rawptr,
	protocols:     rawptr,
}

objc_ivar :: struct($Key: typeid, $Value: typeid) where intrinsics.type_is_valid_map_key(Key) {}

objc_ivar_list :: struct($Key: typeid, $Value: typeid) where intrinsics.type_is_valid_map_key(Key) {}

objc_method :: struct {
	method_name:  ^.objc_selector,
	method_types: cstring,
	method_imp:   IMP,
}

objc_method_list :: struct($Key: typeid, $Value: typeid) where intrinsics.type_is_valid_map_key(Key) {}

objc_object_internals :: struct {
	isa: ^objc_class_internals,
}

objc_protocol_list :: struct {
	next:  ^objc_protocol_list,
	count: i32,
	list:  [1]^Protocol,
}

unichar :: distinct u16

IntegerMax: Integer : max(Integer)

Integermin: Integer : min(Integer)

NO :: false

NotFound :: IntegerMax

UIntegerMax: UInteger : max(UInteger)

WindowStyleMaskBorderless :: WindowStyleMask{}

WindowStyleMaskClosable :: WindowStyleMask{.Closable}

WindowStyleMaskDocModalWindow :: WindowStyleMask{.DocModalWindow}

WindowStyleMaskFullScreen :: WindowStyleMask{.FullScreen}

WindowStyleMaskFullSizeContentView :: WindowStyleMask{.FullSizeContentView}

WindowStyleMaskHUDWindow :: WindowStyleMask{.HUDWindow}

WindowStyleMaskMiniaturizable :: WindowStyleMask{.Miniaturizable}

WindowStyleMaskNonactivatingPanel :: WindowStyleMask{.NonactivatingPanel}

WindowStyleMaskResizable :: WindowStyleMask{.Resizable}

WindowStyleMaskTexturedBackground :: WindowStyleMask{.TexturedBackground}

WindowStyleMaskTitled :: WindowStyleMask{.Titled}

WindowStyleMaskUnifiedTitleAndToolbar :: WindowStyleMask{.UnifiedTitleAndToolbar}

WindowStyleMaskUtilityWindow :: WindowStyleMask{.UtilityWindow}

YES :: true

@(linkage="weak")
CocoaErrorDomain: ^String

@(linkage="weak")
DebugDescriptionErrorKey: ^String

@(linkage="weak")
FilePathErrorKey: ^String

@(linkage="weak")
HelpAnchorErrorKey: ^String

KeyEventModifierFlagDeviceIndependentFlagsMask: KeyEquivalentModifierMask = …

@(linkage="weak")
LocalizedDescriptionKey: ^String

@(linkage="weak")
LocalizedFailureErrorKey: ^String

@(linkage="weak")
LocalizedFailureReasonErrorKey: ^String

@(linkage="weak")
LocalizedRecoveryOptionsErrorKey: ^String

@(linkage="weak")
LocalizedRecoverySuggestionErrorKey: ^String

@(linkage="weak")
MachErrorDomain: ^String

@(linkage="weak")
OSStatusErrorDomain: ^String

@(linkage="weak")
POSIXErrorDomain: ^String

@(linkage="weak")
RecoveryAttempterErrorKey: ^String

@(linkage="weak")
StringEncodingErrorKey: ^String

@(linkage="weak")
URLErrorKey: ^String

@(linkage="weak")
UnderlyingErrorKey: ^String

AT :: MakeConstantString

AllocateObject :: proc "cdecl" (aClass: ^.objc_class, extraBytes: UInteger, zone: ^Zone) -> ^.objc_object ---

Application_activateIgnoringOtherApps :: proc "odin" (self: ^Application, ignoreOtherApps: bool) {…}

Application_run :: proc "odin" (self: ^Application) {…}

Application_setActivationPolicy :: proc "odin" (self: ^Application, activationPolicy: ActivationPolicy) -> bool {…}

Application_setDelegate :: proc "odin" (self: ^Application, delegate: ^ApplicationDelegate) {…}

Application_setMainMenu :: proc "odin" (self: ^Application, menu: ^Menu) {…}

Application_sharedApplication :: proc "odin" () -> ^Application {…}

Application_terminate :: proc "odin" (self: ^Application, sender: ^Object) {…}

Application_windows :: proc "odin" (self: ^Application) -> ^Array {…}

Array_alloc :: proc "odin" () -> ^Array {…}

Array_count :: proc "odin" (self: ^Array) -> UInteger {…}

Array_init :: proc "odin" (self: ^Array) -> ^Array {…}

Array_initWithCoder :: proc "odin" (self: ^Array, coder: ^Coder) -> ^Array {…}

Array_initWithObjects :: proc "odin" (self: ^Array, objects: [^]^Object, count: UInteger) -> ^Array {…}

Array_object :: proc "odin" (self: ^Array, index: UInteger) -> ^Object {…}

Array_objectAs :: proc "odin" (self: ^Array, index: UInteger, $T: typeid) -> typeid {…}

AutoreleasePool_addObject :: proc "odin" (self: ^AutoreleasePool, obj: ^Object) {…}

AutoreleasePool_alloc :: proc "odin" () -> ^AutoreleasePool {…}

AutoreleasePool_drain :: proc "odin" (self: ^AutoreleasePool) {…}

AutoreleasePool_init :: proc "odin" (self: ^AutoreleasePool) -> ^AutoreleasePool {…}

AutoreleasePool_showPools :: proc "odin" (self: ^AutoreleasePool, obj: ^Object) {…}

Block_createGlobal :: proc "cdecl" (user_data: rawptr, user_proc: proc "cdecl" (_: rawptr)) -> ^Block {…}

Block_createLocal :: proc "cdecl" (user_data: rawptr, user_proc: proc "cdecl" (_: rawptr)) -> ^Block {…}

Bundle_PathForAuxiliaryExecutable :: proc "odin" (self: ^Bundle, executableName: ^String) -> ^String {…}

Bundle_URLForAuxiliaryExecutable :: proc "odin" (self: ^Bundle, executableName: ^String) -> ^URL {…}

Bundle_allBundles :: proc "odin" () -> ^Array {…}

Bundle_allFrameworks :: proc "odin" () -> ^Array {…}

Bundle_alloc :: proc "odin" () -> ^Bundle {…}

Bundle_appStoreReceiptPath :: proc "odin" (self: ^Bundle) -> ^String {…}

Bundle_appStoreReceiptURL :: proc "odin" (self: ^Bundle) -> ^URL {…}

Bundle_builtInPlugInsPath :: proc "odin" (self: ^Bundle) -> ^String {…}

Bundle_builtInPlugInsURL :: proc "odin" (self: ^Bundle) -> ^URL {…}

Bundle_bundleIdentifier :: proc "odin" (self: ^Bundle) -> ^String {…}

Bundle_bundlePath :: proc "odin" (self: ^Bundle) -> ^String {…}

Bundle_bundleURL :: proc "odin" (self: ^Bundle) -> ^URL {…}

Bundle_bundleWithPath :: proc "odin" (path: ^String) -> ^Bundle {…}

Bundle_bundleWithURL :: proc "odin" (url: ^URL) -> ^Bundle {…}

Bundle_executablePath :: proc "odin" (self: ^Bundle) -> ^String {…}

Bundle_executableURL :: proc "odin" (self: ^Bundle) -> ^URL {…}

Bundle_infoDictionary :: proc "odin" (self: ^Bundle) -> ^Dictionary {…}

Bundle_init :: proc "odin" (self: ^Bundle) -> ^Bundle {…}

Bundle_initWithPath :: proc "odin" (self: ^Bundle, path: ^String) -> ^Bundle {…}

Bundle_initWithURL :: proc "odin" (self: ^Bundle, url: ^URL) -> ^Bundle {…}

Bundle_isLoaded :: proc "odin" (self: ^Bundle) -> bool {…}

Bundle_load :: proc "odin" (self: ^Bundle) -> bool {…}

Bundle_loadAndReturnError :: proc "odin" (self: ^Bundle) -> (ok: bool, error: ^Error) {…}

Bundle_localizedInfoDictionary :: proc "odin" (self: ^Bundle) -> ^Dictionary {…}

Bundle_localizedStringForKey :: proc "odin" (self: ^Bundle, key: ^String, value: ^String = nil, tableName: ^String = nil) -> ^String {…}

Bundle_mainBundle :: proc "odin" () -> ^Bundle {…}

Bundle_objectForInfoDictionaryKey :: proc "odin" (self: ^Bundle, key: ^String) -> ^Object {…}

Bundle_preflightAndReturnError :: proc "odin" (self: ^Bundle) -> (ok: bool, error: ^Error) {…}

Bundle_privateFrameworksPath :: proc "odin" (self: ^Bundle) -> ^String {…}

Bundle_privateFrameworksURL :: proc "odin" (self: ^Bundle) -> ^URL {…}

Bundle_resourcePath :: proc "odin" (self: ^Bundle) -> ^String {…}

Bundle_resourceURL :: proc "odin" (self: ^Bundle) -> ^URL {…}

Bundle_sharedFrameworksPath :: proc "odin" (self: ^Bundle) -> ^String {…}

Bundle_sharedFrameworksURL :: proc "odin" (self: ^Bundle) -> ^URL {…}

Bundle_sharedSupportPath :: proc "odin" (self: ^Bundle) -> ^String {…}

Bundle_sharedSupportURL :: proc "odin" (self: ^Bundle) -> ^URL {…}

Bundle_unload :: proc "odin" (self: ^Bundle) -> bool {…}

Condition_alloc :: proc "odin" () -> ^Condition {…}

Condition_broadcast :: proc "odin" (self: ^Condition) {…}

Condition_init :: proc "odin" (self: ^Condition) -> ^Condition {…}

Condition_lock :: proc "odin" (self: ^Condition) {…}

Condition_signal :: proc "odin" (self: ^Condition) {…}

Condition_unlock :: proc "odin" (self: ^Condition) {…}

Condition_wait :: proc "odin" (self: ^Condition) {…}

Condition_waitUntilDate :: proc "odin" (self: ^Condition, limit: ^Date) -> bool {…}

Data_alloc :: proc "odin" () -> ^Data {…}

Data_init :: proc "odin" (self: ^Data) -> ^Data {…}

Data_length :: proc "odin" (self: ^Data) -> UInteger {…}

Data_mutableBytes :: proc "odin" (self: ^Data) -> rawptr {…}

Date_alloc :: proc "odin" () -> ^Date {…}

Date_dateWithTimeIntervalSinceNow :: proc "odin" (secs: TimeInterval) -> ^Date {…}

Date_init :: proc "odin" (self: ^Date) -> ^Date {…}

DeallocateObject :: proc "cdecl" (object: ^.objc_object) ---

Dictionary_alloc :: proc "odin" () -> ^Dictionary {…}

Dictionary_count :: proc "odin" (self: ^Dictionary) -> UInteger {…}

Dictionary_dictionary :: proc "odin" () -> ^Dictionary {…}

Dictionary_dictionaryWithObject :: proc "odin" (object: ^Object, forKey: ^Object) -> ^Dictionary {…}

Dictionary_dictionaryWithObjects :: proc "odin" (objects: [^]^Object, forKeys: [^]^Object, count: UInteger) -> ^Dictionary {…}

Dictionary_init :: proc "odin" (self: ^Dictionary) -> ^Dictionary {…}

Dictionary_initWithObjects :: proc "odin" (self: ^Dictionary, objects: [^]^Object, forKeys: [^]^Object, count: UInteger) -> ^Dictionary {…}

Dictionary_keyEnumerator :: proc "odin" (self: ^Dictionary, $KeyType: typeid) -> (enumerator: ^Enumerator(KeyType)) {…}

Dictionary_objectForKey :: proc "odin" (self: ^Dictionary, key: ^Object) -> ^Object {…}

Enumerator_allObjects :: proc "odin" (self: ^$E/Enumerator($T)) -> (all: ^Array) {…}

Enumerator_iterator :: proc "odin" (self: ^$E/Enumerator($T)) -> (obj: $, ok: bool) {…}

Enumerator_nextObject :: proc "odin" (self: ^$E/Enumerator($T)) -> $ {…}

Error_alloc :: proc "odin" () -> ^Error {…}

Error_code :: proc "odin" (self: ^Error) -> Integer {…}

Error_domain :: proc "odin" (self: ^Error) -> ^String {…}

Error_errorWithDomain :: proc "odin" (domain: ^String, code: Integer, userInfo: ^Dictionary) -> ^Error {…}

Error_init :: proc "odin" (self: ^Error) -> ^Error {…}

Error_initWithDomain :: proc "odin" (self: ^Error, domain: ^String, code: Integer, userInfo: ^Dictionary) -> ^Error {…}

Error_localizedDescription :: proc "odin" (self: ^Error) -> ^String {…}

Error_localizedFailureReason :: proc "odin" (self: ^Error) -> ^String {…}

Error_localizedRecoveryOptions :: proc "odin" (self: ^Error) -> (options: ^Array) {…}

Error_localizedRecoverySuggestion :: proc "odin" (self: ^Error) -> ^String {…}

Error_userInfo :: proc "odin" (self: ^Error) -> ^Dictionary {…}

FastEnumeration_alloc :: proc "odin" () -> ^FastEnumeration {…}

FastEnumeration_countByEnumerating :: proc "odin" (self: ^FastEnumeration, state: ^FastEnumerationState, buffer: [^]^Object, len: UInteger) -> UInteger {…}

FastEnumeration_init :: proc "odin" (self: ^FastEnumeration) -> ^FastEnumeration {…}

Layer_addSublayer :: proc "odin" (self: ^Layer, layer: ^Layer) {…}

Layer_contentsScale :: proc "odin" (self: ^Layer) -> Float {…}

Layer_frame :: proc "odin" (self: ^Layer) -> Rect {…}

Layer_setContentsScale :: proc "odin" (self: ^Layer, scale: Float) {…}

Locking_lock :: proc "odin" (self: ^Locking($T)) {…}

Locking_unlock :: proc "odin" (self: ^Locking($T)) {…}

MakeConstantString :: proc "cdecl" (#const c: cstring) -> ^String {…}

MenuItem_alloc :: proc "odin" () -> ^MenuItem {…}

MenuItem_init :: proc "odin" (self: ^MenuItem) -> ^MenuItem {…}

MenuItem_keyEquivalentModifierMask :: proc "odin" (self: ^MenuItem) -> KeyEquivalentModifierMask {…}

MenuItem_registerActionCallback :: proc "odin" (name: cstring, callback: MenuItemCallback) -> ^.objc_selector {…}

MenuItem_setKeyEquivalentModifierMask :: proc "odin" (self: ^MenuItem, modifierMask: KeyEquivalentModifierMask) {…}

MenuItem_setSubmenu :: proc "odin" (self: ^MenuItem, submenu: ^Menu) {…}

Menu_addItem :: proc "odin" (self: ^Menu, item: ^MenuItem) {…}

Menu_addItemWithTitle :: proc "odin" (self: ^Menu, title: ^String, selector: ^.objc_selector, keyEquivalent: ^String) -> ^MenuItem {…}

Menu_alloc :: proc "odin" () -> ^Menu {…}

Menu_init :: proc "odin" (self: ^Menu) -> ^Menu {…}

Menu_initWithTitle :: proc "odin" (self: ^Menu, title: ^String) -> ^Menu {…}

Notification_alloc :: proc "odin" () -> ^Notification {…}

Notification_init :: proc "odin" (self: ^Notification) -> ^Notification {…}

Notification_name :: proc "odin" (self: ^Notification) -> ^String {…}

Notification_object :: proc "odin" (self: ^Notification) -> ^Object {…}

Notification_userInfo :: proc "odin" (self: ^Notification) -> ^Dictionary {…}

Number_alloc :: proc "odin" () -> ^Number {…}

Number_boolValue :: proc "odin" (self: ^Number) -> bool {…}

Number_compare :: proc "odin" (self, other: ^Number) -> ComparisonResult {…}

Number_descriptionWithLocale :: proc "odin" (self: ^Number, locale: ^Object) -> ^String {…}

Number_f32Value :: proc "odin" (self: ^Number) -> f32 {…}

Number_f64Value :: proc "odin" (self: ^Number) -> f64 {…}

Number_i16Value :: proc "odin" (self: ^Number) -> i16 {…}

Number_i32Value :: proc "odin" (self: ^Number) -> i32 {…}

Number_i64Value :: proc "odin" (self: ^Number) -> i64 {…}

Number_i8Value :: proc "odin" (self: ^Number) -> i8 {…}

Number_init :: proc "odin" (self: ^Number) -> ^Number {…}

Number_initWithBool :: proc "odin" (self: ^Number, value: bool) -> ^Number {…}

Number_initWithF32 :: proc "odin" (self: ^Number, value: f32) -> ^Number {…}

Number_initWithF64 :: proc "odin" (self: ^Number, value: f64) -> ^Number {…}

Number_initWithI16 :: proc "odin" (self: ^Number, value: i16) -> ^Number {…}

Number_initWithI32 :: proc "odin" (self: ^Number, value: i32) -> ^Number {…}

Number_initWithI64 :: proc "odin" (self: ^Number, value: i64) -> ^Number {…}

Number_initWithI8 :: proc "odin" (self: ^Number, value: i8) -> ^Number {…}

Number_initWithInt :: proc "odin" (self: ^Number, value: int) -> ^Number {…}

Number_initWithU16 :: proc "odin" (self: ^Number, value: u16) -> ^Number {…}

Number_initWithU32 :: proc "odin" (self: ^Number, value: u32) -> ^Number {…}

Number_initWithU64 :: proc "odin" (self: ^Number, value: u64) -> ^Number {…}

Number_initWithU8 :: proc "odin" (self: ^Number, value: u8) -> ^Number {…}

Number_initWithUint :: proc "odin" (self: ^Number, value: uint) -> ^Number {…}

Number_intValue :: proc "odin" (self: ^Number) -> int {…}

Number_integerValue :: proc "odin" (self: ^Number) -> Integer {…}

Number_isEqualToNumber :: proc "odin" (self, other: ^Number) -> bool {…}

Number_numberWithBool :: proc "odin" (value: bool) -> ^Number {…}

Number_numberWithF32 :: proc "odin" (value: f32) -> ^Number {…}

Number_numberWithF64 :: proc "odin" (value: f64) -> ^Number {…}

Number_numberWithI16 :: proc "odin" (value: i16) -> ^Number {…}

Number_numberWithI32 :: proc "odin" (value: i32) -> ^Number {…}

Number_numberWithI64 :: proc "odin" (value: i64) -> ^Number {…}

Number_numberWithI8 :: proc "odin" (value: i8) -> ^Number {…}

Number_numberWithInt :: proc "odin" (value: int) -> ^Number {…}

Number_numberWithU16 :: proc "odin" (value: u16) -> ^Number {…}

Number_numberWithU32 :: proc "odin" (value: u32) -> ^Number {…}

Number_numberWithU64 :: proc "odin" (value: u64) -> ^Number {…}

Number_numberWithU8 :: proc "odin" (value: u8) -> ^Number {…}

Number_numberWithUint :: proc "odin" (value: uint) -> ^Number {…}

Number_stringValue :: proc "odin" (self: ^Number) -> ^String {…}

Number_u16Value :: proc "odin" (self: ^Number) -> u16 {…}

Number_u32Value :: proc "odin" (self: ^Number) -> u32 {…}

Number_u64Value :: proc "odin" (self: ^Number) -> u64 {…}

Number_u8Value :: proc "odin" (self: ^Number) -> u8 {…}

Number_uintValue :: proc "odin" (self: ^Number) -> uint {…}

Number_uintegerValue :: proc "odin" (self: ^Number) -> UInteger {…}

Range_Equal :: proc "odin" (a, b: Range) -> bool {…}

Range_LocationInRange :: proc "odin" (self: Range, loc: UInteger) -> bool {…}

Range_Make :: proc "odin" (loc, len: UInteger) -> Range {…}

Range_Max :: proc "odin" (self: Range) -> UInteger {…}

RunningApplication_currentApplication :: proc "odin" () -> ^RunningApplication {…}

RunningApplication_localizedName :: proc "odin" (self: ^RunningApplication) -> ^String {…}

StringFromClass :: proc "cdecl" (cls: ^.objc_class) -> ^String ---

String_UTF8String :: proc "odin" (self: ^String) -> cstring {…}

String_alloc :: proc "odin" () -> ^String {…}

String_characterAtIndex :: proc "odin" (self: ^String, index: UInteger) -> unichar {…}

String_cstringUsingEncoding :: proc "odin" (self: ^String, encoding: StringEncoding) -> cstring {…}

String_init :: proc "odin" (self: ^String) -> ^String {…}

String_initWithBytesNoCopy :: proc "odin" (self: ^String, pBytes: rawptr, length: UInteger, encoding: StringEncoding, freeWhenDone: bool) -> ^String {…}

String_initWithCString :: proc "odin" (self: ^String, pString: cstring, encoding: StringEncoding) -> ^String {…}

String_initWithOdinString :: proc "odin" (self: ^String, str: string) -> ^String {…}

String_initWithString :: proc "odin" (self: ^String, other: ^String) -> ^String {…}

String_isEqualToString :: proc "odin" (self: ^String, other: ^String) -> bool {…}

String_length :: proc "odin" (self: ^String) -> UInteger {…}

String_lengthOfBytesUsingEncoding :: proc "odin" (self: ^String, encoding: StringEncoding) -> UInteger {…}

String_maximumLengthOfBytesUsingEncoding :: proc "odin" (self: ^String, encoding: StringEncoding) -> UInteger {…}

String_odinString :: proc "odin" (self: ^String) -> string {…}

String_rangeOfString :: proc "odin" (self, other: ^String, options: StringCompareOptions) -> Range {…}

URL_alloc :: proc "odin" () -> ^URL {…}

URL_fileSystemRepresentation :: proc "odin" (self: ^URL) -> ^String {…}

URL_init :: proc "odin" (self: ^URL) -> ^URL {…}

URL_initFileURLWithPath :: proc "odin" (self: ^URL, value: ^String) -> ^URL {…}

URL_initWithString :: proc "odin" (self: ^URL, value: ^String) -> ^URL {…}

Value_alloc :: proc "odin" () -> ^Value {…}

Value_getValue :: proc "odin" (self: ^Value, value: rawptr, size: UInteger) {…}

Value_init :: proc "odin" (self: ^Value) -> ^Value {…}

Value_initWithBytes :: proc "odin" (self: ^Value, value: rawptr, type: cstring) -> ^Value {…}

Value_initWithCoder :: proc "odin" (self: ^Value, coder: ^Coder) -> ^Value {…}

Value_isEqualToValue :: proc "cdecl" (self, other: ^Value) -> bool {…}

Value_objCType :: proc "cdecl" (self: ^Value) -> cstring {…}

Value_pointerValue :: proc "cdecl" (self: ^Value) -> rawptr {…}

Value_valueWithBytes :: proc "odin" (value: rawptr, type: cstring) -> ^Value {…}

Value_valueWithPointer :: proc "odin" (pointer: rawptr) -> ^Value {…}

View_initWithFrame :: proc "odin" (self: ^View, frame: Rect) -> ^View {…}

View_layer :: proc "odin" (self: ^View) -> ^Layer {…}

View_setLayer :: proc "odin" (self: ^View, layer: ^Layer) {…}

View_setWantsLayer :: proc "odin" (self: ^View, wantsLayer: bool) {…}

View_wantsLayer :: proc "odin" (self: ^View) -> bool {…}

Window_alloc :: proc "odin" () -> ^Window {…}

Window_backgroundColor :: proc "odin" (self: ^Window) -> ^Color {…}

Window_close :: proc "odin" (self: ^Window) {…}

Window_contentView :: proc "odin" (self: ^Window) -> ^View {…}

Window_frame :: proc "odin" (self: ^Window) -> Rect {…}

Window_initWithContentRect :: proc "odin" (self: ^Window, contentRect: Rect, styleMask: WindowStyleMask, backing: BackingStoreType, doDefer: bool) -> ^Window {…}

Window_makeKeyAndOrderFront :: proc "odin" (self: ^Window, key: ^Object) {…}

Window_opaque :: proc "odin" (self: ^Window) -> bool {…}

Window_setBackgroundColor :: proc "odin" (self: ^Window, color: ^Color) {…}

Window_setContentView :: proc "odin" (self: ^Window, content_view: ^View) {…}

Window_setFrame :: proc "odin" (self: ^Window, frame: Rect) {…}

Window_setOpaque :: proc "odin" (self: ^Window, ok: bool) {…}

Window_setTitle :: proc "odin" (self: ^Window, title: ^String) {…}

alloc :: proc "odin" ($T: typeid) -> ^typeid {…}

autorelease :: proc "odin" (self: ^Object) {…}

bridgingCast :: proc "odin" ($T: typeid, obj: ^Object) {…}

class :: proc "odin" (self: ^Object) -> ^.objc_class {…}

class_addMethod :: proc "cdecl" (cls: ^.objc_class, name: ^.objc_selector, imp: IMP, types: cstring) -> bool ---

copy :: proc "odin" (self: ^Copying($T)) -> ^$ {…}

debugDescription :: proc "odin" (self: ^Object) -> ^String {…}

description :: proc "odin" (self: ^Object) -> ^String {…}

hash :: proc "odin" (self: ^Object) -> UInteger {…}

init :: proc "odin" (self: ^$) -> ^$ {…}

isEqual :: proc "odin" (self, pObject: ^Object) -> bool {…}

methodSignatureForSelector :: proc "cdecl" (obj: ^Object, selector: ^.objc_selector) -> rawptr {…}

msgSendSafeCheck :: proc "cdecl" (obj: ^Object, selector: ^.objc_selector) -> bool {…}

new :: proc "odin" ($T: typeid) -> ^typeid {…}

objc_allocateClassPair :: proc "cdecl" (superclass: ^.objc_class, name: cstring, extraBytes: uint) ---

objc_lookUpClass :: proc "cdecl" (name: cstring) -> ^.objc_class ---

release :: proc "odin" (self: ^Object) {…}

respondsToSelector :: proc "cdecl" (obj: ^Object, selector: ^.objc_selector) -> bool {…}

retain :: proc "odin" (self: ^Object) {…}

retainCount :: proc "odin" (self: ^Object) -> UInteger {…}

scoped_autoreleasepool :: proc "odin" () -> ^AutoreleasePool {…}

sel_registerName :: proc "cdecl" (name: cstring) -> ^.objc_selector ---

Number_number :: proc{
	Number_numberWithI8,
	Number_numberWithU8,
	Number_numberWithI16,
	Number_numberWithU16,
	Number_numberWithI32,
	Number_numberWithU32,
	Number_numberWithInt,
	Number_numberWithUint,
	Number_numberWithU64,
	Number_numberWithI64,
	Number_numberWithF32,
	Number_numberWithF64,
	Number_numberWithBool,
}