objcjs-types 0.2.0 → 0.3.0

package/dist/Foundation/functions.d.ts

@@ -0,0 +1,145 @@
+import type { NobjcObject } from "objc-js";
+import type { _NSArray } from "./NSArray.js";
+import type { _NSCoder } from "./NSCoder.js";
+import type { _NSHashTable } from "./NSHashTable.js";
+import type { _NSMapTable } from "./NSMapTable.js";
+import type { _NSObject } from "./NSObject.js";
+import type { _NSString } from "./NSString.js";
+import type { CGPoint } from "../structs/CGPoint.js";
+import type { CGRect } from "../structs/CGRect.js";
+import type { CGSize } from "../structs/CGSize.js";
+import type { NSEdgeInsets } from "../structs/NSEdgeInsets.js";
+import type { NSRange } from "../structs/NSRange.js";
+import type { NSCalculationError } from "./NSCalculationError.js";
+import type { NSRectEdge } from "./NSRectEdge.js";
+import type { NSRoundingMode } from "./NSRoundingMode.js";
+import type { NSSearchPathDirectory } from "./NSSearchPathDirectory.js";
+import type { NSSearchPathDomainMask } from "./NSSearchPathDomainMask.js";
+export declare function NSAllHashTableObjects(table: _NSHashTable): _NSArray;
+export declare function NSAllMapTableKeys(table: _NSMapTable): _NSArray;
+export declare function NSAllMapTableValues(table: _NSMapTable): _NSArray;
+export declare function NSAllocateCollectable(size: number, options: number): NobjcObject;
+export declare function NSAllocateMemoryPages(bytes: number): NobjcObject;
+export declare function NSAllocateObject(aClass: NobjcObject, extraBytes: number, zone: NobjcObject | null): NobjcObject;
+export declare function NSClassFromString(aClassName: _NSString): NobjcObject | null;
+export declare function NSCompareHashTables(table1: _NSHashTable, table2: _NSHashTable): boolean;
+export declare function NSCompareMapTables(table1: _NSMapTable, table2: _NSMapTable): boolean;
+export declare function NSContainsRect(aRect: CGRect, bRect: CGRect): boolean;
+export declare function NSCopyHashTableWithZone(table: _NSHashTable, zone: NobjcObject | null): _NSHashTable;
+export declare function NSCopyMapTableWithZone(table: _NSMapTable, zone: NobjcObject | null): _NSMapTable;
+export declare function NSCopyMemoryPages(source: Uint8Array, dest: Uint8Array, bytes: number): void;
+export declare function NSCopyObject(object_: NobjcObject, extraBytes: number, zone: NobjcObject | null): NobjcObject;
+export declare function NSCountFrames(): number;
+export declare function NSCountHashTable(table: _NSHashTable): number;
+export declare function NSCountMapTable(table: _NSMapTable): number;
+export declare function NSCreateHashTable(callBacks: NobjcObject, capacity: number): _NSHashTable;
+export declare function NSCreateHashTableWithZone(callBacks: NobjcObject, capacity: number, zone: NobjcObject | null): _NSHashTable;
+export declare function NSCreateMapTable(keyCallBacks: NobjcObject, valueCallBacks: NobjcObject, capacity: number): _NSMapTable;
+export declare function NSCreateMapTableWithZone(keyCallBacks: NobjcObject, valueCallBacks: NobjcObject, capacity: number, zone: NobjcObject | null): _NSMapTable;
+export declare function NSCreateZone(startSize: number, granularity: number, canFree: boolean): NobjcObject;
+export declare function NSDeallocateMemoryPages(ptr: Uint8Array, bytes: number): void;
+export declare function NSDeallocateObject(object_: NobjcObject): void;
+export declare function NSDecimalAdd(result: NobjcObject, leftOperand: NobjcObject, rightOperand: NobjcObject, roundingMode: NSRoundingMode): NSCalculationError;
+export declare function NSDecimalCompact(number_: NobjcObject): void;
+export declare function NSDecimalCompare(leftOperand: NobjcObject, rightOperand: NobjcObject): number;
+export declare function NSDecimalCopy(destination: NobjcObject, source: NobjcObject): void;
+export declare function NSDecimalDivide(result: NobjcObject, leftOperand: NobjcObject, rightOperand: NobjcObject, roundingMode: NSRoundingMode): NSCalculationError;
+export declare function NSDecimalMultiply(result: NobjcObject, leftOperand: NobjcObject, rightOperand: NobjcObject, roundingMode: NSRoundingMode): NSCalculationError;
+export declare function NSDecimalMultiplyByPowerOf10(result: NobjcObject, number_: NobjcObject, power: number, roundingMode: NSRoundingMode): NSCalculationError;
+export declare function NSDecimalNormalize(number1: NobjcObject, number2: NobjcObject, roundingMode: NSRoundingMode): NSCalculationError;
+export declare function NSDecimalPower(result: NobjcObject, number_: NobjcObject, power: number, roundingMode: NSRoundingMode): NSCalculationError;
+export declare function NSDecimalRound(result: NobjcObject, number_: NobjcObject, scale: number, roundingMode: NSRoundingMode): void;
+export declare function NSDecimalString(dcm: NobjcObject, locale: NobjcObject | null): _NSString;
+export declare function NSDecimalSubtract(result: NobjcObject, leftOperand: NobjcObject, rightOperand: NobjcObject, roundingMode: NSRoundingMode): NSCalculationError;
+export declare function NSDecrementExtraRefCountWasZero(object_: NobjcObject): boolean;
+export declare function NSDefaultMallocZone(): NobjcObject;
+export declare function NSDivideRect(inRect: CGRect, slice: NobjcObject, rem: NobjcObject, amount: number, edge: NSRectEdge): void;
+export declare function NSEdgeInsetsEqual(aInsets: NSEdgeInsets, bInsets: NSEdgeInsets): boolean;
+export declare function NSEndHashTableEnumeration(enumerator: NobjcObject): void;
+export declare function NSEndMapTableEnumeration(enumerator: NobjcObject): void;
+export declare function NSEnumerateHashTable(table: _NSHashTable): NobjcObject;
+export declare function NSEnumerateMapTable(table: _NSMapTable): NobjcObject;
+export declare function NSEqualPoints(aPoint: CGPoint, bPoint: CGPoint): boolean;
+export declare function NSEqualRects(aRect: CGRect, bRect: CGRect): boolean;
+export declare function NSEqualSizes(aSize: CGSize, bSize: CGSize): boolean;
+export declare function NSExtraRefCount(object_: NobjcObject): number;
+export declare function NSFileTypeForHFSTypeCode(hfsFileTypeCode: number): _NSString;
+export declare function NSFrameAddress(frame: number): NobjcObject;
+export declare function NSFreeHashTable(table: _NSHashTable): void;
+export declare function NSFreeMapTable(table: _NSMapTable): void;
+export declare function NSFullUserName(): _NSString;
+export declare function NSGetSizeAndAlignment(typePtr: string, sizep: NobjcObject | null, alignp: NobjcObject | null): string;
+export declare function NSGetUncaughtExceptionHandler(): NobjcObject | null;
+export declare function NSHashGet(table: _NSHashTable, pointer: Uint8Array | null): NobjcObject;
+export declare function NSHashInsert(table: _NSHashTable, pointer: Uint8Array | null): void;
+export declare function NSHashInsertIfAbsent(table: _NSHashTable, pointer: Uint8Array | null): NobjcObject | null;
+export declare function NSHashInsertKnownAbsent(table: _NSHashTable, pointer: Uint8Array | null): void;
+export declare function NSHashRemove(table: _NSHashTable, pointer: Uint8Array | null): void;
+export declare function NSHFSTypeCodeFromFileType(fileTypeString: _NSString): number;
+export declare function NSHFSTypeOfFile(fullFilePath: _NSString): _NSString;
+export declare function NSHomeDirectory(): _NSString;
+export declare function NSHomeDirectoryForUser(userName: _NSString | null): _NSString | null;
+export declare function NSIncrementExtraRefCount(object_: NobjcObject): void;
+export declare function NSInsetRect(aRect: CGRect, dX: number, dY: number): CGRect;
+export declare function NSIntegralRect(aRect: CGRect): CGRect;
+export declare function NSIntegralRectWithOptions(aRect: CGRect, opts: NobjcObject): CGRect;
+export declare function NSIntersectionRange(range1: NSRange, range2: NSRange): NSRange;
+export declare function NSIntersectionRect(aRect: CGRect, bRect: CGRect): CGRect;
+export declare function NSIntersectsRect(aRect: CGRect, bRect: CGRect): boolean;
+export declare function NSIsEmptyRect(aRect: CGRect): boolean;
+export declare function NSIsFreedObject(anObject: NobjcObject): boolean;
+export declare function NSLog(arg: NobjcObject, ...args: any[]): void;
+export declare function NSLogPageSize(): number;
+export declare function NSLogv(arg: NobjcObject, arg2: string): void;
+export declare function NSMapGet(table: _NSMapTable, key: Uint8Array | null): NobjcObject | null;
+export declare function NSMapInsert(table: _NSMapTable, key: Uint8Array | null, value: Uint8Array | null): void;
+export declare function NSMapInsertIfAbsent(table: _NSMapTable, key: Uint8Array | null, value: Uint8Array | null): NobjcObject | null;
+export declare function NSMapInsertKnownAbsent(table: _NSMapTable, key: Uint8Array | null, value: Uint8Array | null): void;
+export declare function NSMapMember(table: _NSMapTable, key: Uint8Array, originalKey: NobjcObject | null, value: NobjcObject | null): boolean;
+export declare function NSMapRemove(table: _NSMapTable, key: Uint8Array | null): void;
+export declare function NSMouseInRect(aPoint: CGPoint, aRect: CGRect, flipped: boolean): boolean;
+export declare function NSNextHashEnumeratorItem(enumerator: NobjcObject): NobjcObject | null;
+export declare function NSNextMapEnumeratorPair(enumerator: NobjcObject, key: NobjcObject | null, value: NobjcObject | null): boolean;
+export declare function NSOffsetRect(aRect: CGRect, dX: number, dY: number): CGRect;
+export declare function NSOpenStepRootDirectory(): _NSString;
+export declare function NSPageSize(): number;
+export declare function NSPointFromString(aString: _NSString): CGPoint;
+export declare function NSPointInRect(aPoint: CGPoint, aRect: CGRect): boolean;
+export declare function NSProtocolFromString(namestr: _NSString): NobjcObject | null;
+export declare function NSRangeFromString(aString: _NSString): NSRange;
+export declare function NSReallocateCollectable(ptr: Uint8Array | null, size: number, options: number): NobjcObject;
+export declare function NSRealMemoryAvailable(): number;
+export declare function NSRecordAllocationEvent(eventType: number, object_: NobjcObject): void;
+export declare function NSRectFromString(aString: _NSString): CGRect;
+export declare function NSRecycleZone(zone: NobjcObject): void;
+export declare function NSResetHashTable(table: _NSHashTable): void;
+export declare function NSResetMapTable(table: _NSMapTable): void;
+export declare function NSReturnAddress(frame: number): NobjcObject;
+export declare function NSRoundDownToMultipleOfPageSize(bytes: number): number;
+export declare function NSRoundUpToMultipleOfPageSize(bytes: number): number;
+export declare function NSSearchPathForDirectoriesInDomains(directory: NSSearchPathDirectory, domainMask: NSSearchPathDomainMask, expandTilde: boolean): _NSArray;
+export declare function NSSelectorFromString(aSelectorName: _NSString): string;
+export declare function NSSetUncaughtExceptionHandler(arg: NobjcObject | null): void;
+export declare function NSSetZoneName(zone: NobjcObject | null, name: _NSString): void;
+export declare function NSShouldRetainWithZone(anObject: NobjcObject, requestedZone: NobjcObject | null): boolean;
+export declare function NSSizeFromString(aString: _NSString): CGSize;
+export declare function NSStringFromClass(aClass: NobjcObject): _NSString;
+export declare function NSStringFromHashTable(table: _NSHashTable): _NSString;
+export declare function NSStringFromMapTable(table: _NSMapTable): _NSString;
+export declare function NSStringFromPoint(aPoint: CGPoint): _NSString;
+export declare function NSStringFromProtocol(proto: NobjcObject): _NSString;
+export declare function NSStringFromRange(range: NSRange): _NSString;
+export declare function NSStringFromRect(aRect: CGRect): _NSString;
+export declare function NSStringFromSelector(aSelector: string): _NSString;
+export declare function NSStringFromSize(aSize: CGSize): _NSString;
+export declare function NSTemporaryDirectory(): _NSString;
+export declare function NSUnionRange(range1: NSRange, range2: NSRange): NSRange;
+export declare function NSUnionRect(aRect: CGRect, bRect: CGRect): CGRect;
+export declare function NSUserName(): _NSString;
+export declare function NSZoneCalloc(zone: NobjcObject | null, numElems: number, byteSize: number): NobjcObject;
+export declare function NSZoneFree(zone: NobjcObject | null, ptr: Uint8Array): void;
+export declare function NSZoneFromPointer(ptr: Uint8Array): NobjcObject | null;
+export declare function NSZoneMalloc(zone: NobjcObject | null, size: number): NobjcObject;
+export declare function NSZoneName(zone: NobjcObject | null): _NSString;
+export declare function NSZoneRealloc(zone: NobjcObject | null, ptr: Uint8Array | null, size: number): NobjcObject;
+export declare function NXReadNSObjectFromCoder(decoder: _NSCoder): _NSObject | null;

