@decky/ui 4.9.2 → 4.10.1

package/src/globals/steam-client/Parental.ts

@@ -0,0 +1,129 @@
+import { EResult, Unregisterable } from "./shared";
+
+/**
+ * Interface for managing parental control settings.
+ */
+export interface Parental {
+    /**
+     * Locks the parental control settings.
+     */
+    LockParentalLock(): void;
+
+    RegisterForParentalPlaytimeWarnings(callback: (time: number) => void): Unregisterable;
+
+    /**
+     * Registers a callback function to be invoked when parental settings change.
+     * @param callback The callback function to be invoked when parental settings change.
+     * @returns an object that can be used to unregister the callback.
+     */
+    RegisterForParentalSettingsChanges(callback: (settings: ParentalSettings) => void): Unregisterable;
+
+    /**
+     * Unlocks the parental lock with the provided PIN.
+     * @param pin The 4-digit PIN to unlock the parental lock.
+     * @returns a number representing the result of the unlock operation.
+     */
+    UnlockParentalLock(pin: string, param1: boolean): Promise<EResult>;
+}
+
+export interface ParentalSettings {
+  ever_enabled: boolean;
+  locked: boolean;
+  /**
+   * If deserialized, returns {@link ParentalSettingsProtoMsg}.
+   */
+  settings: ArrayBuffer;
+  strPlaintextPassword: string;
+}
+
+/**
+ * Represents the parental settings and restrictions.
+ * @todo This whole thing is unconfirmed as I do not have access to parental
+ * stuff and things
+ */
+export interface ParentalSettingsProtoMsg {
+    steamid?: number;
+    applist_base_id?: number;
+    applist_base_description?: string;
+    /**
+     * Base list.
+     */
+    applist_base: ParentalApp[];
+    /**
+     * Custom list of allowed applications.
+     */
+    applist_custom: ParentalApp[];
+    /**
+     * @todo enum ?
+     */
+    passwordhashtype?: number;
+    salt?: number;
+    passwordhash?: number;
+    /**
+     * Indicates whether parental settings are enabled.
+     */
+    is_enabled?: boolean;
+    /**
+     * Bitmask representing enabled features.
+     * - Bit 0: Unknown (@todo Please provide more details if known)
+     * - Bit 1: Online content & features - Steam Store
+     * - Bit 2: Online content & features - Community-generated content
+     * - Bit 3: Online content & features - My online profile, screenshots, and achievements
+     * - Bit 4: Online content & features - Friends, chat, and groups
+     * - Bit 5-11: Unknown (@todo Please provide more details if known)
+     * - Bit 12: Library content - 0: Only games I choose, 1: All games
+     * @todo {@link EParentalFeature} ?
+     */
+    enabled_features?: number;
+    /**
+     * Email for recovery (if applicable).
+     */
+    recovery_email?: string;
+    is_site_license_lock?: boolean;
+    temporary_enabled_features?: number;
+    rtime_temporary_feature_expiration?: number;
+    playtime_restrictions?: ParentalPlaytimeRestrictions;
+    temporary_playtime_restrictions?: ParentalTemporaryPlaytimeRestrictions;
+    excluded_store_content_descriptors: number[];
+    excluded_community_content_descriptors: number[];
+    utility_appids: number[];
+}
+
+interface ParentalApp {
+  appid: number;
+  is_allowed: boolean;
+}
+
+interface ParentalPlaytimeDay {
+  allowed_time_windows?: number;
+  allowed_daily_minutes?: number;
+}
+
+interface ParentalPlaytimeRestrictions {
+  apply_playtime_restrictions?: boolean;
+  playtime_days: ParentalPlaytimeDay[];
+}
+
+interface ParentalTemporaryPlaytimeRestrictions {
+  restrictions?: ParentalPlaytimeDay;
+  rtime_expires?: number;
+}
+
+export enum EParentalFeature {
+  Invalid,
+  Store,
+  Community,
+  Profile,
+  Friends,
+  News,
+  Trading,
+  Settings,
+  Console,
+  Browser,
+  ParentalSetup,
+  Library,
+  Test,
+  SiteLicense,
+  KioskMode,
+  Max,
+}

package/src/globals/steam-client/RemotePlay.ts

