objcjs-types 0.7.0 → 0.7.1

package/dist/GameController/GCHapticsLocality.d.ts

@@ -1,3 +1,4 @@
+import type { NSStringLiteral } from "../helpers.js";
 export declare const GCHapticsLocality: {
     readonly Default: "Default";
     readonly All: "All";
@@ -8,4 +9,4 @@ export declare const GCHapticsLocality: {
     readonly LeftTrigger: "Left Trigger";
     readonly RightTrigger: "Right Trigger";
 };
-export type GCHapticsLocality = typeof GCHapticsLocality[keyof typeof GCHapticsLocality];
+export type GCHapticsLocality = NSStringLiteral<(typeof GCHapticsLocality)[keyof typeof GCHapticsLocality]> | (typeof GCHapticsLocality)[keyof typeof GCHapticsLocality];

package/dist/GameController/GCLinearInput.d.ts

@@ -5,34 +5,34 @@ 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?(): ((arg0: _GCPhysicalInputElement, arg1: _GCLinearInput, arg2: number) => void) | null;
-    setValueDidChangeHandler$?(value: ((arg0: _GCPhysicalInputElement, arg1: _GCLinearInput, arg2: number) => void) | 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.
      */
-    value?(): number;
+    value(): number;
     /**
      * Check if the input can support more than just digital values. If \c YES, the input can produce any value between [0, 1]. Otherwise, the input only produces the values 0 or 1.
      */
-    analog?(): boolean;
+    analog(): boolean;
     /**
      * Check if the input value "rolls over" when reaching either the extreme high or low value. For example, some dials can be rotated past the position that represents their maximum value, causing the next reported value to roll over. Defaults to NO for most inputs.
      */
-    canWrap?(): boolean;
+    canWrap(): boolean;
     /**
      * The timestamp of the last value. This time interval is not relative to any specific point in time. You can subtract a previous timestamp from the current timestamp to determine the time (in seconds) between changes to the value.
      */
-    lastValueTimestamp?(): number;
+    lastValueTimestamp(): number;
     /**
      * The interval (in seconds) between the timestamp of the last event and the current time. This should be treated as a lower bound of the event latency. It may not include (wired or wireless) transmission latency, or latency accrued on the device before the event was transmitted to the host.
      */
-    lastValueLatency?(): number;
+    lastValueLatency(): number;
     /**
      * An object describing the physical extents of the input, if the input represents a physical unit of measurement.
      */
-    physicalExtents?(): _GCPhysicalInputExtents | null;
+    physicalExtents(): _GCPhysicalInputExtents | null;
     /**
      * An object describing the physical action(s) the user performs to manipulate this input.
      */
-    sources?(): _NSSet;
+    sources(): _NSSet;
 }

package/dist/GameController/GCPhysicalInputElement.d.ts

@@ -4,11 +4,11 @@ export interface _GCPhysicalInputElement {
     /**
      * The set of aliases that can be used to access this element with keyed subscript notation.
      */
-    aliases?(): _NSSet;
+    aliases(): _NSSet;
     /**
      * The element's localized display name. This is the string that your app should display in any on-screen messages instructing the user to interact with the control. For example: "Press \(buttonA.localizedName) to jump!" Do not cache this value - it can change when the user remaps controls.
      */
-    localizedName?(): _NSString | null;
+    localizedName(): _NSString | null;
     /** The SF Symbols name for the element. */
-    sfSymbolsName?(): _NSString | null;
+    sfSymbolsName(): _NSString | null;
 }

package/dist/GameController/GCPhysicalInputExtents.d.ts

@@ -1,8 +1,8 @@
 export interface _GCPhysicalInputExtents {
     /** The value of the input, scaled into physical units. */
-    scaledValue?(): number;
+    scaledValue(): number;
     /** The minimum value for the physical extent of the input. */
-    minimumValue?(): number;
+    minimumValue(): number;
     /** The maximum value for the physical extent of the input. */
-    maximumValue?(): number;
+    maximumValue(): number;
 }

package/dist/GameController/GCPhysicalInputSource.d.ts

@@ -3,11 +3,11 @@ import type { _NSString } from "../Foundation/NSString.js";
 import type { GCPhysicalInputSourceDirection } from "./GCPhysicalInputSourceDirection.js";
 export interface _GCPhysicalInputSource {
     /** The set of aliases for the element that the user interacts with. */
-    elementAliases?(): _NSSet;
+    elementAliases(): _NSSet;
     /** The localized name of the element that the user interacts with. */
-    elementLocalizedName?(): _NSString | null;
+    elementLocalizedName(): _NSString | null;
     /** The SF Symbol of the element that the user interacts with. */
-    sfSymbolsName?(): _NSString | null;
+    sfSymbolsName(): _NSString | null;
     /** One or more directions associated with the source. */
-    direction?(): GCPhysicalInputSourceDirection;
+    direction(): GCPhysicalInputSourceDirection;
 }

package/dist/GameController/GCPressedStateInput.d.ts

@@ -2,22 +2,22 @@ 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?(): ((arg0: _GCPhysicalInputElement, arg1: _GCPressedStateInput, arg2: boolean) => void) | null;
-    setPressedDidChangeHandler$?(value: ((arg0: _GCPhysicalInputElement, arg1: _GCPressedStateInput, arg2: boolean) => void) | 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
      */
-    pressed?(): boolean;
+    pressed(): boolean;
     /**
      * The timestamp of the last pressed state change. This time interval is not relative to any specific point in time. You can subtract a previous timestamp from the current timestamp to determine the time (in seconds) between changes to the value.
      */
-    lastPressedStateTimestamp?(): number;
+    lastPressedStateTimestamp(): number;
     /**
      * The interval (in seconds) between the timestamp of the last pressed state change and the current time. This should be treated as a lower bound of the event latency. It may not include (wired or wireless) transmission latency, or latency accrued on the device before the event was transmitted to the host.
      */
-    lastPressedStateLatency?(): number;
+    lastPressedStateLatency(): number;
     /**
      * An object describing the physical action(s) the user performs to manipulate this input.
      */
-    sources?(): _NSSet;
+    sources(): _NSSet;
 }

package/dist/GameController/GCRelativeInput.d.ts

@@ -4,24 +4,24 @@ 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?(): ((arg0: _GCPhysicalInputElement, arg1: _GCRelativeInput, arg2: number) => void) | null;
-    setDeltaDidChangeHandler$?(value: ((arg0: _GCPhysicalInputElement, arg1: _GCRelativeInput, arg2: number) => void) | 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;
+    delta(): number;
     /**
      * Check if the input can support more than just digital values. Defaults to \c YES for most relative inputs.
      */
-    analog?(): boolean;
+    analog(): boolean;
     /**
      * The timestamp of the last change. This time interval is not relative to any specific point in time. You can subtract a previous timestamp from the current timestamp to determine the time (in seconds) between changes to the value.
      */
-    lastDeltaTimestamp?(): number;
+    lastDeltaTimestamp(): number;
     /**
      * The interval (in seconds) between the timestamp of the last change and the current time. This should be treated as a lower bound of the event latency. It may not include (wired or wireless) transmission latency, or latency accrued on the device before the event was transmitted to the host.
      */
-    lastDeltaLatency?(): number;
+    lastDeltaLatency(): number;
     /**
      * An object describing the physical action(s) the user performs to manipulate this input.
      */
-    sources?(): _NSSet;
+    sources(): _NSSet;
 }

package/dist/GameController/GCSwitchElement.d.ts

@@ -2,5 +2,5 @@ import type { _GCPhysicalInputElement } from "./GCPhysicalInputElement.js";
 import type { _GCSwitchPositionInput } from "./GCSwitchPositionInput.js";
 export interface _GCSwitchElement extends _GCPhysicalInputElement {
     /** Get the input containing the absolute position of the switch. */
-    positionInput?(): _GCSwitchPositionInput;
+    positionInput(): _GCSwitchPositionInput;
 }

package/dist/GameController/GCSwitchPositionInput.d.ts

@@ -5,30 +5,30 @@ 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?(): ((arg0: _GCPhysicalInputElement, arg1: _GCSwitchPositionInput, arg2: number) => void) | null;
-    setPositionDidChangeHandler$?(value: ((arg0: _GCPhysicalInputElement, arg1: _GCSwitchPositionInput, arg2: number) => void) | 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;
+    position(): number;
     /** The (inclusive) bounds of possible position values for the switch. */
-    positionRange?(): NSRange;
+    positionRange(): NSRange;
     /**
      * if the switch input can only transition to positions that are adjacent to the current position.
      */
-    sequential?(): boolean;
+    sequential(): boolean;
     /**
      * Check if the position input value can "roll over" when reaching either of its bounds. This will always be for non-sequential switch inputs.
      */
-    canWrap?(): boolean;
+    canWrap(): boolean;
     /**
      * The timestamp of the last value. This time interval is not relative to any specific point in time. You can subtract a previous timestamp from the returned timestamp to determine the time (in seconds) between changes to the value.
      */
-    lastPositionTimestamp?(): number;
+    lastPositionTimestamp(): number;
     /**
      * The interval (in seconds) between the timestamp of the last event and the current time. This should be treated as a lower bound of the event latency. It may not include (wired or wireless) transmission latency, or latency accrued on the device before the event was transmitted to the host.
      */
-    lastPositionLatency?(): number;
+    lastPositionLatency(): number;
     /**
      * An object describing the physical action(s) the user performs to manipulate this input.
      */
-    sources?(): _NSSet;
+    sources(): _NSSet;
 }

package/dist/GameController/GCTouchedStateInput.d.ts

@@ -2,22 +2,22 @@ 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?(): ((arg0: _GCPhysicalInputElement, arg1: _GCTouchedStateInput, arg2: boolean) => void) | null;
-    setTouchedDidChangeHandler$?(value: ((arg0: _GCPhysicalInputElement, arg1: _GCTouchedStateInput, arg2: boolean) => void) | 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
      */
-    touched?(): boolean;
+    touched(): boolean;
     /**
      * The timestamp of the last touched state change. This time interval is not relative to any specific point in time. You can subtract a previous timestamp from the returned timestamp to determine the time (in seconds) between changes to the value.
      */
-    lastTouchedStateTimestamp?(): number;
+    lastTouchedStateTimestamp(): number;
     /**
      * The interval (in seconds) between the timestamp of the last touched state change and the current time. This should be treated as a lower bound of the event latency. It may not include (wired or wireless) transmission latency, or latency accrued on the device before the event was transmitted to the host.
      */
-    lastTouchedStateLatency?(): number;
+    lastTouchedStateLatency(): number;
     /**
      * An object describing the physical action(s) the user performs to manipulate this input.
      */
-    sources?(): _NSSet;
+    sources(): _NSSet;
 }

package/dist/GameKit/GKAchievementViewControllerDelegate.d.ts

@@ -1,5 +1,5 @@
 import type { _GKAchievementViewController } from "./GKAchievementViewController.js";
 export interface _GKAchievementViewControllerDelegate {
     /** The achievement view has finished */
-    achievementViewControllerDidFinish$?(viewController: _GKAchievementViewController): void;
+    achievementViewControllerDidFinish$(viewController: _GKAchievementViewController): void;
 }

package/dist/GameKit/GKChallengesViewControllerDelegate.d.ts

@@ -1,5 +1,5 @@
 import type { _GKChallengesViewController } from "./GKChallengesViewController.js";
 export interface _GKChallengesViewControllerDelegate {
     /** The challenge view has finished */
-    challengesViewControllerDidFinish$?(viewController: _GKChallengesViewController): void;
+    challengesViewControllerDidFinish$(viewController: _GKChallengesViewController): void;
 }

package/dist/GameKit/GKFriendRequestComposeViewControllerDelegate.d.ts

@@ -4,5 +4,5 @@ export interface _GKFriendRequestComposeViewControllerDelegate {
      * The compose view has finished
      * @deprecated No longer supported.
      */
-    friendRequestComposeViewControllerDidFinish$?(viewController: _GKFriendRequestComposeViewController): void;
+    friendRequestComposeViewControllerDidFinish$(viewController: _GKFriendRequestComposeViewController): void;
 }

package/dist/GameKit/GKGameCenterControllerDelegate.d.ts

@@ -1,4 +1,4 @@
 import type { _GKGameCenterViewController } from "./GKGameCenterViewController.js";
 export interface _GKGameCenterControllerDelegate {
-    gameCenterViewControllerDidFinish$?(gameCenterViewController: _GKGameCenterViewController): void;
+    gameCenterViewControllerDidFinish$(gameCenterViewController: _GKGameCenterViewController): void;
 }

package/dist/GameKit/GKLeaderboardViewControllerDelegate.d.ts

@@ -1,5 +1,5 @@
 import type { _GKLeaderboardViewController } from "./GKLeaderboardViewController.js";
 export interface _GKLeaderboardViewControllerDelegate {
     /** The leaderboard view has finished */
-    leaderboardViewControllerDidFinish$?(viewController: _GKLeaderboardViewController): void;
+    leaderboardViewControllerDidFinish$(viewController: _GKLeaderboardViewController): void;
 }

package/dist/GameKit/GKMatchmakerViewControllerDelegate.d.ts

@@ -7,9 +7,9 @@ import type { _NSError } from "../Foundation/NSError.js";
 import type { _NSString } from "../Foundation/NSString.js";
 export interface _GKMatchmakerViewControllerDelegate {
     /** The user has cancelled matchmaking */
-    matchmakerViewControllerWasCancelled$?(viewController: _GKMatchmakerViewController): void;
+    matchmakerViewControllerWasCancelled$(viewController: _GKMatchmakerViewController): void;
     /** Matchmaking has failed with an error */
-    matchmakerViewController$didFailWithError$?(viewController: _GKMatchmakerViewController, error: _NSError): void;
+    matchmakerViewController$didFailWithError$(viewController: _GKMatchmakerViewController, error: _NSError): void;
     /** A peer-to-peer match has been found, the game should start */
     matchmakerViewController$didFindMatch$?(viewController: _GKMatchmakerViewController, match: _GKMatch): void;
     /** Players have been found for a server-hosted game, the game should start */

package/dist/GameKit/GKTurnBasedEventHandlerDelegate.d.ts

@@ -4,11 +4,11 @@ export interface _GKTurnBasedEventHandlerDelegate {
     /**
      * @deprecated Use the ``GKLocalPlayer/register(_:)`` method of the ``GKLocalPlayer`` class instead.
      */
-    handleInviteFromGameCenter$?(playersToInvite: _NSArray): void;
+    handleInviteFromGameCenter$(playersToInvite: _NSArray): void;
     /**
      * @deprecated Use the ``GKLocalPlayer/register(_:)`` method of the ``GKLocalPlayer`` class instead.
      */
-    handleTurnEventForMatch$didBecomeActive$?(match: _GKTurnBasedMatch, didBecomeActive: boolean): void;
+    handleTurnEventForMatch$didBecomeActive$(match: _GKTurnBasedMatch, didBecomeActive: boolean): void;
     /**
      * @deprecated Use the ``GKLocalPlayer/register(_:)`` method of the ``GKLocalPlayer`` class instead.
      */

package/dist/GameKit/GKTurnBasedMatchmakerViewControllerDelegate.d.ts

@@ -3,9 +3,9 @@ import type { _GKTurnBasedMatchmakerViewController } from "./GKTurnBasedMatchmak
 import type { _NSError } from "../Foundation/NSError.js";
 export interface _GKTurnBasedMatchmakerViewControllerDelegate {
     /** The user has cancelled */
-    turnBasedMatchmakerViewControllerWasCancelled$?(viewController: _GKTurnBasedMatchmakerViewController): void;
+    turnBasedMatchmakerViewControllerWasCancelled$(viewController: _GKTurnBasedMatchmakerViewController): void;
     /** Matchmaking has failed with an error */
-    turnBasedMatchmakerViewController$didFailWithError$?(viewController: _GKTurnBasedMatchmakerViewController, error: _NSError): void;
+    turnBasedMatchmakerViewController$didFailWithError$(viewController: _GKTurnBasedMatchmakerViewController, error: _NSError): void;
     /**
      * Deprecated
      * @deprecated Use ``GKTurnBasedEventListener`` method ``GKTurnBasedEventListener/player(_:receivedTurnEventFor:didBecomeActive:)`` instead.

package/dist/GameKit/GKVoiceChatClient.d.ts

@@ -6,9 +6,9 @@ export interface _GKVoiceChatClient {
     /**
      * /must be sent within some reasonble period of time and should accept at least 512 bytes.
      */
-    voiceChatService$sendData$toParticipantID$?(voiceChatService: _GKVoiceChatService, data: _NSData, participantID: _NSString): void;
+    voiceChatService$sendData$toParticipantID$(voiceChatService: _GKVoiceChatService, data: _NSData, participantID: _NSString): void;
     /** / voice chat client's participant ID */
-    participantID?(): _NSString;
+    participantID(): _NSString;
     /**
      * should be sent immediately with no delay on a UDP peer-to-peer connection. If this method is implemented, then the Voice Chat Service will not attempt to set up a peer-to-peer connection. And will rely on this one. To transmit audio.
      */

package/dist/GameplayKit/GKGameModel.d.ts

@@ -6,15 +6,15 @@ export interface _GKGameModel extends _NSCopying {
     /**
      * Sets the data of another game model. All data should be copied over, and should not maintain any pointers to the copied game state. This is used by the GKMinmaxStrategist to process permutations of the game without needing to apply potentially destructive updates to the primary game model.
      */
-    setGameModel$?(gameModel: _GKGameModel): void;
+    setGameModel$(gameModel: _GKGameModel): void;
     /**
      * Returns an array of all the GKGameModelUpdates (i.e. actions/moves) that the active player can undertake, with one instance of GKGameModelUpdate for each possible move. Returns nil if the specified player is invalid, is not a part of the game model, or if there are no valid moves available.
      */
-    gameModelUpdatesForPlayer$?(player: _GKGameModelPlayer): _NSArray | null;
+    gameModelUpdatesForPlayer$(player: _GKGameModelPlayer): _NSArray | null;
     /**
      * Applies a GKGameModelUpdate to the game model, potentially resulting in a new activePlayer. GKMinmaxStrategist will call this method on a copy of the primary game model to speculate about possible future moves and their effects. It is assumed that calling this method performs a move on behalf of the player identified by the activePlayer property.
      */
-    applyGameModelUpdate$?(gameModelUpdate: _GKGameModelUpdate): void;
+    applyGameModelUpdate$(gameModelUpdate: _GKGameModelUpdate): void;
     /**
      * Returns the score for the specified player. A higher value indicates a better position for the player than a lower value. Required by GKMinmaxStrategist to determine which GKGameModelUpdate is the most advantageous for a given player. If the player is invalid, or not a part of the game model, returns NSIntegerMin.
      */
@@ -31,9 +31,9 @@ export interface _GKGameModel extends _NSCopying {
     /**
      * Array of instances of GKGameModelPlayers representing players within this game model. When the GKMinmaxStrategist class is used to find an optimal move for a specific player, it uses this array to rate the moves of that player’s opponent(s).
      */
-    players?(): _NSArray | null;
+    players(): _NSArray | null;
     /**
      * The player whose turn it is to perform an update to the game model. GKMinmaxStrategist assumes that the next call to the applyGameModelUpdate: method will perform a move on behalf of this player.
      */
-    activePlayer?(): _GKGameModelPlayer | null;
+    activePlayer(): _GKGameModelPlayer | null;
 }

package/dist/GameplayKit/GKGameModelPlayer.d.ts

@@ -1,4 +1,4 @@
 export interface _GKGameModelPlayer {
     /** Identifier used by GKMinmaxStrategist differentiate players from one another. */
-    playerId?(): number;
+    playerId(): number;
 }

package/dist/GameplayKit/GKGameModelUpdate.d.ts

@@ -1,5 +1,5 @@
 export interface _GKGameModelUpdate {
     /** Property get/set by GKMinmaxStrategist to sort GKGameModelUpdates. */
-    value?(): number;
-    setValue$?(value: number): void;
+    value(): number;
+    setValue$(value: number): void;
 }

package/dist/GameplayKit/GKRandom.d.ts

@@ -2,17 +2,17 @@ export interface _GKRandom {
     /**
      * Returns the next integer in the random sequence and moves ahead to the next one. The value is in the range of [INT32_MIN, INT32_MAX]. The lower bits are not guaranteed to be random so please use another property for simple choices. @see nextBool @see nextUniform
      */
-    nextInt?(): number;
+    nextInt(): number;
     /**
      * Returns the next unsigned value in the random sequence that is less than upperBound. The value is in the range of [0, upperBound). Thus the value never equals or exceeeds upperBound. The unsigned nature and upper bound allows implementations to use logical shifts to return a value whose lower bits are more random than a similar call to nextInt. This is used to implement nextBool and nextUniform by default.
      */
-    nextIntWithUpperBound$?(upperBound: number): number;
+    nextIntWithUpperBound$(upperBound: number): number;
     /**
      * Returns the next uniform float in the random sequence and moves ahead to the next one. The value is in the range of [0.0, 1.0]. There is no weighting across the range so remapping this with a curve may give the best sampling distribution for your algorithm. By default this should be based on nextIntWithUpperBound:. Implementions may base it on another representation if needed. @see nextIntWithUpperBound: @see nextInt
      */
-    nextUniform?(): number;
+    nextUniform(): number;
     /**
      * Returns the next true or false value in the random sequence and moves ahead to the next one. The value is either nonzero (true) or zero (false). Use this for simple boolean switches in logic that don't require fuzzy evaluation. For fuzzy evaluation use nextUniform. By default this should be based on nextIntWithUpperBound:. Implementations may base it on another representation if needed. @see nextIntWithUpperBound: @see nextUniform
      */
-    nextBool?(): boolean;
+    nextBool(): boolean;
 }

package/dist/GameplayKit/GKRandomDistribution.d.ts

@@ -54,3 +54,5 @@ export declare class _GKRandomDistribution extends _NSObject {
      */
     numberOfPossibleOutcomes(): number;
 }
+export interface _GKRandomDistribution extends _GKRandom {
+}

package/dist/GameplayKit/GKStrategist.d.ts

@@ -4,13 +4,13 @@ import type { _GKRandom } from "./GKRandom.js";
 import type { _GKRandomDistribution } from "./GKRandomDistribution.js";
 import type { _GKRandomSource } from "./GKRandomSource.js";
 export interface _GKStrategist {
-    bestMoveForActivePlayer?(): _GKGameModelUpdate | null;
+    bestMoveForActivePlayer(): _GKGameModelUpdate | null;
     /** The game model that we wish to select updates for. */
-    gameModel?(): _GKGameModel | null;
-    setGameModel$?(value: _GKGameModel | null): void;
+    gameModel(): _GKGameModel | null;
+    setGameModel$(value: _GKGameModel | null): void;
     /**
      * A random source to use when breaking ties between equally-strong moves when calling bestMoveForPlayer or when selecting a random move when randomMoveForPlayer is called. If set to nil, bestMoveForPlayer and randomMoveForPlayer will simply return the first best move available.
      */
-    randomSource?(): _GKRandomDistribution | _GKRandomSource | null;
-    setRandomSource$?(value: _GKRandom | null): void;
+    randomSource(): _GKRandomDistribution | _GKRandomSource | null;
+    setRandomSource$(value: _GKRandom | null): void;
 }

package/dist/HealthKit/HKCategoryTypeIdentifier.d.ts

@@ -1,3 +1,4 @@
+import type { NSStringLiteral } from "../helpers.js";
 export declare const HKCategoryTypeIdentifier: {
     readonly AppleStandHour: "HKCategoryTypeIdentifierAppleStandHour";
     readonly EnvironmentalAudioExposureEvent: "HKCategoryTypeIdentifierAudioExposureEvent";
@@ -70,4 +71,4 @@ export declare const HKCategoryTypeIdentifier: {
     readonly Wheezing: "HKCategoryTypeIdentifierWheezing";
     readonly AudioExposureEvent: "HKCategoryTypeIdentifierAudioExposureEvent";
 };
-export type HKCategoryTypeIdentifier = typeof HKCategoryTypeIdentifier[keyof typeof HKCategoryTypeIdentifier];
+export type HKCategoryTypeIdentifier = NSStringLiteral<(typeof HKCategoryTypeIdentifier)[keyof typeof HKCategoryTypeIdentifier]> | (typeof HKCategoryTypeIdentifier)[keyof typeof HKCategoryTypeIdentifier];

package/dist/HealthKit/HKCharacteristicTypeIdentifier.d.ts

@@ -1,3 +1,4 @@
+import type { NSStringLiteral } from "../helpers.js";
 export declare const HKCharacteristicTypeIdentifier: {
     readonly ActivityMoveMode: "HKCharacteristicTypeIdentifierActivityMoveMode";
     readonly BiologicalSex: "HKCharacteristicTypeIdentifierBiologicalSex";
@@ -6,4 +7,4 @@ export declare const HKCharacteristicTypeIdentifier: {
     readonly FitzpatrickSkinType: "HKCharacteristicTypeIdentifierFitzpatrickSkinType";
     readonly WheelchairUse: "HKCharacteristicTypeIdentifierWheelchairUse";
 };
-export type HKCharacteristicTypeIdentifier = typeof HKCharacteristicTypeIdentifier[keyof typeof HKCharacteristicTypeIdentifier];
+export type HKCharacteristicTypeIdentifier = NSStringLiteral<(typeof HKCharacteristicTypeIdentifier)[keyof typeof HKCharacteristicTypeIdentifier]> | (typeof HKCharacteristicTypeIdentifier)[keyof typeof HKCharacteristicTypeIdentifier];

package/dist/HealthKit/HKClinicalTypeIdentifier.d.ts

@@ -1,3 +1,4 @@
+import type { NSStringLiteral } from "../helpers.js";
 export declare const HKClinicalTypeIdentifier: {
     readonly AllergyRecord: "HKClinicalTypeIdentifierAllergyRecord";
     readonly ClinicalNoteRecord: "HKClinicalTypeIdentifierClinicalNoteRecord";
@@ -9,4 +10,4 @@ export declare const HKClinicalTypeIdentifier: {
     readonly VitalSignRecord: "HKClinicalTypeIdentifierVitalSignRecord";
     readonly CoverageRecord: "HKClinicalTypeIdentifierCoverageRecord";
 };
-export type HKClinicalTypeIdentifier = typeof HKClinicalTypeIdentifier[keyof typeof HKClinicalTypeIdentifier];
+export type HKClinicalTypeIdentifier = NSStringLiteral<(typeof HKClinicalTypeIdentifier)[keyof typeof HKClinicalTypeIdentifier]> | (typeof HKClinicalTypeIdentifier)[keyof typeof HKClinicalTypeIdentifier];

package/dist/HealthKit/HKCorrelationTypeIdentifier.d.ts

@@ -1,5 +1,6 @@
+import type { NSStringLiteral } from "../helpers.js";
 export declare const HKCorrelationTypeIdentifier: {
     readonly BloodPressure: "HKCorrelationTypeIdentifierBloodPressure";
     readonly Food: "HKCorrelationTypeIdentifierFood";
 };
-export type HKCorrelationTypeIdentifier = typeof HKCorrelationTypeIdentifier[keyof typeof HKCorrelationTypeIdentifier];
+export type HKCorrelationTypeIdentifier = NSStringLiteral<(typeof HKCorrelationTypeIdentifier)[keyof typeof HKCorrelationTypeIdentifier]> | (typeof HKCorrelationTypeIdentifier)[keyof typeof HKCorrelationTypeIdentifier];

package/dist/HealthKit/HKDocumentTypeIdentifier.d.ts

@@ -1,4 +1,5 @@
+import type { NSStringLiteral } from "../helpers.js";
 export declare const HKDocumentTypeIdentifier: {
     readonly CDA: "HKDocumentTypeIdentifierCDA";
 };
-export type HKDocumentTypeIdentifier = typeof HKDocumentTypeIdentifier[keyof typeof HKDocumentTypeIdentifier];
+export type HKDocumentTypeIdentifier = NSStringLiteral<(typeof HKDocumentTypeIdentifier)[keyof typeof HKDocumentTypeIdentifier]> | (typeof HKDocumentTypeIdentifier)[keyof typeof HKDocumentTypeIdentifier];

package/dist/HealthKit/HKFHIRRelease.d.ts

@@ -1,6 +1,7 @@
+import type { NSStringLiteral } from "../helpers.js";
 export declare const HKFHIRRelease: {
     readonly DSTU2: "DSTU2";
     readonly R4: "R4";
     readonly Unknown: "unknown";
 };
-export type HKFHIRRelease = typeof HKFHIRRelease[keyof typeof HKFHIRRelease];
+export type HKFHIRRelease = NSStringLiteral<(typeof HKFHIRRelease)[keyof typeof HKFHIRRelease]> | (typeof HKFHIRRelease)[keyof typeof HKFHIRRelease];

package/dist/HealthKit/HKFHIRResourceType.d.ts

@@ -1,3 +1,4 @@
+import type { NSStringLiteral } from "../helpers.js";
 export declare const HKFHIRResourceType: {
     readonly AllergyIntolerance: "AllergyIntolerance";
     readonly Condition: "Condition";
@@ -12,4 +13,4 @@ export declare const HKFHIRResourceType: {
     readonly Observation: "Observation";
     readonly Procedure: "Procedure";
 };
-export type HKFHIRResourceType = typeof HKFHIRResourceType[keyof typeof HKFHIRResourceType];
+export type HKFHIRResourceType = NSStringLiteral<(typeof HKFHIRResourceType)[keyof typeof HKFHIRResourceType]> | (typeof HKFHIRResourceType)[keyof typeof HKFHIRResourceType];

package/dist/HealthKit/HKHealthConceptDomain.d.ts

@@ -1,4 +1,5 @@
+import type { NSStringLiteral } from "../helpers.js";
 export declare const HKHealthConceptDomain: {
     readonly Medication: "HKHealthConceptDomainMedication";
 };
-export type HKHealthConceptDomain = typeof HKHealthConceptDomain[keyof typeof HKHealthConceptDomain];
+export type HKHealthConceptDomain = NSStringLiteral<(typeof HKHealthConceptDomain)[keyof typeof HKHealthConceptDomain]> | (typeof HKHealthConceptDomain)[keyof typeof HKHealthConceptDomain];

package/dist/HealthKit/HKLiveWorkoutBuilderDelegate.d.ts

@@ -5,11 +5,11 @@ export interface _HKLiveWorkoutBuilderDelegate {
     /**
      * @method workoutBuilder:didCollectDataOfTypes: @abstract Called every time new samples are added to the workout builder. @discussion With new samples added, statistics for the collectedTypes may have changed and should be read again @param workoutBuilder The workout builder to which samples were added. @param collectedTypes The sample types that were added.
      */
-    workoutBuilder$didCollectDataOfTypes$?(workoutBuilder: _HKLiveWorkoutBuilder, collectedTypes: _NSSet): void;
+    workoutBuilder$didCollectDataOfTypes$(workoutBuilder: _HKLiveWorkoutBuilder, collectedTypes: _NSSet): void;
     /**
      * @method workoutBuilderDidCollectEvent: @abstract Called every time a new event is added to the workout builder. @param workoutBuilder The workout builder to which an event was added.
      */
-    workoutBuilderDidCollectEvent$?(workoutBuilder: _HKLiveWorkoutBuilder): void;
+    workoutBuilderDidCollectEvent$(workoutBuilder: _HKLiveWorkoutBuilder): void;
     /**
      * @method workoutBuilder:didBeginActivity: @abstract Called every time new activity is started and added to the workout builder. @param workoutBuilder The workout builder to which the activity was added to. @param workoutActivity The activity that was added.
      */

package/dist/HealthKit/HKQuantityTypeIdentifier.d.ts

@@ -1,3 +1,4 @@
+import type { NSStringLiteral } from "../helpers.js";
 export declare const HKQuantityTypeIdentifier: {
     readonly AppleSleepingWristTemperature: "HKQuantityTypeIdentifierAppleSleepingWristTemperature";
     readonly BodyFatPercentage: "HKQuantityTypeIdentifierBodyFatPercentage";
@@ -120,4 +121,4 @@ export declare const HKQuantityTypeIdentifier: {
     readonly BloodGlucose: "HKQuantityTypeIdentifierBloodGlucose";
     readonly BodyTemperature: "HKQuantityTypeIdentifierBodyTemperature";
 };
-export type HKQuantityTypeIdentifier = typeof HKQuantityTypeIdentifier[keyof typeof HKQuantityTypeIdentifier];
+export type HKQuantityTypeIdentifier = NSStringLiteral<(typeof HKQuantityTypeIdentifier)[keyof typeof HKQuantityTypeIdentifier]> | (typeof HKQuantityTypeIdentifier)[keyof typeof HKQuantityTypeIdentifier];

package/dist/HealthKit/HKScoredAssessmentTypeIdentifier.d.ts

@@ -1,5 +1,6 @@
+import type { NSStringLiteral } from "../helpers.js";
 export declare const HKScoredAssessmentTypeIdentifier: {
     readonly GAD7: "HKScoredAssessmentTypeIdentifierGAD7";
     readonly PHQ9: "HKScoredAssessmentTypeIdentifierPHQ9";
 };
-export type HKScoredAssessmentTypeIdentifier = typeof HKScoredAssessmentTypeIdentifier[keyof typeof HKScoredAssessmentTypeIdentifier];
+export type HKScoredAssessmentTypeIdentifier = NSStringLiteral<(typeof HKScoredAssessmentTypeIdentifier)[keyof typeof HKScoredAssessmentTypeIdentifier]> | (typeof HKScoredAssessmentTypeIdentifier)[keyof typeof HKScoredAssessmentTypeIdentifier];

package/dist/HealthKit/HKVerifiableClinicalRecordCredentialType.d.ts

@@ -1,7 +1,8 @@
+import type { NSStringLiteral } from "../helpers.js";
 export declare const HKVerifiableClinicalRecordCredentialType: {
     readonly COVID19: "https://smarthealth.cards#covid19";
     readonly Immunization: "https://smarthealth.cards#immunization";
     readonly Laboratory: "https://smarthealth.cards#laboratory";
     readonly Recovery: "https://smarthealth.cards#recovery";
 };
-export type HKVerifiableClinicalRecordCredentialType = typeof HKVerifiableClinicalRecordCredentialType[keyof typeof HKVerifiableClinicalRecordCredentialType];
+export type HKVerifiableClinicalRecordCredentialType = NSStringLiteral<(typeof HKVerifiableClinicalRecordCredentialType)[keyof typeof HKVerifiableClinicalRecordCredentialType]> | (typeof HKVerifiableClinicalRecordCredentialType)[keyof typeof HKVerifiableClinicalRecordCredentialType];

package/dist/HealthKit/HKVerifiableClinicalRecordSourceType.d.ts

@@ -1,5 +1,6 @@
+import type { NSStringLiteral } from "../helpers.js";
 export declare const HKVerifiableClinicalRecordSourceType: {
     readonly SMARTHealthCard: "SMARTHealthCard";
     readonly EUDigitalCOVIDCertificate: "EUDigitalCOVIDCertificate";
 };
-export type HKVerifiableClinicalRecordSourceType = typeof HKVerifiableClinicalRecordSourceType[keyof typeof HKVerifiableClinicalRecordSourceType];
+export type HKVerifiableClinicalRecordSourceType = NSStringLiteral<(typeof HKVerifiableClinicalRecordSourceType)[keyof typeof HKVerifiableClinicalRecordSourceType]> | (typeof HKVerifiableClinicalRecordSourceType)[keyof typeof HKVerifiableClinicalRecordSourceType];

package/dist/HealthKit/HKWorkoutSessionDelegate.d.ts

@@ -9,11 +9,11 @@ export interface _HKWorkoutSessionDelegate {
     /**
      * @method workoutSession:didChangeToState:fromState:date: @abstract This method is called when a workout session transitions to a new state. @discussion The date is provided to indicate when the state change actually happened. If your application is suspended then the delegate will receive this call once the application resumes, which may be much later than when the original state change ocurred.
      */
-    workoutSession$didChangeToState$fromState$date$?(workoutSession: _HKWorkoutSession, toState: HKWorkoutSessionState, fromState: HKWorkoutSessionState, date: _NSDate): void;
+    workoutSession$didChangeToState$fromState$date$(workoutSession: _HKWorkoutSession, toState: HKWorkoutSessionState, fromState: HKWorkoutSessionState, date: _NSDate): void;
     /**
      * @method workoutSession:didFailWithError: @abstract This method is called when an error occurs that stops a workout session. @discussion When the state of the workout session changes due to an error occurring, this method is always called before workoutSession:didChangeToState:fromState:date:.
      */
-    workoutSession$didFailWithError$?(workoutSession: _HKWorkoutSession, error: _NSError): void;
+    workoutSession$didFailWithError$(workoutSession: _HKWorkoutSession, error: _NSError): void;
     /**
      * @method workoutSession:didGenerateEvent: @abstract This method is called whenever the system generates a workout event. @discussion Whenever a workout event is generated, such as pause or resume detection, the event will be passed to the session delegate via this method. Clients may save the generated events to use when creating an HKWorkout object.
      */