package/dist/Foundation/functions.js

@@ -0,0 +1,386 @@
+// AUTO-GENERATED by objcjs-types generator — DO NOT EDIT
+import { callFunction, callVariadicFunction } from "objc-js";
+export function NSAllHashTableObjects(table) {
+    return callFunction("NSAllHashTableObjects", { returns: "@" }, table);
+}
+export function NSAllMapTableKeys(table) {
+    return callFunction("NSAllMapTableKeys", { returns: "@" }, table);
+}
+export function NSAllMapTableValues(table) {
+    return callFunction("NSAllMapTableValues", { returns: "@" }, table);
+}
+export function NSAllocateCollectable(size, options) {
+    return callFunction("NSAllocateCollectable", { returns: "^v", args: ["Q", "Q"] }, size, options);
+}
+export function NSAllocateMemoryPages(bytes) {
+    return callFunction("NSAllocateMemoryPages", { returns: "^v", args: ["Q"] }, bytes);
+}
+export function NSAllocateObject(aClass, extraBytes, zone) {
+    return callFunction("NSAllocateObject", { returns: "@", args: ["#", "Q", "@"] }, aClass, extraBytes, zone);
+}
+export function NSClassFromString(aClassName) {
+    return callFunction("NSClassFromString", { returns: "#" }, aClassName);
+}
+export function NSCompareHashTables(table1, table2) {
+    return callFunction("NSCompareHashTables", { returns: "B" }, table1, table2);
+}
+export function NSCompareMapTables(table1, table2) {
+    return callFunction("NSCompareMapTables", { returns: "B" }, table1, table2);
+}
+export function NSContainsRect(aRect, bRect) {
+    return callFunction("NSContainsRect", { returns: "B", args: ["{NSRect}", "{NSRect}"] }, aRect, bRect);
+}
+export function NSCopyHashTableWithZone(table, zone) {
+    return callFunction("NSCopyHashTableWithZone", { returns: "@" }, table, zone);
+}
+export function NSCopyMapTableWithZone(table, zone) {
+    return callFunction("NSCopyMapTableWithZone", { returns: "@" }, table, zone);
+}
+export function NSCopyMemoryPages(source, dest, bytes) {
+    callFunction("NSCopyMemoryPages", { args: ["^v", "^v", "Q"] }, source, dest, bytes);
+}
+export function NSCopyObject(object_, extraBytes, zone) {
+    return callFunction("NSCopyObject", { returns: "@", args: ["@", "Q", "@"] }, object_, extraBytes, zone);
+}
+export function NSCountFrames() {
+    return callFunction("NSCountFrames", { returns: "Q" });
+}
+export function NSCountHashTable(table) {
+    return callFunction("NSCountHashTable", { returns: "Q" }, table);
+}
+export function NSCountMapTable(table) {
+    return callFunction("NSCountMapTable", { returns: "Q" }, table);
+}
+export function NSCreateHashTable(callBacks, capacity) {
+    return callFunction("NSCreateHashTable", { returns: "@", args: ["@", "Q"] }, callBacks, capacity);
+}
+export function NSCreateHashTableWithZone(callBacks, capacity, zone) {
+    return callFunction("NSCreateHashTableWithZone", { returns: "@", args: ["@", "Q", "@"] }, callBacks, capacity, zone);
+}
+export function NSCreateMapTable(keyCallBacks, valueCallBacks, capacity) {
+    return callFunction("NSCreateMapTable", { returns: "@", args: ["@", "@", "Q"] }, keyCallBacks, valueCallBacks, capacity);
+}
+export function NSCreateMapTableWithZone(keyCallBacks, valueCallBacks, capacity, zone) {
+    return callFunction("NSCreateMapTableWithZone", { returns: "@", args: ["@", "@", "Q", "@"] }, keyCallBacks, valueCallBacks, capacity, zone);
+}
+export function NSCreateZone(startSize, granularity, canFree) {
+    return callFunction("NSCreateZone", { returns: "@", args: ["Q", "Q", "B"] }, startSize, granularity, canFree);
+}
+export function NSDeallocateMemoryPages(ptr, bytes) {
+    callFunction("NSDeallocateMemoryPages", { args: ["^v", "Q"] }, ptr, bytes);
+}
+export function NSDeallocateObject(object_) {
+    callFunction("NSDeallocateObject", undefined, object_);
+}
+export function NSDecimalAdd(result, leftOperand, rightOperand, roundingMode) {
+    return callFunction("NSDecimalAdd", { returns: "q", args: ["@", "@", "@", "q"] }, result, leftOperand, rightOperand, roundingMode);
+}
+export function NSDecimalCompact(number_) {
+    callFunction("NSDecimalCompact", undefined, number_);
+}
+export function NSDecimalCompare(leftOperand, rightOperand) {
+    return callFunction("NSDecimalCompare", { returns: "q" }, leftOperand, rightOperand);
+}
+export function NSDecimalCopy(destination, source) {
+    callFunction("NSDecimalCopy", undefined, destination, source);
+}
+export function NSDecimalDivide(result, leftOperand, rightOperand, roundingMode) {
+    return callFunction("NSDecimalDivide", { returns: "q", args: ["@", "@", "@", "q"] }, result, leftOperand, rightOperand, roundingMode);
+}
+export function NSDecimalMultiply(result, leftOperand, rightOperand, roundingMode) {
+    return callFunction("NSDecimalMultiply", { returns: "q", args: ["@", "@", "@", "q"] }, result, leftOperand, rightOperand, roundingMode);
+}
+export function NSDecimalMultiplyByPowerOf10(result, number_, power, roundingMode) {
+    return callFunction("NSDecimalMultiplyByPowerOf10", { returns: "q", args: ["@", "@", "s", "q"] }, result, number_, power, roundingMode);
+}
+export function NSDecimalNormalize(number1, number2, roundingMode) {
+    return callFunction("NSDecimalNormalize", { returns: "q", args: ["@", "@", "q"] }, number1, number2, roundingMode);
+}
+export function NSDecimalPower(result, number_, power, roundingMode) {
+    return callFunction("NSDecimalPower", { returns: "q", args: ["@", "@", "Q", "q"] }, result, number_, power, roundingMode);
+}
+export function NSDecimalRound(result, number_, scale, roundingMode) {
+    callFunction("NSDecimalRound", { args: ["@", "@", "q", "q"] }, result, number_, scale, roundingMode);
+}
+export function NSDecimalString(dcm, locale) {
+    return callFunction("NSDecimalString", { returns: "@" }, dcm, locale);
+}
+export function NSDecimalSubtract(result, leftOperand, rightOperand, roundingMode) {
+    return callFunction("NSDecimalSubtract", { returns: "q", args: ["@", "@", "@", "q"] }, result, leftOperand, rightOperand, roundingMode);
+}
+export function NSDecrementExtraRefCountWasZero(object_) {
+    return callFunction("NSDecrementExtraRefCountWasZero", { returns: "B" }, object_);
+}
+export function NSDefaultMallocZone() {
+    return callFunction("NSDefaultMallocZone", { returns: "@" });
+}
+export function NSDivideRect(inRect, slice, rem, amount, edge) {
+    callFunction("NSDivideRect", { args: ["{NSRect}", "@", "@", "d", "q"] }, inRect, slice, rem, amount, edge);
+}
+export function NSEdgeInsetsEqual(aInsets, bInsets) {
+    return callFunction("NSEdgeInsetsEqual", { returns: "B", args: ["{NSEdgeInsets}", "{NSEdgeInsets}"] }, aInsets, bInsets);
+}
+export function NSEndHashTableEnumeration(enumerator) {
+    callFunction("NSEndHashTableEnumeration", undefined, enumerator);
+}
+export function NSEndMapTableEnumeration(enumerator) {
+    callFunction("NSEndMapTableEnumeration", undefined, enumerator);
+}
+export function NSEnumerateHashTable(table) {
+    return callFunction("NSEnumerateHashTable", { returns: "@" }, table);
+}
+export function NSEnumerateMapTable(table) {
+    return callFunction("NSEnumerateMapTable", { returns: "@" }, table);
+}
+export function NSEqualPoints(aPoint, bPoint) {
+    return callFunction("NSEqualPoints", { returns: "B", args: ["{NSPoint}", "{NSPoint}"] }, aPoint, bPoint);
+}
+export function NSEqualRects(aRect, bRect) {
+    return callFunction("NSEqualRects", { returns: "B", args: ["{NSRect}", "{NSRect}"] }, aRect, bRect);
+}
+export function NSEqualSizes(aSize, bSize) {
+    return callFunction("NSEqualSizes", { returns: "B", args: ["{NSSize}", "{NSSize}"] }, aSize, bSize);
+}
+export function NSExtraRefCount(object_) {
+    return callFunction("NSExtraRefCount", { returns: "Q" }, object_);
+}
+export function NSFileTypeForHFSTypeCode(hfsFileTypeCode) {
+    return callFunction("NSFileTypeForHFSTypeCode", { returns: "@", args: ["I"] }, hfsFileTypeCode);
+}
+export function NSFrameAddress(frame) {
+    return callFunction("NSFrameAddress", { returns: "^v", args: ["Q"] }, frame);
+}
+export function NSFreeHashTable(table) {
+    callFunction("NSFreeHashTable", undefined, table);
+}
+export function NSFreeMapTable(table) {
+    callFunction("NSFreeMapTable", undefined, table);
+}
+export function NSFullUserName() {
+    return callFunction("NSFullUserName", { returns: "@" });
+}
+export function NSGetSizeAndAlignment(typePtr, sizep, alignp) {
+    return callFunction("NSGetSizeAndAlignment", { returns: "*", args: ["*", "@", "@"] }, typePtr, sizep, alignp);
+}
+export function NSGetUncaughtExceptionHandler() {
+    return callFunction("NSGetUncaughtExceptionHandler", { returns: "@" });
+}
+export function NSHashGet(table, pointer) {
+    return callFunction("NSHashGet", { returns: "^v", args: ["@", "^v"] }, table, pointer);
+}
+export function NSHashInsert(table, pointer) {
+    callFunction("NSHashInsert", { args: ["@", "^v"] }, table, pointer);
+}
+export function NSHashInsertIfAbsent(table, pointer) {
+    return callFunction("NSHashInsertIfAbsent", { returns: "^v", args: ["@", "^v"] }, table, pointer);
+}
+export function NSHashInsertKnownAbsent(table, pointer) {
+    callFunction("NSHashInsertKnownAbsent", { args: ["@", "^v"] }, table, pointer);
+}
+export function NSHashRemove(table, pointer) {
+    callFunction("NSHashRemove", { args: ["@", "^v"] }, table, pointer);
+}
+export function NSHFSTypeCodeFromFileType(fileTypeString) {
+    return callFunction("NSHFSTypeCodeFromFileType", { returns: "I" }, fileTypeString);
+}
+export function NSHFSTypeOfFile(fullFilePath) {
+    return callFunction("NSHFSTypeOfFile", { returns: "@" }, fullFilePath);
+}
+export function NSHomeDirectory() {
+    return callFunction("NSHomeDirectory", { returns: "@" });
+}
+export function NSHomeDirectoryForUser(userName) {
+    return callFunction("NSHomeDirectoryForUser", { returns: "@" }, userName);
+}
+export function NSIncrementExtraRefCount(object_) {
+    callFunction("NSIncrementExtraRefCount", undefined, object_);
+}
+export function NSInsetRect(aRect, dX, dY) {
+    return callFunction("NSInsetRect", { returns: "{NSRect}", args: ["{NSRect}", "d", "d"] }, aRect, dX, dY);
+}
+export function NSIntegralRect(aRect) {
+    return callFunction("NSIntegralRect", { returns: "{NSRect}", args: ["{NSRect}"] }, aRect);
+}
+export function NSIntegralRectWithOptions(aRect, opts) {
+    return callFunction("NSIntegralRectWithOptions", { returns: "{NSRect}", args: ["{NSRect}", "@"] }, aRect, opts);
+}
+export function NSIntersectionRange(range1, range2) {
+    return callFunction("NSIntersectionRange", { returns: "{NSRange}", args: ["{NSRange}", "{NSRange}"] }, range1, range2);
+}
+export function NSIntersectionRect(aRect, bRect) {
+    return callFunction("NSIntersectionRect", { returns: "{NSRect}", args: ["{NSRect}", "{NSRect}"] }, aRect, bRect);
+}
+export function NSIntersectsRect(aRect, bRect) {
+    return callFunction("NSIntersectsRect", { returns: "B", args: ["{NSRect}", "{NSRect}"] }, aRect, bRect);
+}
+export function NSIsEmptyRect(aRect) {
+    return callFunction("NSIsEmptyRect", { returns: "B", args: ["{NSRect}"] }, aRect);
+}
+export function NSIsFreedObject(anObject) {
+    return callFunction("NSIsFreedObject", { returns: "B" }, anObject);
+}
+export function NSLog(arg, ...args) {
+    callVariadicFunction("NSLog", 1, arg, ...args);
+}
+export function NSLogPageSize() {
+    return callFunction("NSLogPageSize", { returns: "Q" });
+}
+export function NSLogv(arg, arg2) {
+    callFunction("NSLogv", { args: ["@", "*"] }, arg, arg2);
+}
+export function NSMapGet(table, key) {
+    return callFunction("NSMapGet", { returns: "^v", args: ["@", "^v"] }, table, key);
+}
+export function NSMapInsert(table, key, value) {
+    callFunction("NSMapInsert", { args: ["@", "^v", "^v"] }, table, key, value);
+}
+export function NSMapInsertIfAbsent(table, key, value) {
+    return callFunction("NSMapInsertIfAbsent", { returns: "^v", args: ["@", "^v", "^v"] }, table, key, value);
+}
+export function NSMapInsertKnownAbsent(table, key, value) {
+    callFunction("NSMapInsertKnownAbsent", { args: ["@", "^v", "^v"] }, table, key, value);
+}
+export function NSMapMember(table, key, originalKey, value) {
+    return callFunction("NSMapMember", { returns: "B", args: ["@", "^v", "@", "@"] }, table, key, originalKey, value);
+}
+export function NSMapRemove(table, key) {
+    callFunction("NSMapRemove", { args: ["@", "^v"] }, table, key);
+}
+export function NSMouseInRect(aPoint, aRect, flipped) {
+    return callFunction("NSMouseInRect", { returns: "B", args: ["{NSPoint}", "{NSRect}", "B"] }, aPoint, aRect, flipped);
+}
+export function NSNextHashEnumeratorItem(enumerator) {
+    return callFunction("NSNextHashEnumeratorItem", { returns: "^v" }, enumerator);
+}
+export function NSNextMapEnumeratorPair(enumerator, key, value) {
+    return callFunction("NSNextMapEnumeratorPair", { returns: "B" }, enumerator, key, value);
+}
+export function NSOffsetRect(aRect, dX, dY) {
+    return callFunction("NSOffsetRect", { returns: "{NSRect}", args: ["{NSRect}", "d", "d"] }, aRect, dX, dY);
+}
+export function NSOpenStepRootDirectory() {
+    return callFunction("NSOpenStepRootDirectory", { returns: "@" });
+}
+export function NSPageSize() {
+    return callFunction("NSPageSize", { returns: "Q" });
+}
+export function NSPointFromString(aString) {
+    return callFunction("NSPointFromString", { returns: "{NSPoint}" }, aString);
+}
+export function NSPointInRect(aPoint, aRect) {
+    return callFunction("NSPointInRect", { returns: "B", args: ["{NSPoint}", "{NSRect}"] }, aPoint, aRect);
+}
+export function NSProtocolFromString(namestr) {
+    return callFunction("NSProtocolFromString", { returns: "@" }, namestr);
+}
+export function NSRangeFromString(aString) {
+    return callFunction("NSRangeFromString", { returns: "{NSRange}" }, aString);
+}
+export function NSReallocateCollectable(ptr, size, options) {
+    return callFunction("NSReallocateCollectable", { returns: "^v", args: ["^v", "Q", "Q"] }, ptr, size, options);
+}
+export function NSRealMemoryAvailable() {
+    return callFunction("NSRealMemoryAvailable", { returns: "Q" });
+}
+export function NSRecordAllocationEvent(eventType, object_) {
+    callFunction("NSRecordAllocationEvent", { args: ["i", "@"] }, eventType, object_);
+}
+export function NSRectFromString(aString) {
+    return callFunction("NSRectFromString", { returns: "{NSRect}" }, aString);
+}
+export function NSRecycleZone(zone) {
+    callFunction("NSRecycleZone", undefined, zone);
+}
+export function NSResetHashTable(table) {
+    callFunction("NSResetHashTable", undefined, table);
+}
+export function NSResetMapTable(table) {
+    callFunction("NSResetMapTable", undefined, table);
+}
+export function NSReturnAddress(frame) {
+    return callFunction("NSReturnAddress", { returns: "^v", args: ["Q"] }, frame);
+}
+export function NSRoundDownToMultipleOfPageSize(bytes) {
+    return callFunction("NSRoundDownToMultipleOfPageSize", { returns: "Q", args: ["Q"] }, bytes);
+}
+export function NSRoundUpToMultipleOfPageSize(bytes) {
+    return callFunction("NSRoundUpToMultipleOfPageSize", { returns: "Q", args: ["Q"] }, bytes);
+}
+export function NSSearchPathForDirectoriesInDomains(directory, domainMask, expandTilde) {
+    return callFunction("NSSearchPathForDirectoriesInDomains", { returns: "@", args: ["q", "q", "B"] }, directory, domainMask, expandTilde);
+}
+export function NSSelectorFromString(aSelectorName) {
+    return callFunction("NSSelectorFromString", { returns: ":" }, aSelectorName);
+}
+export function NSSetUncaughtExceptionHandler(arg) {
+    callFunction("NSSetUncaughtExceptionHandler", undefined, arg);
+}
+export function NSSetZoneName(zone, name) {
+    callFunction("NSSetZoneName", undefined, zone, name);
+}
+export function NSShouldRetainWithZone(anObject, requestedZone) {
+    return callFunction("NSShouldRetainWithZone", { returns: "B" }, anObject, requestedZone);
+}
+export function NSSizeFromString(aString) {
+    return callFunction("NSSizeFromString", { returns: "{NSSize}" }, aString);
+}
+export function NSStringFromClass(aClass) {
+    return callFunction("NSStringFromClass", { returns: "@", args: ["#"] }, aClass);
+}
+export function NSStringFromHashTable(table) {
+    return callFunction("NSStringFromHashTable", { returns: "@" }, table);
+}
+export function NSStringFromMapTable(table) {
+    return callFunction("NSStringFromMapTable", { returns: "@" }, table);
+}
+export function NSStringFromPoint(aPoint) {
+    return callFunction("NSStringFromPoint", { returns: "@", args: ["{NSPoint}"] }, aPoint);
+}
+export function NSStringFromProtocol(proto) {
+    return callFunction("NSStringFromProtocol", { returns: "@" }, proto);
+}
+export function NSStringFromRange(range) {
+    return callFunction("NSStringFromRange", { returns: "@", args: ["{NSRange}"] }, range);
+}
+export function NSStringFromRect(aRect) {
+    return callFunction("NSStringFromRect", { returns: "@", args: ["{NSRect}"] }, aRect);
+}
+export function NSStringFromSelector(aSelector) {
+    return callFunction("NSStringFromSelector", { returns: "@", args: [":"] }, aSelector);
+}
+export function NSStringFromSize(aSize) {
+    return callFunction("NSStringFromSize", { returns: "@", args: ["{NSSize}"] }, aSize);
+}
+export function NSTemporaryDirectory() {
+    return callFunction("NSTemporaryDirectory", { returns: "@" });
+}
+export function NSUnionRange(range1, range2) {
+    return callFunction("NSUnionRange", { returns: "{NSRange}", args: ["{NSRange}", "{NSRange}"] }, range1, range2);
+}
+export function NSUnionRect(aRect, bRect) {
+    return callFunction("NSUnionRect", { returns: "{NSRect}", args: ["{NSRect}", "{NSRect}"] }, aRect, bRect);
+}
+export function NSUserName() {
+    return callFunction("NSUserName", { returns: "@" });
+}
+export function NSZoneCalloc(zone, numElems, byteSize) {
+    return callFunction("NSZoneCalloc", { returns: "^v", args: ["@", "Q", "Q"] }, zone, numElems, byteSize);
+}
+export function NSZoneFree(zone, ptr) {
+    callFunction("NSZoneFree", { args: ["@", "^v"] }, zone, ptr);
+}
+export function NSZoneFromPointer(ptr) {
+    return callFunction("NSZoneFromPointer", { returns: "@", args: ["^v"] }, ptr);
+}
+export function NSZoneMalloc(zone, size) {
+    return callFunction("NSZoneMalloc", { returns: "^v", args: ["@", "Q"] }, zone, size);
+}
+export function NSZoneName(zone) {
+    return callFunction("NSZoneName", { returns: "@" }, zone);
+}
+export function NSZoneRealloc(zone, ptr, size) {
+    return callFunction("NSZoneRealloc", { returns: "^v", args: ["@", "^v", "Q"] }, zone, ptr, size);
+}
+export function NXReadNSObjectFromCoder(decoder) {
+    return callFunction("NXReadNSObjectFromCoder", { returns: "@" }, decoder);
+}