@@ -0,0 +1,342 @@
+import {EControllerType} from "./Input";
+import { EParentalFeature } from "./Parental";
+import { EResult, Unregisterable } from "./shared";
+
+export interface RemotePlay {
+    /**
+     * @param param1 TODO: Something about restrictions countries ? maybe it's games
+     */
+    BCanAcceptInviteForGame(gameId: string, param1: string): Promise<boolean>;
+    BCanCreateInviteForGame(gameId: string, param1: boolean): Promise<boolean>;
+
+    BRemotePlayTogetherGuestOnPhoneOrTablet(steam64Id: string, guestId: number): Promise<boolean>;
+
+    BRemotePlayTogetherGuestSupported(): Promise<boolean>;
+
+    // TODO: both calls have 1 arg, but it requires 2
+    CancelInviteAndSession(steam64Id: string, param1: number): Promise<EResult>;
+
+    CancelInviteAndSessionWithGuestID(steam64Id: string, guestId: number): Promise<EResult>;
+
+    CancelRemoteClientPairing(): void;
+
+    CloseGroup(): Promise<number>;
+
+    CreateGroup(param0: string): Promise<EResult>;
+
+    CreateInviteAndSession(steam64Id: string, param1: string): Promise<EResult>;
+
+    CreateInviteAndSessionWithGuestID(steam64Id: string, guestId: number, param2: string): Promise<EResult>;
+
+    GetClientID(): Promise<string>;
+
+    // TODO: -1 no preference? no idea where the settings are anyway lol
+    GetClientStreamingBitrate(): Promise<number>;
+    GetClientStreamingQuality(): Promise<number>;
+    GetControllerType(controllerIndex: number): Promise<EControllerType>;
+
+    /**
+     * @returns an integer from 0 to 100.
+     */
+    GetGameSystemVolume(): Promise<number>;
+
+    GetPerUserInputSettings(steam64Id: string): Promise<RemotePlayInputSettings>;
+
+    GetPerUserInputSettingsWithGuestID(steam64Id: string, guestId: number): Promise<RemotePlayInputSettings>;
+
+    IdentifyController(nControllerIndex: number): void;
+
+    InstallAudioDriver(): void;
+    InstallInputDriver(): void;
+    MoveControllerToSlot(controllerIndex: number, slot: number): void;
+    RegisterForAdditionalParentalBlocks(callback: (blocks: EParentalFeature[]) => void): Unregisterable;
+    RegisterForAudioDriverPrompt(callback: () => void): Unregisterable;
+
+    /**
+     * @todo no mentions of it in Steam code
+     */
+    RegisterForBitrateOverride: Unregisterable;
+    RegisterForClearControllers(callback: () => void): Unregisterable;
+    RegisterForControllerIndexSet(
+      callback: (steamid: string, slot: number, guestid: number) => void
+    ): Unregisterable;
+
+    RegisterForDevicesChanges(callback: (devices: RemotePlayDevice[]) => void): Unregisterable;
+
+    RegisterForGroupCreated(callback: (steamId: string, appId: string) => void): Unregisterable;
+    RegisterForGroupDisbanded(callback: () => void): Unregisterable;
+    RegisterForInputDriverPrompt(callback: () => void): Unregisterable;
+    RegisterForInputDriverRestartNotice(callback: () => void): Unregisterable;
+
+    RegisterForInputUsed(
+        callback: (steam64Id: string, type: EClientUsedInputType, guestId: number) => void,
+    ): Unregisterable; // only fires on host
+
+    RegisterForInviteResult(
+      callback: (
+        steamId: string,
+        param1: any,
+        result: ERemoteClientLaunch,
+      ) => void
+    ): Unregisterable;
+
+    RegisterForNetworkUtilizationUpdate(
+        callback: (steam64Id: string, guestId: number, networkUtilization: number, networkDuration: number) => void,
+    ): Unregisterable; // only fires on host
+
+    RegisterForPlaceholderStateChanged(callback: (isShowingPlaceholder: boolean) => void): Unregisterable;
+
+    RegisterForPlayerInputSettingsChanged(
+      callback: (steamId: string, settings: RemotePlayInputSettings, guestId: number) => void
+    ): Unregisterable;
+
+    RegisterForQualityOverride(callback: (hostStreamingQualityOverride: number) => void): Unregisterable;
+
+    RegisterForRemoteClientLaunchFailed(callback: (state: ERemoteClientLaunch) => void): Unregisterable;
+
+    RegisterForRemoteClientStarted(callback: (steam64Id: string, appId: string) => void): Unregisterable; // only fires on client
+
+    RegisterForRemoteClientStopped(callback: (steam64Id: string, appId: string) => void): Unregisterable; // only fires on client
+
+    RegisterForRemoteDeviceAuthorizationCancelled(callback: () => void): Unregisterable;
+
+    RegisterForRemoteDeviceAuthorizationRequested(callback: (device: string) => void): Unregisterable;
+
+    RegisterForRemoteDevicePairingPINChanged(callback: (device: string, pin: string) => void): Unregisterable;
+
+    RegisterForRestrictedSessionChanges(callback: (restrictedSession: boolean) => void): Unregisterable;
+
+    RegisterForSessionStopped(callback: (steam64Id: string, guestId: number, avatarHash: string) => void): Unregisterable;
+
+    RegisterForSessionStarted(callback: (steam64Id: string, gameId: string, guestId: number) => void): Unregisterable;
+
+    RegisterForSessionStopped(callback: (steam64Id: string, guestId: number) => void): Unregisterable;
+
+    RegisterForSettingsChanges(callback: (remotePlaySettings: RemotePlaySettings) => void): Unregisterable;
+
+    SetClientStreamingBitrate(bitrate: number): void;
+
+    SetClientStreamingQuality(quality: number): void;
+
+    SetGameSystemVolume(volume: number): void;
+
+    SetPerUserControllerInputEnabled(steam64Id: string, enabled: boolean): void;
+
+    SetPerUserControllerInputEnabledWithGuestID(steam64Id: string, guestId: number, enabled: boolean): void;
+
+    SetPerUserKeyboardInputEnabled(steam64Id: string, enabled: boolean): void;
+
+    SetPerUserKeyboardInputEnabledWithGuestID(steam64Id: string, guestId: number, enabled: boolean): void;
+
+    SetPerUserMouseInputEnabled(steam64Id: string, enabled: boolean): void;
+
+    SetPerUserMouseInputEnabledWithGuestID(steam64Id: string, guestId: number, enabled: boolean): void;
+
+    SetRemoteDeviceAuthorized(param0: boolean, param1: string): void;
+
+    SetRemoteDevicePIN(pin: string): void;
+
+    SetRemotePlayEnabled(enabled: boolean): void;
+
+    /**
+     * @param base64 Serialized base64 message from {@link StreamingClientConfig}.
+     */
+    SetStreamingClientConfig(base64: string, sessionId: number): void;
+  
+    /**
+     * Enables advanced client options.
+     */
+    SetStreamingClientConfigEnabled(value: boolean): void;
+
+    SetStreamingDesktopToRemotePlayTogetherEnabled(enabled: boolean): void;
+
+    SetStreamingP2PScope(scope: EStreamP2PScope): void;
+
+    /**
+     * @param base64 Serialized base64 message from {@link StreamingServerConfig}.
+     */
+    SetStreamingServerConfig(base64: string, sessionId: number): void;
+
+    /**
+     * Enables advanced host options.
+     */
+    SetStreamingServerConfigEnabled(value: boolean): void;
+
+    StopStreamingClient(): void;
+
+    StopStreamingSession(id: number): void;
+    StopStreamingSessionAndSuspendDevice(id: number): void;
+
+    UnlockH264(): void;
+
+    /**
+     * Unpairs all devices.
+     */
+    UnpairRemoteDevices(): void;
+}
+
+export enum EClientUsedInputType {
+    Keyboard,
+    Mouse,
+    Controller,
+    Max,
+}
+
+export interface RemotePlayDevice {
+    clientId: string;
+    clientName: string;
+    status: string; // "Connected", "Paired",
+    formFactor: number;
+    unStreamingSessionID: number;
+    bCanSteamVR: boolean;
+    bCanSuspend: boolean;
+}
+
+interface RemotePlayInputSettings {
+  bKeyboardEnabled: true;
+  bMouseEnabled: true;
+  bControllerEnabled: true;
+}
+
+export interface RemotePlaySettings {
+    bAV1DecodeAvailable: boolean;
+    bHEVCDecodeAvailable: boolean;
+    bRemotePlayDisabledBySystemPolicy: boolean;
+    bRemotePlaySupported: boolean;
+    bRemotePlayEnabled: boolean;
+    eRemotePlayP2PScope: EStreamP2PScope;
+    bRemotePlayServerConfigAvailable: boolean;
+    bRemotePlayServerConfigEnabled: boolean;
+    bRemotePlayClientConfigEnabled: boolean;
+    unStreamingSessionID: number;
+    strStreamingClientName: string;
+    /**
+     * If deserialized, returns {@link StreamingClientConfig}.
+     */
+    RemotePlayClientConfig: StreamingClientConfig;
+    /**
+     * If deserialized, returns {@link StreamingServerConfig}.
+     */
+    RemotePlayServerConfig: ArrayBuffer;
+    nDefaultAudioChannels: number;
+    nAutomaticResolutionX: number;
+    nAutomaticResolutionY: number;
+}
+
+export interface StreamingClientConfig {
+  quality?: EStreamQualityPreference;
+  desired_resolution_x?: number;
+  desired_resolution_y?: number;
+  desired_framerate_numerator?: number;
+  desired_framerate_denominator?: number;
+  desired_bitrate_kbps?: number;
+  enable_hardware_decoding?: boolean;
+  enable_performance_overlay?: boolean;
+  enable_video_streaming?: boolean;
+  enable_audio_streaming?: boolean;
+  enable_input_streaming?: boolean;
+  audio_channels?: number;
+  enable_video_hevc?: boolean;
+  enable_performance_icons?: boolean;
+  enable_microphone_streaming?: boolean;
+  controller_overlay_hotkey?: string;
+  enable_touch_controller_OBSOLETE?: boolean;
+  p2p_scope?: EStreamP2PScope;
+  enable_audio_uncompressed?: boolean;
+  display_limit?: StreamVideoLimit;
+  quality_limit?: StreamVideoLimit;
+  runtime_limit?: StreamVideoLimit;
+  decoder_limit: StreamVideoLimit[];
+}
+
+export interface StreamingServerConfig {
+  change_desktop_resolution?: boolean;
+  dynamically_adjust_resolution_OBSOLETE?: boolean;
+  enable_capture_nvfbc?: boolean;
+  enable_hardware_encoding_nvidia_OBSOLETE?: boolean;
+  enable_hardware_encoding_amd_OBSOLETE?: boolean;
+  enable_hardware_encoding_intel_OBSOLETE?: boolean;
+  software_encoding_threads?: number;
+  enable_traffic_priority?: boolean;
+  host_play_audio?: EStreamHostPlayAudioPreference;
+  enable_hardware_encoding?: boolean;
+}
+
+export interface StreamVideoLimit {
+  codec?: EStreamVideoCodec;
+  mode?: StreamVideoMode;
+  bitrate_kbps?: number;
+  burst_bitrate_kbps?: number;
+}
+
+export interface StreamVideoMode {
+  width?: number;
+  height?: number;
+  refresh_rate?: number;
+  refresh_rate_numerator?: number;
+  refresh_rate_denominator?: number;
+}
+
+export enum ERemoteClientLaunch {
+  OK = 1,
+  Fail,
+  RequiresUI,
+  RequiresLaunchOption,
+  RequiresEULA,
+  Timeout,
+  StreamTimeout,
+  StreamClientFail,
+  OtherGameRunning,
+  DownloadStarted,
+  DownloadNoSpace,
+  DownloadFiltered,
+  DownloadRequiresUI,
+  AccessDenied,
+  NetworkError,
+  Progress,
+  ParentalUnlockFailed,
+  ScreenLocked,
+  Unsupported,
+  DisabledLocal,
+  DisabledRemote,
+  Broadcasting,
+  Busy,
+  DriversNotInstalled,
+  TransportUnavailable,
+  Canceled,
+  Invisible,
+  RestrictedCountry,
+  Unauthorized,
+}
+
+export enum EStreamVideoCodec {
+  None,
+  Raw,
+  VP8,
+  VP9,
+  H264,
+  HEVC,
+  ORBX1,
+  ORBX2,
+  AV1,
+}
+
+export enum EStreamHostPlayAudioPreference {
+  Default,
+  Always,
+}
+
+export enum EStreamQualityPreference {
+  Automatic = -1,
+  Fast = 1,
+  Balanced,
+  Beautiful,
+}
+
+export enum EStreamP2PScope {
+    Automatic,
+    Disabled,
+    OnlyMe,
+    Friends,
+    Everyone,
+}

