objcjs-types 0.3.0 → 0.5.0

package/dist/Foundation/NSXPCConnection.d.ts

@@ -1,4 +1,5 @@
 import type { NobjcObject } from "objc-js";
+import type { _NSError } from "./NSError.js";
 import type { _NSObject } from "./NSObject.js";
 import type { _NSString } from "./NSString.js";
 import type { _NSXPCInterface } from "./NSXPCInterface.js";
@@ -24,11 +25,11 @@ export declare class _NSXPCConnection extends _NSObject {
      * Initialize an NSXPCConnection that will connect to an NSXPCListener (identified by its NSXPCListenerEndpoint).
      */
     initWithListenerEndpoint$(endpoint: _NSXPCListenerEndpoint): _NSXPCConnection;
-    remoteObjectProxyWithErrorHandler$(handler: NobjcObject): NobjcObject;
+    remoteObjectProxyWithErrorHandler$(handler: (error: _NSError) => void): NobjcObject;
     /**
      * Make a synchronous IPC call instead of the default async behavior. The error handler block and reply block will be invoked on the calling thread before the message to the proxy returns, instead of on the queue for the connection.
      */
-    synchronousRemoteObjectProxyWithErrorHandler$(handler: NobjcObject): NobjcObject;
+    synchronousRemoteObjectProxyWithErrorHandler$(handler: (error: _NSError) => void): NobjcObject;
     /**
      * All connections start suspended. You must resume them before they will start processing received messages or sending messages through the remoteObjectProxy. Note: Calling resume does not immediately launch the XPC service. The service will be started on demand when the first message is sent. However, if the name specified when creating the connection is determined to be invalid, your invalidation handler will be called immediately (and asynchronously) after calling resume. For new code, calling `-activate` is preferred for the initial activation of the connection.
      */
@@ -48,7 +49,7 @@ export declare class _NSXPCConnection extends _NSObject {
     /**
      * Add a barrier block to be executed on the connection. This barrier block will run after any outstanding sends have completed. Note: This does not guarantee that messages will be received by the remote process by the time the block is invoked. If you need to ensure receipt of a message by the remote process, waiting for a reply to come back is the best option.
      */
-    scheduleSendBarrierBlock$(block: NobjcObject): void;
+    scheduleSendBarrierBlock$(block: () => void): void;
     /**
      * Sets the code signing requirement for this connection. If the requirement is malformed, an exception is thrown. If new messages do not match the requirement, the connection is invalidated. It is recommended to set this before calling `resume`, as it is an XPC error to call it more than once. See https://developer.apple.com/library/archive/documentation/Security/Conceptual/CodeSigningGuide/RequirementLang/RequirementLang.html for more information on the format.
      */
@@ -77,13 +78,13 @@ export declare class _NSXPCConnection extends _NSObject {
     /**
      * The interruption handler will be called if the remote process exits or crashes. It may be possible to re-establish the connection by simply sending another message. The handler will be invoked on the same queue as replies and other handlers, but there is no guarantee of ordering between those callbacks and this one. The interruptionHandler property is cleared after the connection becomes invalid. This is to mitigate the impact of a retain cycle created by referencing the NSXPCConnection instance inside this block.
      */
-    interruptionHandler(): NobjcObject | null;
-    setInterruptionHandler$(value: NobjcObject | null): void;
+    interruptionHandler(): (() => void) | null;
+    setInterruptionHandler$(value: (() => void) | null): void;
     /**
      * The invalidation handler will be called if the connection can not be formed or the connection has terminated and may not be re-established. The invalidation handler will also be called if a connection created with an NSXPCListenerEndpoint is invalidated from the remote side, or if the NSXPCListener used to create that endpoint is invalidated. The handler will be invoked on the same queue as replies and other handlers, but there is no guarantee of ordering between those callbacks and this one. You may not send messages over the connection from within an invalidation handler block. The invalidationHandler property is cleared after the connection becomes invalid. This is to mitigate the impact of a retain cycle created by referencing the NSXPCConnection instance inside this block.
      */
-    invalidationHandler(): NobjcObject | null;
-    setInvalidationHandler$(value: NobjcObject | null): void;
+    invalidationHandler(): (() => void) | null;
+    setInvalidationHandler$(value: (() => void) | null): void;
     /**
      * These attributes describe the security attributes of the connection. They may be used by the listener delegate to accept or reject connections.
      */

package/dist/Foundation/NSXPCProxyCreating.d.ts

@@ -1,4 +1,5 @@
 import type { NobjcObject } from "objc-js";
+import type { _NSError } from "./NSError.js";
 export interface _NSXPCProxyCreating {
     /**
      * Returns a proxy object with no error handling block. Messages sent to the proxy object will be sent over the wire to the other side of the connection. All messages must be 'oneway void' return type. Control may be returned to the caller before the message is sent. This proxy object will conform with the NSXPCProxyCreating protocol.
@@ -7,9 +8,9 @@ export interface _NSXPCProxyCreating {
     /**
      * Returns a proxy object which will invoke the error handling block if an error occurs on the connection. If the message sent to the proxy has a reply handler, then either the error handler or the reply handler will be called exactly once. This proxy object will also conform with the NSXPCProxyCreating protocol.
      */
-    remoteObjectProxyWithErrorHandler$?(handler: NobjcObject): NobjcObject;
+    remoteObjectProxyWithErrorHandler$?(handler: (error: _NSError) => void): NobjcObject;
     /**
      * Make a synchronous IPC call instead of the default async behavior. The error handler block and reply block will be invoked on the calling thread before the message to the proxy returns, instead of on the queue for the connection.
      */
-    synchronousRemoteObjectProxyWithErrorHandler$?(handler: NobjcObject): NobjcObject;
+    synchronousRemoteObjectProxyWithErrorHandler$?(handler: (error: _NSError) => void): NobjcObject;
 }

package/dist/Foundation/index.d.ts

@@ -1092,4 +1092,3 @@ 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,4 +458,3 @@ 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/GLKTextureLoader.d.ts

@@ -3,6 +3,7 @@ import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSBundle } from "../Foundation/NSBundle.js";
 import type { _NSData } from "../Foundation/NSData.js";
 import type { _NSDictionary } from "../Foundation/NSDictionary.js";
+import type { _NSError } from "../Foundation/NSError.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSString } from "../Foundation/NSString.js";
 import type { _NSURL } from "../Foundation/NSURL.js";
@@ -44,33 +45,33 @@ export declare class _GLKTextureLoader extends _NSObject {
     /**
      * Asynchronously load an image from disk into an OpenGL texture. Invokes the block on the provided queue when the operation is complete. If queue is NULL, the main queue will be used.
      */
-    textureWithContentsOfFile$options$queue$completionHandler$(path: _NSString, options: _NSDictionary | null, queue: _NSObject | null, block: NobjcObject): void;
+    textureWithContentsOfFile$options$queue$completionHandler$(path: _NSString, options: _NSDictionary | null, queue: _NSObject | null, block: (arg0: _GLKTextureInfo, arg1: _NSError) => void): void;
     /**
      * completionHandler:(GLKTextureLoaderCallback)block; Block to be invoked on the above dispatch queue.
      */
-    textureWithContentsOfURL$options$queue$completionHandler$(url: _NSURL, options: _NSDictionary | null, queue: _NSObject | null, block: NobjcObject): void;
+    textureWithContentsOfURL$options$queue$completionHandler$(url: _NSURL, options: _NSDictionary | null, queue: _NSObject | null, block: (arg0: _GLKTextureInfo, arg1: _NSError) => void): void;
     /**
      * Asynchronously load a named texture asset from a given bundled into an OpenGL texture Invokes the block on the provided queue when the operation is complete. If queue is NULL, the main queue will be used.
      */
-    textureWithName$scaleFactor$bundle$options$queue$completionHandler$(name: _NSString, scaleFactor: number, bundle: _NSBundle | null, options: _NSDictionary | null, queue: _NSObject | null, block: NobjcObject): void;
+    textureWithName$scaleFactor$bundle$options$queue$completionHandler$(name: _NSString, scaleFactor: number, bundle: _NSBundle | null, options: _NSDictionary | null, queue: _NSObject | null, block: (arg0: _GLKTextureInfo, arg1: _NSError) => void): void;
     /**
      * Asynchronously create a texture from data residing in memory. Invokes the block on the provided queue when the operation is complete. If queue is NULL, the main queue will be used.
      */
-    textureWithContentsOfData$options$queue$completionHandler$(data: _NSData, options: _NSDictionary | null, queue: _NSObject | null, block: NobjcObject): void;
+    textureWithContentsOfData$options$queue$completionHandler$(data: _NSData, options: _NSDictionary | null, queue: _NSObject | null, block: (arg0: _GLKTextureInfo, arg1: _NSError) => void): void;
     /**
      * Asynchronously create a texture from a CGImageRef. Invokes the block on the provided queue when the operation is complete. If queue is NULL, the main queue will be used.
      */
-    textureWithCGImage$options$queue$completionHandler$(cgImage: Uint8Array, options: _NSDictionary | null, queue: _NSObject | null, block: NobjcObject): void;
+    textureWithCGImage$options$queue$completionHandler$(cgImage: Uint8Array, options: _NSDictionary | null, queue: _NSObject | null, block: (arg0: _GLKTextureInfo, arg1: _NSError) => void): void;
     /**
      * Asynchronously load six images from disk into an OpenGL cubemap texture. Face ordering will always be interpreted as Right(+x), Left(-x), Top(+y), Bottom(-y), Front(+z), Back(-z). This coordinate system is left-handed if you think of yourself within the cube. The coordinate system is right-handed if you think of yourself outside of the cube. Invokes the block on the provided queue when the operation is complete. If queue is NULL, the main queue will be used.
      */
-    cubeMapWithContentsOfFiles$options$queue$completionHandler$(paths: _NSArray, options: _NSDictionary | null, queue: _NSObject | null, block: NobjcObject): void;
+    cubeMapWithContentsOfFiles$options$queue$completionHandler$(paths: _NSArray, options: _NSDictionary | null, queue: _NSObject | null, block: (arg0: _GLKTextureInfo, arg1: _NSError) => void): void;
     /**
      * Asynchronously creates an OpenGL cubemap texture by splitting one image into six parts. Takes a single image file where height = 6 * width or width = 6 * height. The former (vertical orientation) is preferred to avoid image data extraction overhead. Face ordering will always be interpreted as Right(+x), Left(-x), Top(+y), Bottom(-y), Front(+z), Back(-z). This coordinate system is left-handed if you think of yourself within the cube. The coordinate system is right-handed if you think of yourself outside of the cube. Invokes the block on the provided queue when the operation is complete. If queue is NULL, the main queue will be used.
      */
-    cubeMapWithContentsOfFile$options$queue$completionHandler$(path: _NSString, options: _NSDictionary | null, queue: _NSObject | null, block: NobjcObject): void;
+    cubeMapWithContentsOfFile$options$queue$completionHandler$(path: _NSString, options: _NSDictionary | null, queue: _NSObject | null, block: (arg0: _GLKTextureInfo, arg1: _NSError) => void): void;
     /**
      * completionHandler:(GLKTextureLoaderCallback)block; Block to be invoked on the above dispatch queue.
      */
-    cubeMapWithContentsOfURL$options$queue$completionHandler$(url: _NSURL, options: _NSDictionary | null, queue: _NSObject | null, block: NobjcObject): void;
+    cubeMapWithContentsOfURL$options$queue$completionHandler$(url: _NSURL, options: _NSDictionary | null, queue: _NSObject | null, block: (arg0: _GLKTextureInfo, arg1: _NSError) => void): void;
 }

package/dist/GLKit/index.d.ts

@@ -55,4 +55,3 @@ export { GLKTextureInfoOrigin } from "./GLKTextureInfoOrigin.js";
 export { GLKTextureLoaderError } from "./GLKTextureLoaderError.js";
 export { GLKTextureTarget } from "./GLKTextureTarget.js";
 export { GLKVertexAttrib } from "./GLKVertexAttrib.js";
-export * from "./functions.js";

package/dist/GLKit/index.js

@@ -25,4 +25,3 @@ export { GLKTextureInfoOrigin } from "./GLKTextureInfoOrigin.js";
 export { GLKTextureLoaderError } from "./GLKTextureLoaderError.js";
 export { GLKTextureTarget } from "./GLKTextureTarget.js";
 export { GLKVertexAttrib } from "./GLKVertexAttrib.js";
-export * from "./functions.js";

package/dist/GameController/GCAxis2DInput.d.ts

@@ -1,12 +1,12 @@
-import type { NobjcObject } from "objc-js";
+import type { _GCPhysicalInputElement } from "./GCPhysicalInputElement.js";
 import type { _NSSet } from "../Foundation/NSSet.js";
 import type { GCPoint2 } from "../structs/GCPoint2.js";
 export interface _GCAxis2DInput {
     /**
      * Set this block to be notified when the value of the axis input changes. @param element the element that has been modified. @param input the input that has been modified. @param value the value the axis was set to at the time the valueChangedHandler fired.
      */
-    valueDidChangeHandler?(): NobjcObject | null;
-    setValueDidChangeHandler$?(value: NobjcObject | null): void;
+    valueDidChangeHandler?(): ((arg0: _GCPhysicalInputElement, arg1: _GCAxis2DInput, arg2: GCPoint2) => void) | null;
+    setValueDidChangeHandler$?(value: ((arg0: _GCPhysicalInputElement, arg1: _GCAxis2DInput, arg2: GCPoint2) => void) | null): void;
     /**
      * A pair of x,y normalized values for the axis input, each between -1 and 1 (inclusive). The values are deadzoned and saturated before they are returned so there is no value outside the range. Deadzoning does not remove values from the range; the full 0 to 1 magnitude of values are possible from the input. As an axis is often used in a digital sense, you can rely on a value of 0 meaning the axis is inside the deadzone. Any value greater than or less than zero is not in the deadzone.
      */

package/dist/GameController/GCAxisInput.d.ts

@@ -1,11 +1,11 @@
-import type { NobjcObject } from "objc-js";
+import type { _GCPhysicalInputElement } from "./GCPhysicalInputElement.js";
 import type { _NSSet } from "../Foundation/NSSet.js";
 export interface _GCAxisInput {
     /**
      * Set this block to be notified when the value of the axis input changes. @param element the element that has been modified. @param input the input that has been modified. @param value the value the axis was set to at the time the valueChangedHandler fired.
      */
-    valueDidChangeHandler?(): NobjcObject | null;
-    setValueDidChangeHandler$?(value: NobjcObject | null): void;
+    valueDidChangeHandler?(): ((arg0: _GCPhysicalInputElement, arg1: _GCAxisInput, arg2: number) => void) | null;
+    setValueDidChangeHandler$?(value: ((arg0: _GCPhysicalInputElement, arg1: _GCAxisInput, arg2: number) => void) | null): void;
     /**
      * A normalized value for the axis input, between -1 and 1 (inclusive). The values are deadzoned and saturated before they are returned so there is no value outside the range. Deadzoning does not remove values from the range, the full 0 to 1 magnitude of values are possible from the input. As an axis is often used in a digital sense, you can rely on a value of 0 meaning the axis is inside the deadzone. Any value greater than or less than zero is not in the deadzone.
      */

package/dist/GameController/GCController.d.ts

@@ -34,7 +34,7 @@ export declare class _GCController extends _NSObject {
     /**
      * Start discovery of new wireless controllers that are discoverable. This is an asynchronous and the supplied completionHandler will get called once no more devices can be found. If there are already multiple controllers available for use, there may be little reason to automatically start discovery of new wireless controllers. In this situation it may be best to allow the user to start discovery manually via in-game UI. Once discovery has started new controllers will notify themselves as connected via GCControllerDidConnectNotification. As the notification arrives the controller is also available in the controllers array. The completionHandler could be used to update UI and/or game state to indicate that no more controllers will be found and the current set of controllers is what is available for use in the game. If a completionHandler was provided, it will be called once when discovery stops. Either from an explicit call to stopWirelessControllerDiscovery or from timing out or stopping in its natural course of operation. Thus the completionHandler will at most be called once per call to startWirelessControllerDiscoveryWithCompletionHandler:. The completionHandler may also not get called at all, if for example startWirelessControllerDiscoveryWithCompletionHandler: is called multiple times during dicovery. For this case the net effect is that the completionHandler is replaced with each call and only the last one set before discovery stops will be called. @param completionHandler an optional handler that is called when discovery stops. (may be nil, in which case you will not be notified when discovery stops) @see stopWirelessControllerDiscovery @see controllers
      */
-    static startWirelessControllerDiscoveryWithCompletionHandler$(completionHandler: NobjcObject | null): void;
+    static startWirelessControllerDiscoveryWithCompletionHandler$(completionHandler: (() => void) | null): void;
     /**
      * If no more controllers are needed, depending on game state or number of controllers supported by a game, the discovery process can be stopped. Calling stopWirelessControllerDiscovery when no discovery is currently in progress will return immediately without any effect, thus it is safe to call even if the completionHandler of startWirelessControllerDiscoveryWithCompletionHandler: has been called. @see startWirelessControllerDiscoveryWithCompletionHandler:
      */
@@ -56,8 +56,8 @@ export declare class _GCController extends _NSObject {
      * Set this block to be notified when a user intends to suspend or resume the current game state. A controller will have a button dedicated to suspending and resuming play and invoking context sensitive actions. During event handling the system will notify the application using this block such that the application can handle the suspension and resumption from the given controller. Use this to implement your canonical transition to a pause menu for example if that is your application's desired handling of suspension in play. You may pause and resume based on game state as well so the event is only called each time the pause/resume button is pressed. @note This handler has been deprecated in favor of the Menu button found on GCMicroGamepad and GCExtendedGamepad. @see microGamepad @see extendedGamepad
      * @deprecated Use the Menu button found on the controller's input profile, if it exists.
      */
-    controllerPausedHandler(): NobjcObject | null;
-    setControllerPausedHandler$(value: NobjcObject | null): void;
+    controllerPausedHandler(): ((arg0: _GCController) => void) | null;
+    setControllerPausedHandler$(value: ((arg0: _GCController) => void) | null): void;
     /**
      * A controller may be form fitting or otherwise closely attached to the device. This closeness to other inputs on the device may suggest that interaction with the device may use other inputs easily. This is presented to developers to allow them to make informed decisions about UI and interactions to choose for their game in this situation.
      */

package/dist/GameController/GCControllerAxisInput.d.ts

@@ -1,4 +1,3 @@
-import type { NobjcObject } from "objc-js";
 import type { _GCControllerElement } from "./GCControllerElement.js";
 export declare class _GCControllerAxisInput extends _GCControllerElement {
     static alloc(): _GCControllerAxisInput;
@@ -8,8 +7,8 @@ export declare class _GCControllerAxisInput extends _GCControllerElement {
      * Sets the normalized value for the input. the value to set the input to. If the controller's snapshot flag is set to NO, this method has no effect. value
      */
     setValue$(value: number): void;
-    valueChangedHandler(): NobjcObject | null;
-    setValueChangedHandler$(value: NobjcObject | null): void;
+    valueChangedHandler(): ((arg0: _GCControllerAxisInput, arg1: number) => void) | null;
+    setValueChangedHandler$(value: ((arg0: _GCControllerAxisInput, arg1: number) => void) | null): void;
     /**
      * A normalized value for the input, between -1 and 1 for axis inputs. The values are deadzoned and saturated before they are returned so there is no value ouside the range. Deadzoning does not remove values from the range, the full 0 to 1 magnitude of values are possible from the input. As an axis is often used in a digital sense, you can rely on a value of 0 meaning the axis is inside the deadzone. Any value greater than or less than zero is not in the deadzone.
      */

package/dist/GameController/GCControllerButtonInput.d.ts

@@ -1,4 +1,3 @@
-import type { NobjcObject } from "objc-js";
 import type { _GCControllerElement } from "./GCControllerElement.js";
 export declare class _GCControllerButtonInput extends _GCControllerElement {
     static alloc(): _GCControllerButtonInput;
@@ -8,15 +7,15 @@ export declare class _GCControllerButtonInput extends _GCControllerElement {
      * Sets the normalized value for the button input. Will update the pressed state of the button. the value to set the input to. If the controller's snapshot flag is set to NO, this method has no effect. value
      */
     setValue$(value: number): void;
-    valueChangedHandler(): NobjcObject | null;
-    setValueChangedHandler$(value: NobjcObject | null): void;
+    valueChangedHandler(): ((arg0: _GCControllerButtonInput, arg1: number, arg2: boolean) => void) | null;
+    setValueChangedHandler$(value: ((arg0: _GCControllerButtonInput, arg1: number, arg2: boolean) => void) | null): void;
     /**
      * Set this block if you want to be notified when only the pressed state on this button changes. This will get called less often than the valueChangedHandler with the additional feature of the pressed state being different to the last time it was called.
      */
-    pressedChangedHandler(): NobjcObject | null;
-    setPressedChangedHandler$(value: NobjcObject | null): void;
-    touchedChangedHandler(): NobjcObject | null;
-    setTouchedChangedHandler$(value: NobjcObject | null): void;
+    pressedChangedHandler(): ((arg0: _GCControllerButtonInput, arg1: number, arg2: boolean) => void) | null;
+    setPressedChangedHandler$(value: ((arg0: _GCControllerButtonInput, arg1: number, arg2: boolean) => void) | null): void;
+    touchedChangedHandler(): ((arg0: _GCControllerButtonInput, arg1: number, arg2: boolean, arg3: boolean) => void) | null;
+    setTouchedChangedHandler$(value: ((arg0: _GCControllerButtonInput, arg1: number, arg2: boolean, arg3: boolean) => void) | null): void;
     /**
      * A normalized value for the input. Between 0 and 1 for button inputs. Values are saturated and thus never exceed the range of [0, 1]. valueChangedHandler pressed
      */

package/dist/GameController/GCControllerDirectionPad.d.ts

@@ -1,4 +1,3 @@
-import type { NobjcObject } from "objc-js";
 import type { _GCControllerAxisInput } from "./GCControllerAxisInput.js";
 import type { _GCControllerButtonInput } from "./GCControllerButtonInput.js";
 import type { _GCControllerElement } from "./GCControllerElement.js";
@@ -10,8 +9,8 @@ export declare class _GCControllerDirectionPad extends _GCControllerElement {
      * Sets the normalized value for the direction pad's axis inputs. Will update the states of the direction pad's button inputs as well. the value to set the xAxis of the touchpad to. the value to set the yAxis of the touchpad to. If the controller's snapshot flag is set to NO, this method has no effect. value pressed
      */
     setValueForXAxis$yAxis$(xAxis: number, yAxis: number): void;
-    valueChangedHandler(): NobjcObject | null;
-    setValueChangedHandler$(value: NobjcObject | null): void;
+    valueChangedHandler(): ((arg0: _GCControllerDirectionPad, arg1: number, arg2: number) => void) | null;
+    setValueChangedHandler$(value: ((arg0: _GCControllerDirectionPad, arg1: number, arg2: number) => void) | null): void;
     xAxis(): _GCControllerAxisInput;
     yAxis(): _GCControllerAxisInput;
     up(): _GCControllerButtonInput;

package/dist/GameController/GCControllerTouchpad.d.ts

@@ -1,4 +1,3 @@
-import type { NobjcObject } from "objc-js";
 import type { _GCControllerButtonInput } from "./GCControllerButtonInput.js";
 import type { _GCControllerDirectionPad } from "./GCControllerDirectionPad.js";
 import type { _GCControllerElement } from "./GCControllerElement.js";
@@ -14,16 +13,16 @@ export declare class _GCControllerTouchpad extends _GCControllerElement {
     /** Button is the button built into the touch surface. */
     button(): _GCControllerButtonInput;
     /** Called when a touch event begins on the touchpad. */
-    touchDown(): NobjcObject | null;
-    setTouchDown$(value: NobjcObject | null): void;
+    touchDown(): ((arg0: _GCControllerTouchpad, arg1: number, arg2: number, arg3: number, arg4: boolean) => void) | null;
+    setTouchDown$(value: ((arg0: _GCControllerTouchpad, arg1: number, arg2: number, arg3: number, arg4: boolean) => void) | null): void;
     /**
      * Called when a touch event continues on the touchpad, but not when it begins or ends.
      */
-    touchMoved(): NobjcObject | null;
-    setTouchMoved$(value: NobjcObject | null): void;
+    touchMoved(): ((arg0: _GCControllerTouchpad, arg1: number, arg2: number, arg3: number, arg4: boolean) => void) | null;
+    setTouchMoved$(value: ((arg0: _GCControllerTouchpad, arg1: number, arg2: number, arg3: number, arg4: boolean) => void) | null): void;
     /** Called when a touch event ends on the touchpad. */
-    touchUp(): NobjcObject | null;
-    setTouchUp$(value: NobjcObject | null): void;
+    touchUp(): ((arg0: _GCControllerTouchpad, arg1: number, arg2: number, arg3: number, arg4: boolean) => void) | null;
+    setTouchUp$(value: ((arg0: _GCControllerTouchpad, arg1: number, arg2: number, arg3: number, arg4: boolean) => void) | null): void;
     /**
      * The touch surface is a 2-axis control that represents the position of a touch event on the touchpad. The axes will indicate the most recent touch position - a non-zero value does not indicate that the surface is being touched, and a value of (0, 0) does not indicate the surface is not being touched. touchState - Should be polled in conjunction with touchSurface to determine if values are valid
      */

package/dist/GameController/GCDevicePhysicalInput.d.ts

@@ -1,4 +1,3 @@
-import type { NobjcObject } from "objc-js";
 import type { _GCController } from "./GCController.js";
 import type { _GCControllerInputState } from "./GCControllerInputState.js";
 import type { _GCControllerLiveInput } from "./GCControllerLiveInput.js";
@@ -6,6 +5,7 @@ import type { _GCDevicePhysicalInputState } from "./GCDevicePhysicalInputState.j
 import type { _GCDevicePhysicalInputStateDiff } from "./GCDevicePhysicalInputStateDiff.js";
 import type { _GCKeyboard } from "./GCKeyboard.js";
 import type { _GCMouse } from "./GCMouse.js";
+import type { _GCPhysicalInputElement } from "./GCPhysicalInputElement.js";
 import type { _GCRacingWheel } from "./GCRacingWheel.js";
 import type { _GCRacingWheelInput } from "./GCRacingWheelInput.js";
 import type { _GCRacingWheelInputState } from "./GCRacingWheelInputState.js";
@@ -30,13 +30,13 @@ export interface _GCDevicePhysicalInput extends _GCDevicePhysicalInputState {
     /**
      * Set this block to be notified when a value on a element changed. If multiple elements change this block will be called for each element that changed. The block is called on the configured for the physical input. The element that has been modified.
      */
-    elementValueDidChangeHandler?(): NobjcObject | null;
-    setElementValueDidChangeHandler$?(value: NobjcObject | null): void;
+    elementValueDidChangeHandler?(): ((arg0: _GCDevicePhysicalInput, arg1: _GCPhysicalInputElement) => void) | null;
+    setElementValueDidChangeHandler$?(value: ((arg0: _GCDevicePhysicalInput, arg1: _GCPhysicalInputElement) => void) | null): void;
     /**
      * Set this block to be notified when a new input state is available. Your handler should repeatedly call until it returns to drain the pending input states from the queue. physicalInput.inputStateQueueDepth = 20; physicalInput.inputStateAvailableHandler = ^(__kindof id <GCDevicePhysicalInput > physicalInput) { id <GCDevicePhysicalInputState , GCDevicePhysicalInputStateDiff> nextInputState; while ((nextInputState = [physicalInput nextInputState])) { // You can grab the individual states of all elements that your app // is interested in. id <GCButtonElement > buttonA = nextInputState.buttons[GCInputButtonA]; BOOL buttonAPressed = buttonA.pressedInput.pressed; if (buttonAPressed) { // Handle button A pressed } // Your code can first query whether an element's input value changed // from the prior input state. GCDevicePhysicalInputElementChange buttonAChange = [nextInputState changeForElement:buttonA]; if (buttonAChange == GCDevicePhysicalInputElementChanged) { // Handle button A input changed } // Or, your code can request an enumerator of elements with input // values that changed from the prior input state for (id <GCPhysicalInputElement > changedElement in nextInputState.changedElements) { } } };
      */
-    inputStateAvailableHandler?(): NobjcObject | null;
-    setInputStateAvailableHandler$?(value: NobjcObject | null): void;
+    inputStateAvailableHandler?(): ((arg0: _GCDevicePhysicalInput) => void) | null;
+    setInputStateAvailableHandler$?(value: ((arg0: _GCDevicePhysicalInput) => void) | null): void;
     /**
      * The maximum number of input states to buffer. If your application does not drain the pending input states in the queue before this limit is reached, older input states will be discarded - resulting in your application "missing" input state changes. The default value is (no buffering). Smaller values are ignored. A value of should be more than enough to ensure no input state changes are missed.
      */

package/dist/GameController/GCExtendedGamepad.d.ts

@@ -1,7 +1,7 @@
-import type { NobjcObject } from "objc-js";
 import type { _GCController } from "./GCController.js";
 import type { _GCControllerButtonInput } from "./GCControllerButtonInput.js";
 import type { _GCControllerDirectionPad } from "./GCControllerDirectionPad.js";
+import type { _GCControllerElement } from "./GCControllerElement.js";
 import type { _GCExtendedGamepadSnapshot } from "./GCExtendedGamepadSnapshot.js";
 import type { _GCPhysicalInputProfile } from "./GCPhysicalInputProfile.js";
 export declare class _GCExtendedGamepad extends _GCPhysicalInputProfile {
@@ -21,8 +21,8 @@ export declare class _GCExtendedGamepad extends _GCPhysicalInputProfile {
      * A profile keeps a reference to the controller that this profile is mapping input from.
      */
     controller(): _GCController | null;
-    valueChangedHandler(): NobjcObject | null;
-    setValueChangedHandler$(value: NobjcObject | null): void;
+    valueChangedHandler(): ((arg0: _GCExtendedGamepad, arg1: _GCControllerElement) => void) | null;
+    setValueChangedHandler$(value: ((arg0: _GCExtendedGamepad, arg1: _GCControllerElement) => void) | null): void;
     /**
      * Required to be analog in the Extended profile. All the elements of this directional input are thus analog.
      */

package/dist/GameController/GCGamepad.d.ts

@@ -1,7 +1,7 @@
-import type { NobjcObject } from "objc-js";
 import type { _GCController } from "./GCController.js";
 import type { _GCControllerButtonInput } from "./GCControllerButtonInput.js";
 import type { _GCControllerDirectionPad } from "./GCControllerDirectionPad.js";
+import type { _GCControllerElement } from "./GCControllerElement.js";
 import type { _GCGamepadSnapshot } from "./GCGamepadSnapshot.js";
 import type { _GCPhysicalInputProfile } from "./GCPhysicalInputProfile.js";
 export declare class _GCGamepad extends _GCPhysicalInputProfile {
@@ -16,8 +16,8 @@ export declare class _GCGamepad extends _GCPhysicalInputProfile {
      * A profile keeps a reference to the controller that this profile is mapping input from.
      */
     controller(): _GCController | null;
-    valueChangedHandler(): NobjcObject | null;
-    setValueChangedHandler$(value: NobjcObject | null): void;
+    valueChangedHandler(): ((arg0: _GCGamepad, arg1: _GCControllerElement) => void) | null;
+    setValueChangedHandler$(value: ((arg0: _GCGamepad, arg1: _GCControllerElement) => void) | null): void;
     /**
      * Required to be analog in the Standard profile. All the elements of this directional input are thus analog.
      */

package/dist/GameController/GCKeyboardInput.d.ts

@@ -9,8 +9,8 @@ export declare class _GCKeyboardInput extends _GCPhysicalInputProfile {
      * Alongside general subscript notation of GCPhysicalInputProfile keys can be accessed using this method. is a low level key code that can be used for accessing a keyboard button. Full list of supported key constants can be found in GCKeyCodes.h and GCKeyNames.h
      */
     buttonForKeyCode$(code: NobjcObject): _GCControllerButtonInput | null;
-    keyChangedHandler(): NobjcObject | null;
-    setKeyChangedHandler$(value: NobjcObject | null): void;
+    keyChangedHandler(): ((arg0: _GCKeyboardInput, arg1: _GCControllerButtonInput, arg2: number, arg3: boolean) => void) | null;
+    setKeyChangedHandler$(value: ((arg0: _GCKeyboardInput, arg1: _GCControllerButtonInput, arg2: number, arg3: boolean) => void) | null): void;
     /**
      * Before querying any key for a value it might be useful to check if any key is actually pressed
      */

package/dist/GameController/GCLinearInput.d.ts

@@ -1,12 +1,12 @@
-import type { NobjcObject } from "objc-js";
+import type { _GCPhysicalInputElement } from "./GCPhysicalInputElement.js";
 import type { _GCPhysicalInputExtents } from "./GCPhysicalInputExtents.js";
 import type { _NSSet } from "../Foundation/NSSet.js";
 export interface _GCLinearInput {
     /**
      * Set this block to be notified when the value of the input changes. @param element the element that has been modified. @param input the input that has been modified. @param value the value the axis was set to at the time the valueDidChangeHandler fired.
      */
-    valueDidChangeHandler?(): NobjcObject | null;
-    setValueDidChangeHandler$?(value: NobjcObject | null): void;
+    valueDidChangeHandler?(): ((arg0: _GCPhysicalInputElement, arg1: _GCLinearInput, arg2: number) => void) | null;
+    setValueDidChangeHandler$?(value: ((arg0: _GCPhysicalInputElement, arg1: _GCLinearInput, arg2: number) => void) | null): void;
     /**
      * A normalized value for the axis input, between 0 and 1 (inclusive). The values are deadzoned and saturated before they are returned so there is no value outside the range. Deadzoning does not remove values from the range, the full 0 to 1 magnitude of values are possible from the input. You can rely on a value of 0 meaning the value is inside the deadzone. Any value greater than zero is not in the deadzone.
      */

package/dist/GameController/GCMicroGamepad.d.ts

@@ -1,7 +1,7 @@
-import type { NobjcObject } from "objc-js";
 import type { _GCController } from "./GCController.js";
 import type { _GCControllerButtonInput } from "./GCControllerButtonInput.js";
 import type { _GCControllerDirectionPad } from "./GCControllerDirectionPad.js";
+import type { _GCControllerElement } from "./GCControllerElement.js";
 import type { _GCMicroGamepadSnapshot } from "./GCMicroGamepadSnapshot.js";
 import type { _GCPhysicalInputProfile } from "./GCPhysicalInputProfile.js";
 export declare class _GCMicroGamepad extends _GCPhysicalInputProfile {
@@ -21,8 +21,8 @@ export declare class _GCMicroGamepad extends _GCPhysicalInputProfile {
      * A profile keeps a reference to the controller that this profile is mapping input from.
      */
     controller(): _GCController | null;
-    valueChangedHandler(): NobjcObject | null;
-    setValueChangedHandler$(value: NobjcObject | null): void;
+    valueChangedHandler(): ((arg0: _GCMicroGamepad, arg1: _GCControllerElement) => void) | null;
+    setValueChangedHandler$(value: ((arg0: _GCMicroGamepad, arg1: _GCControllerElement) => void) | null): void;
     /**
      * Optionally analog in the Micro profile. All the elements of this directional input are either analog or digital.
      */

package/dist/GameController/GCMotion.d.ts

@@ -1,4 +1,3 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _GCController } from "./GCController.js";
 import type { GCAcceleration } from "../structs/GCAcceleration.js";
@@ -36,8 +35,8 @@ export declare class _GCMotion extends _NSObject {
      * A profile keeps a reference to the controller that it is mapping input from. @see GCController
      */
     controller(): _GCController | null;
-    valueChangedHandler(): NobjcObject | null;
-    setValueChangedHandler$(value: NobjcObject | null): void;
+    valueChangedHandler(): ((arg0: _GCMotion) => void) | null;
+    setValueChangedHandler$(value: ((arg0: _GCMotion) => void) | null): void;
     /**
      * If this property is returns YES, you are responsible for setting sensorsActive to YES when you need motion data from the controller. Some controllers, such as the Siri Remote, automatically activate and deactivate motion sensors. In such a case, this property will return NO. @see sensorsActive
      */

package/dist/GameController/GCMouseInput.d.ts

@@ -1,4 +1,3 @@
-import type { NobjcObject } from "objc-js";
 import type { _GCControllerButtonInput } from "./GCControllerButtonInput.js";
 import type { _GCDeviceCursor } from "./GCDeviceCursor.js";
 import type { _GCPhysicalInputProfile } from "./GCPhysicalInputProfile.js";
@@ -7,8 +6,8 @@ export declare class _GCMouseInput extends _GCPhysicalInputProfile {
     static alloc(): _GCMouseInput;
     static new(): _GCMouseInput;
     init(): _GCMouseInput;
-    mouseMovedHandler(): NobjcObject | null;
-    setMouseMovedHandler$(value: NobjcObject | null): void;
+    mouseMovedHandler(): ((arg0: _GCMouseInput, arg1: number, arg2: number) => void) | null;
+    setMouseMovedHandler$(value: ((arg0: _GCMouseInput, arg1: number, arg2: number) => void) | null): void;
     /** Scroll is a dpad with undefined range. */
     scroll(): _GCDeviceCursor;
     /** Mouse buttons that can be used only as digital inputs */

package/dist/GameController/GCPhysicalInputProfile.d.ts

@@ -1,4 +1,3 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSDictionary } from "../Foundation/NSDictionary.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSSet } from "../Foundation/NSSet.js";
@@ -46,8 +45,8 @@ export declare class _GCPhysicalInputProfile extends _NSObject {
     /**
      * Set this block if you want to be notified when a value on a element changed. If multiple elements have changed this block will be called for each element that changed. @param profile this profile that is being used to map the raw input data into logical values on controller elements such as the dpad or the buttons. @param element the element that has been modified.
      */
-    valueDidChangeHandler(): NobjcObject | null;
-    setValueDidChangeHandler$(value: NobjcObject | null): void;
+    valueDidChangeHandler(): ((arg0: _GCPhysicalInputProfile, arg1: _GCControllerElement) => void) | null;
+    setValueDidChangeHandler$(value: ((arg0: _GCPhysicalInputProfile, arg1: _GCControllerElement) => void) | null): void;
     /**
      * The following properties allow for runtime lookup of any input element on a profile, when provided with a valid alias. @example extendedGamepad.elements["Button A"] == extendedGamepad.buttonA // YES @example extendedGamepad.dpads["Left Thumbstick"] == extendedGamepad.leftThumbstick // YES @example extendedGamepad.dpads["Button B"] // returns nil, "Button B" is not a GCControllerDirectionPad
      */

package/dist/GameController/GCPressedStateInput.d.ts

@@ -1,9 +1,9 @@
-import type { NobjcObject } from "objc-js";
+import type { _GCPhysicalInputElement } from "./GCPhysicalInputElement.js";
 import type { _NSSet } from "../Foundation/NSSet.js";
 export interface _GCPressedStateInput {
     /** Set this block if you want to be notified when the pressed state changes. */
-    pressedDidChangeHandler?(): NobjcObject | null;
-    setPressedDidChangeHandler$?(value: NobjcObject | null): void;
+    pressedDidChangeHandler?(): ((arg0: _GCPhysicalInputElement, arg1: _GCPressedStateInput, arg2: boolean) => void) | null;
+    setPressedDidChangeHandler$?(value: ((arg0: _GCPhysicalInputElement, arg1: _GCPressedStateInput, arg2: boolean) => void) | null): void;
     /**
      * Buttons are mostly used in a digital sense, thus we have a recommended method for checking for pressed state instead of interpreting the value. As a general guideline a button is pressed if the value exceeds 0. However there may be hysteresis applied to counter noisy input values, thus incidental values around the threshold value may not trigger a change in pressed state. Other buttons may support two-stage actuation, where the button reports a value between 0 and 1 but is only considered pressed when its value is greater than some threshold other than 0. @see pressedDidChangeHandler
      */

package/dist/GameController/GCRelativeInput.d.ts

@@ -1,11 +1,11 @@
-import type { NobjcObject } from "objc-js";
+import type { _GCPhysicalInputElement } from "./GCPhysicalInputElement.js";
 import type { _NSSet } from "../Foundation/NSSet.js";
 export interface _GCRelativeInput {
     /**
      * Set this block to be notified when the delta of the input changes. @param delta The amount that the input has changed since the last time \c deltaDidChangeHandler fired.
      */
-    deltaDidChangeHandler?(): NobjcObject | null;
-    setDeltaDidChangeHandler$?(value: NobjcObject | null): void;
+    deltaDidChangeHandler?(): ((arg0: _GCPhysicalInputElement, arg1: _GCRelativeInput, arg2: number) => void) | null;
+    setDeltaDidChangeHandler$?(value: ((arg0: _GCPhysicalInputElement, arg1: _GCRelativeInput, arg2: number) => void) | null): void;
     /** The last reported delta for the input. */
     delta?(): number;
     /**

package/dist/GameController/GCSwitchPositionInput.d.ts

@@ -1,12 +1,12 @@
-import type { NobjcObject } from "objc-js";
+import type { _GCPhysicalInputElement } from "./GCPhysicalInputElement.js";
 import type { _NSSet } from "../Foundation/NSSet.js";
 import type { NSRange } from "../structs/NSRange.js";
 export interface _GCSwitchPositionInput {
     /**
      * Set this block if you want to be notified when the value on the switch changes. the element that has been modified. value
      */
-    positionDidChangeHandler?(): NobjcObject | null;
-    setPositionDidChangeHandler$?(value: NobjcObject | null): void;
+    positionDidChangeHandler?(): ((arg0: _GCPhysicalInputElement, arg1: _GCSwitchPositionInput, arg2: number) => void) | null;
+    setPositionDidChangeHandler$?(value: ((arg0: _GCPhysicalInputElement, arg1: _GCSwitchPositionInput, arg2: number) => void) | null): void;
     /** The switch's position. valueDidChangeHandler */
     position?(): number;
     /** The (inclusive) bounds of possible position values for the switch. */

package/dist/GameController/GCTouchedStateInput.d.ts

@@ -1,9 +1,9 @@
-import type { NobjcObject } from "objc-js";
+import type { _GCPhysicalInputElement } from "./GCPhysicalInputElement.js";
 import type { _NSSet } from "../Foundation/NSSet.js";
 export interface _GCTouchedStateInput {
     /** Set this block if you want to be notified when the touched state changes. */
-    touchedDidChangeHandler?(): NobjcObject | null;
-    setTouchedDidChangeHandler$?(value: NobjcObject | null): void;
+    touchedDidChangeHandler?(): ((arg0: _GCPhysicalInputElement, arg1: _GCTouchedStateInput, arg2: boolean) => void) | null;
+    setTouchedDidChangeHandler$?(value: ((arg0: _GCPhysicalInputElement, arg1: _GCTouchedStateInput, arg2: boolean) => void) | null): void;
     /**
      * Some buttons feature capacitive touch capabilities, where the user can touch the button without pressing it. In such cases, a button will be touched before it is pressed. touchedDidChangeHandler GCPressedStateInput
      */

package/dist/GameController/index.d.ts

@@ -171,4 +171,3 @@ export { GCPhysicalInputSourceDirection } from "./GCPhysicalInputSourceDirection
 export { GCSystemGestureState } from "./GCSystemGestureState.js";
 export { GCTouchState } from "./GCTouchState.js";
 export { GCHapticsLocality } from "./GCHapticsLocality.js";
-export * from "./functions.js";

package/dist/GameController/index.js

@@ -51,4 +51,3 @@ export { GCPhysicalInputSourceDirection } from "./GCPhysicalInputSourceDirection
 export { GCSystemGestureState } from "./GCSystemGestureState.js";
 export { GCTouchState } from "./GCTouchState.js";
 export { GCHapticsLocality } from "./GCHapticsLocality.js";
-export * from "./functions.js";