package/dist/Foundation/index.d.ts

@@ -1092,3 +1092,4 @@ export { NSURLUbiquitousSharedItemRole } from "./NSURLUbiquitousSharedItemRole.j
 export { NSValueTransformerName } from "./NSValueTransformerName.js";
 export type { NSFileProviderServiceName } from "./NSFileProviderServiceName.js";
 export type { NSUndoManagerUserInfoKey } from "./NSUndoManagerUserInfoKey.js";
+export * from "./functions.js";

package/dist/Foundation/index.js

@@ -458,3 +458,4 @@ export { NSURLUbiquitousItemDownloadingStatus } from "./NSURLUbiquitousItemDownl
 export { NSURLUbiquitousSharedItemPermissions } from "./NSURLUbiquitousSharedItemPermissions.js";
 export { NSURLUbiquitousSharedItemRole } from "./NSURLUbiquitousSharedItemRole.js";
 export { NSValueTransformerName } from "./NSValueTransformerName.js";
+export * from "./functions.js";

package/dist/GLKit/GLKTextureInfo.d.ts

@@ -1,3 +1,4 @@
+import type { _NSCopying } from "../Foundation/NSCopying.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { GLKTextureInfoAlphaState } from "./GLKTextureInfoAlphaState.js";
 import type { GLKTextureInfoOrigin } from "./GLKTextureInfoOrigin.js";