package/src/globals/steam-client/Screenshots.ts

@@ -0,0 +1,149 @@
+/**
+ * Interface for managing screenshots.
+ */
+export interface Screenshots {
+    /**
+     * Deletes a local screenshot.
+     * @param appId The ID of the application.
+     * @param screenshotIndex The index of the local screenshot.
+     * @returns a boolean value indicating whether the deletion was successful.
+     */
+    DeleteLocalScreenshot(appId: string, screenshotIndex: number): Promise<boolean>;
+
+    DeleteLocalScreenshots(screenshots: ScreenshotToDelete[]): Promise<ScreenshotDeletionResponse>;
+
+    /**
+     * Retrieves all local screenshots for all applications.
+     * @returns an array of Screenshot objects.
+     */
+    GetAllAppsLocalScreenshots(): Promise<Screenshot[]>;
+
+    /**
+     * Retrieves the count of all local screenshots for all applications.
+     * @returns the count of local screenshots.
+     */
+    GetAllAppsLocalScreenshotsCount(): Promise<number>;
+
+    /**
+     * Retrieves a range of local screenshots for all applications.
+     * @param start The starting index of the screenshot range.
+     * @param end The ending index of the screenshot range.
+     * @returns an array of Screenshot objects within the specified range.
+     */
+    GetAllAppsLocalScreenshotsRange(start: number, end: number): Promise<Screenshot[]>;
+
+    /**
+     * Retrieves all local screenshots.
+     * @returns an array of Screenshot objects.
+     */
+    GetAllLocalScreenshots(): Promise<Screenshot[]>;
+
+    /**
+     * Retrieves the game associated with a specific local screenshot index.
+     * @param screenshotIndex The index of the local screenshot.
+     * @returns the ID of the game associated with the screenshot.
+     */
+    GetGameWithLocalScreenshots(screenshotIndex: number): Promise<number>;
+
+    /**
+     * Retrieves the last taken local screenshot.
+     * @returns the last taken local screenshot.
+     */
+    GetLastScreenshotTaken(): Promise<Screenshot>;
+
+    /**
+     * Retrieves a specific local screenshot for an application.
+     * @param appId The ID of the application.
+     * @param screenshotIndex The index of the local screenshot.
+     * @returns the requested local screenshot.
+     */
+    GetLocalScreenshotByHandle(appId: string, screenshotIndex: number): Promise<Screenshot>;
+
+    /**
+     * Retrieves the count of local screenshots for a specific application.
+     * @param appId The ID of the application.
+     * @returns the count of local screenshots for the application.
+     */
+    GetLocalScreenshotCount(appId: number): Promise<number>;
+
+    /**
+     * Retrieves the path of a screenshot.
+     * @param appId The ID of the application.
+     * @param hHandle The handle of the screenshot.
+     * @returns the screenshot path or the screenshot directory if no such handle.
+     */
+    GetLocalScreenshotPath(appId: number, hHandle: number): Promise<string>;
+
+    /**
+     * Retrieves the number of games with local screenshots.
+     * @returns the number of games with local screenshots.
+     */
+    GetNumGamesWithLocalScreenshots(): Promise<number>;
+
+    /**
+     * Gets total screenshot usage in the specified library folder.
+     * @param path Library folder path.
+     * @returns the number of taken space in bytes.
+     */
+    GetTotalDiskSpaceUsage(path: string): Promise<number>;
+
+    /**
+     * Opens a local screenshot in the system image viewer.
+     * If the screenshot index is invalid, this function opens the screenshots directory for the specified application ID.
+     * @param appId The ID of the application.
+     * @param screenshotIndex The index of the local screenshot.
+     */
+    ShowScreenshotInSystemViewer(appId: string, screenshotIndex: number): void;
+
+    /**
+     * Opens the folder containing local screenshots for a specific application.
+     * @param appId The ID of the application.
+     */
+    ShowScreenshotsOnDisk(appId: string): void;
+
+    /**
+     * Uploads a local screenshot.
+     * @param appId The ID of the application.
+     * @param localScreenshot_hHandle The handle of the local screenshot.
+     * @param filePrivacyState The privacy state of the screenshot file.
+     * @returns a boolean value indicating whether the upload was successful.
+     */
+    UploadLocalScreenshot(
+        appId: string,
+        localScreenshot_hHandle: number,
+        filePrivacyState: EUCMFilePrivacyState,
+    ): Promise<boolean>;
+}
+
+export interface Screenshot {
+    nAppID: number;
+    strGameID: string;
+    hHandle: number;
+    nWidth: number;
+    nHeight: number;
+    nCreated: number; // timestamp
+    ePrivacy: EUCMFilePrivacyState;
+    strCaption: string;
+    bSpoilers: boolean;
+    strUrl: string;
+    bUploaded: boolean;
+    ugcHandle: string;
+}
+
+export interface ScreenshotToDelete {
+    gameID: string;
+    rgHandles: number[];
+}
+
+export interface ScreenshotDeletionResponse {
+    bSuccess: boolean;
+    rgFailedRequestIndices: number[];
+}
+
+export enum EUCMFilePrivacyState {
+    Invalid = -1,
+    Private = 1 << 1,
+    FriendsOnly = 1 << 2,
+    Public = 1 << 3,
+    Unlisted = 1 << 4,
+}