@@ -16,3 +17,5 @@ export declare class _GLKTextureInfo extends _NSObject {
     mimapLevelCount(): number;
     arrayLength(): number;
 }
+export interface _GLKTextureInfo extends _NSCopying {
+}

package/dist/GLKit/functions.d.ts

@@ -0,0 +1,51 @@
+import type { NobjcObject } from "objc-js";
+import type { _NSString } from "../Foundation/NSString.js";
+import type { MDLVertexFormat } from "../ModelIO/MDLVertexFormat.js";
+export declare function GLKMathProject(object_: NobjcObject, model: NobjcObject, projection: NobjcObject, viewport: NobjcObject): NobjcObject;
+export declare function GLKMathUnproject(window: NobjcObject, model: NobjcObject, projection: NobjcObject, viewport: NobjcObject, success: NobjcObject | null): NobjcObject;
+export declare function GLKMatrix3Invert(matrix: NobjcObject, isInvertible: NobjcObject): NobjcObject;
+export declare function GLKMatrix3InvertAndTranspose(matrix: NobjcObject, isInvertible: NobjcObject): NobjcObject;
+export declare function GLKMatrix4Invert(matrix: NobjcObject, isInvertible: NobjcObject | null): NobjcObject;
+export declare function GLKMatrix4InvertAndTranspose(matrix: NobjcObject, isInvertible: NobjcObject | null): NobjcObject;
+export declare function GLKMatrixStackCreate(alloc: NobjcObject | null): NobjcObject | null;
+export declare function GLKMatrixStackGetMatrix2(stack: NobjcObject): NobjcObject;
+export declare function GLKMatrixStackGetMatrix3(stack: NobjcObject): NobjcObject;
+export declare function GLKMatrixStackGetMatrix3Inverse(stack: NobjcObject): NobjcObject;
+export declare function GLKMatrixStackGetMatrix3InverseTranspose(stack: NobjcObject): NobjcObject;
+export declare function GLKMatrixStackGetMatrix4(stack: NobjcObject): NobjcObject;
+export declare function GLKMatrixStackGetMatrix4Inverse(stack: NobjcObject): NobjcObject;
+export declare function GLKMatrixStackGetMatrix4InverseTranspose(stack: NobjcObject): NobjcObject;
+export declare function GLKMatrixStackGetTypeID(): number;
+export declare function GLKMatrixStackLoadMatrix4(stack: NobjcObject, matrix: NobjcObject): void;
+export declare function GLKMatrixStackMultiplyMatrix4(stack: NobjcObject, matrix: NobjcObject): void;
+export declare function GLKMatrixStackMultiplyMatrixStack(stackLeft: NobjcObject, stackRight: NobjcObject): void;
+export declare function GLKMatrixStackPop(stack: NobjcObject): void;
+export declare function GLKMatrixStackPush(stack: NobjcObject): void;
+export declare function GLKMatrixStackRotate(stack: NobjcObject, radians: number, x: number, y: number, z: number): void;
+export declare function GLKMatrixStackRotateWithVector3(stack: NobjcObject, radians: number, axisVector: NobjcObject): void;
+export declare function GLKMatrixStackRotateWithVector4(stack: NobjcObject, radians: number, axisVector: NobjcObject): void;
+export declare function GLKMatrixStackRotateX(stack: NobjcObject, radians: number): void;
+export declare function GLKMatrixStackRotateY(stack: NobjcObject, radians: number): void;
+export declare function GLKMatrixStackRotateZ(stack: NobjcObject, radians: number): void;
+export declare function GLKMatrixStackScale(stack: NobjcObject, sx: number, sy: number, sz: number): void;
+export declare function GLKMatrixStackScaleWithVector3(stack: NobjcObject, scaleVector: NobjcObject): void;
+export declare function GLKMatrixStackScaleWithVector4(stack: NobjcObject, scaleVector: NobjcObject): void;
+export declare function GLKMatrixStackSize(stack: NobjcObject): number;
+export declare function GLKMatrixStackTranslate(stack: NobjcObject, tx: number, ty: number, tz: number): void;
+export declare function GLKMatrixStackTranslateWithVector3(stack: NobjcObject, translationVector: NobjcObject): void;
+export declare function GLKMatrixStackTranslateWithVector4(stack: NobjcObject, translationVector: NobjcObject): void;
+export declare function GLKQuaternionAngle(quaternion: NobjcObject): number;
+export declare function GLKQuaternionAxis(quaternion: NobjcObject): NobjcObject;
+export declare function GLKQuaternionMakeWithMatrix3(matrix: NobjcObject): NobjcObject;
+export declare function GLKQuaternionMakeWithMatrix4(matrix: NobjcObject): NobjcObject;
+export declare function GLKQuaternionRotateVector3Array(quaternion: NobjcObject, vectors: NobjcObject, vectorCount: number): void;
+export declare function GLKQuaternionRotateVector4Array(quaternion: NobjcObject, vectors: NobjcObject, vectorCount: number): void;
+export declare function GLKQuaternionSlerp(quaternionStart: NobjcObject, quaternionEnd: NobjcObject, t: number): NobjcObject;
+export declare function GLKVertexAttributeParametersFromModelIO(vertexFormat: MDLVertexFormat): NobjcObject;
+export declare function NSStringFromGLKMatrix2(matrix: NobjcObject): _NSString;
+export declare function NSStringFromGLKMatrix3(matrix: NobjcObject): _NSString;
+export declare function NSStringFromGLKMatrix4(matrix: NobjcObject): _NSString;
+export declare function NSStringFromGLKQuaternion(quaternion: NobjcObject): _NSString;
+export declare function NSStringFromGLKVector2(vector: NobjcObject): _NSString;
+export declare function NSStringFromGLKVector3(vector: NobjcObject): _NSString;
+export declare function NSStringFromGLKVector4(vector: NobjcObject): _NSString;