@decky/ui 4.9.2 → 4.10.0

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

@@ -0,0 +1,105 @@
+import { EResult, JsPbMessage, OperationResponse } from "./shared";
+import {EOSType} from "./system";
+
+export interface Auth {
+    /**
+     * @returns a boolean indicating if the operation succeeded.
+     */
+    ClearCachedSignInPin(): Promise<boolean>;
+
+    CurrentUserHasCachedSignInPin(): Promise<boolean>;
+
+    GetLocalHostname(): Promise<string>;
+
+    /**
+     * @returns a ProtoBuf message. If deserialized, returns {@link CAuthentication_DeviceDetails}.
+     */
+    GetMachineID(): Promise<ArrayBuffer>;
+
+    GetRefreshInfo(): Promise<AuthRefreshInfo>;
+
+    GetSteamGuardData(param0: string): Promise<SteamGuardData>;
+
+    /**
+     * "Secured" refers to unshared.
+     */
+    IsSecureComputer(): Promise<boolean>;
+
+    SetCachedSignInPin(pin: string): Promise<boolean>;
+
+    SetLoginToken(refreshToken: string, accountName: string): Promise<OperationResponse>;
+
+    SetSteamGuardData(accountName: string, newGuardData: string): void;
+
+    StartSignInFromCache(accountName: string, offlineMode: boolean): Promise<OperationResponse | void>;
+
+    UserHasCachedSignInPin(accountName: string): Promise<boolean>;
+
+    ValidateCachedSignInPin(accountName: string, pin: string): Promise<boolean>;
+}
+
+export interface AuthRefreshInfo {
+    reason: number;
+    account_name: string;
+    login_id_token: string;
+}
+
+export interface SteamGuardData {
+  data: string;
+  eresult: EResult;
+}
+
+/**
+ * `deserializeBinary` argument:
+ * ```
+ * [
+ *     await SteamClient.System.GetOSType(),
+ *     await SteamClient.Auth.GetLocalHostname(),
+ *     await SteamClient.Auth.GetMachineID(),
+ * ];
+ * ```
+ */
+export interface CAuthentication_DeviceDetails extends JsPbMessage {
+    client_count(): number | undefined;
+
+    device_friendly_name(): string | undefined;
+
+    gaming_device_type(): EGamingDeviceType | undefined;
+
+    machine_id(): Uint8Array | string;
+
+    os_type(): EOSType | undefined;
+
+    platform_type(): EAuthTokenPlatformType | undefined;
+
+    set_client_count(): any;
+
+    set_device_friendly_name(): any;
+
+    set_gaming_device_type(): any;
+
+    set_machine_id(): any;
+
+    set_os_type(): any;
+
+    set_platform_type(): any;
+}
+
+export enum EAuthTokenPlatformType {
+    Unknown,
+    SteamClient,
+    WebBrowser,
+    MobileApp,
+}
+
+export enum EGamingDeviceType {
+    Unknown,
+    StandardPC,
+    Console = 256,
+    PS3 = 272,
+    Steambox = 288,
+    Tesla = 320,
+    Handheld = 512,
+    Phone = 528,
+    SteamDeck = 544,
+}

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

@@ -0,0 +1,56 @@
+import { EResult, Unregisterable } from "./shared";
+
+export interface Broadcast {
+    /**
+     * Approves a viewer request for the broadcast.
+     * @param steamId64 The SteamID64 of the user whose request is to be approved.
+     */
+    ApproveViewerRequest(steamId64: string, param1: number): void;
+
+    /**
+     * Invites a user identified by their SteamID64 to watch the broadcast.
+     * @param steamId64 The SteamID64 of the user to invite.
+     */
+    InviteToWatch(steamId64: string): Promise<EResult>;
+
+    /**
+     * Registers a callback to be called when the broadcast status changes.
+     * @param callback The callback function to be called.
+     * @returns an object that can be used to unregister the callback.
+     */
+    RegisterForBroadcastStatus(callback: (status: BroadcastStatus) => void): Unregisterable;
+
+    /**
+     * Registers a callback to be called when viewer requests are received.
+     * @param callback The callback function to be called.
+     * @returns an object that can be used to unregister the callback.
+     */
+    RegisterForViewerRequests(
+        callback: (viewerFriendCode: number, param1: number, param2: number) => void,
+    ): Unregisterable;
+
+    /**
+     * Rejects a viewer request for the broadcast.
+     * @param steamId64 The SteamID64 of the user whose request is to be rejected.
+     */
+    RejectViewerRequest(steamId64: string, param1: number): void;
+
+    /**
+     * Stops the broadcast.
+     */
+    StopBroadcasting(): void;
+}
+
+export interface BroadcastStatus {
+    broadcastid: string;
+    nViewers: number;
+    nRequests: number;
+    bIsBroadcasting: boolean;
+    bIsRecordingDesktop: boolean;
+    eBroadcastReady: EResult;
+    bBroadcastCapable: boolean;
+    bMicrophoneEnabled: boolean;
+    bMicrophoneActive: boolean;
+    nCurrentFPS: number;
+    nUploadKbps: number;
+}

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

@@ -0,0 +1,91 @@
+import { Unregisterable } from "./shared";
+
+export interface Browser {
+    AddWordToDictionary(word: string): void;
+
+    ClearAllBrowsingData(): void;
+
+    ClearHistory(): void;
+
+    CloseDevTools(): void;
+
+    GetBrowserID(): Promise<number>;
+
+    GetSpellingSuggestions(word: string): string[];
+
+    GetSteamBrowserID(): Promise<number>; // 16-bit unsigned integer?
+
+    /**
+     * Hides the mouse cursor until input.
+     */
+    HideCursorUntilMouseEvent(): void;
+
+    /**
+     * yup that's right, clientY and clientX are reversed
+     */
+    InspectElement(clientY: number, clientX: number): void;
+
+    NotifyUserActivation(): void;
+
+    OpenDevTools(): void;
+
+    /**
+     * Pastes the clipboard contents.
+     */
+    Paste(): void;
+
+    /**
+     * @note Not available on a created BrowserView.
+     * @todo unconfirmed
+     */
+    RegisterForGestureEvents(callback: (gesture: TouchGesture) => void): Unregisterable;
+
+    /**
+     * @note Not available on a created BrowserView.
+     */
+    RegisterForOpenNewTab: Unregisterable;
+
+    ReplaceMisspelling(param0: string): void;
+
+    /**
+     * Restarts the Steam JS context.
+     */
+    RestartJSContext(): void;
+
+    SetBackgroundThrottlingDisabled(value: boolean): void;
+
+    SetPendingFilePath(path: string): Promise<boolean>;
+
+    SetShouldExitSteamOnBrowserClosed(value: boolean): Promise<void>;
+
+    SetTouchGesturesToCancel(gestures: ETouchGesture[]): void;
+
+    /**
+     * Prompts and downloads a file.
+     * @param url The URL of the file to download.
+     */
+    StartDownload(url: string): void;
+}
+
+export interface TouchGesture {
+    eTouchGesture: ETouchGesture;
+    x: number;
+    y: number;
+}
+
+export enum ETouchGesture {
+    None,
+    Touch,
+    Tap,
+    DoubleTap,
+    ShortPress,
+    LongPress,
+    LongTap,
+    TwoFingerTap,
+    TapCancelled,
+    PinchBegin,
+    PinchUpdate,
+    PinchEnd,
+    FlingStart,
+    FlingCancelled,
+}

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

@@ -0,0 +1,39 @@
+import { BrowserContext } from "./shared";
+
+export interface ClientNotifications {
+    /**
+     * Displays a Steam notification.
+     * @param notification Notification type.
+     * @param options Stringified object of {@link SteamNotificationOptions}.
+     * @param callback
+     */
+    DisplayClientNotification(
+        notification: EClientUINotificationType,
+        options: string,
+        callback: (context: BrowserContext) => void,
+    ): void;
+
+    /**
+     * @param notificationId The ID of the notification to handle.
+     * @param handleAction `true` to execute the callback function associated with the notification.
+     */
+    OnRespondToClientNotification(notificationId: number, handleAction: boolean): void;
+}
+
+export interface SteamNotificationOptions {
+    body: string;
+    chatroomgroupid?: number;
+    chatroomid?: number;
+    icon?: string;
+    state: string;
+    /** A Steam64 ID. */
+    steamid: string;
+    tag?: string;
+    title?: string;
+}
+
+export enum EClientUINotificationType {
+    GroupChatMessage = 1,
+    FriendChatMessage,
+    FriendPersonaState,
+}

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

@@ -0,0 +1,14 @@
+export interface Cloud {
+    /**
+     * Resolves a synchronization conflict for an app in the cloud.
+     * @param appId The ID of the app with the sync conflict.
+     * @param keepLocal Whether to keep the local version during conflict resolution.
+     */
+    ResolveAppSyncConflict(appId: number, keepLocal: boolean): void;
+
+    /**
+     * Retries syncing an app with the cloud.
+     * @param appId The ID of the app to retry syncing.
+     */
+    RetryAppSync(appId: number): void;
+}

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

@@ -0,0 +1,24 @@
+export interface CommunityItems {
+    /*
+    DownloadMovie(e) {
+            return (0, o.mG)(this, void 0, void 0, (function* () {
+                if (0 != e.movie_webm_local_path.length) return !0;
+                let t = yield SteamClient.CommunityItems.DownloadItemAsset(e.communityitemid, w, e.movie_webm),
+                    n = 1 == t.result;
+                if (n) {
+                    e.movie_webm_local_path = t.path;
+                    let n = [];
+                    this.m_startupMovies.forEach((t => {
+                        t.movie_webm == e.movie_webm ? n.push(e) : n.push(t)
+                    })), this.m_startupMovies = n
+                }
+                return n
+            }))
+        }
+     */
+    DownloadItemAsset(communityItemId: string, param1: any, param2: string): any;
+
+    GetItemAssetPath(communityItemId: string, param1: any, param2: string): any;
+
+    RemoveDownloadedItemAsset(communityItemId: string, param1: any, param2: string): any;
+}

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

@@ -0,0 +1,43 @@
+import { Unregisterable } from "./shared";
+
+/**
+ * Represents the console functionality for executing commands and handling spew output.
+ */
+export interface Console {
+    /**
+     * Executes a console command.
+     * @param command The command to execute in the console.
+     */
+    ExecCommand(command: string): void;
+
+    /**
+     * Retrieves autocomplete suggestions for a given console command.
+     * @param command The console command to provide autocomplete suggestions for.
+     * @returns an array of autocomplete suggestions.
+     */
+    GetAutocompleteSuggestions(command: string): Promise<string[]>;
+
+    /**
+     * Registers a callback function to receive spew output.
+     * @param callback The callback function that will receive spew output.
+     * @returns an object that can be used to unregister the callback.
+     */
+    RegisterForSpewOutput(callback: (output: SpewOutput) => void): Unregisterable;
+}
+
+export type SpewType_t = "assert" | "error" | "warning" | "info" | "input";
+
+/**
+ * Represents spew output information.
+ */
+export interface SpewOutput {
+    /**
+     * The content of the spew output.
+     */
+    spew: string;
+
+    /**
+     * The type or category of the spew output.
+     */
+    spew_type: SpewType_t;
+}

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

@@ -0,0 +1,12 @@
+export interface Customization {
+    GenerateLocalStartupMoviesThumbnails(param0: number): Promise<number>;
+
+    //param0: "startupmovies"
+    GetDownloadedStartupMovies(param0: string): Promise<StartupMovie[]>;
+
+    GetLocalStartupMovies(): Promise<StartupMovie[]>;
+}
+
+export interface StartupMovie {
+    strMovieURL: string;
+}

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

@@ -0,0 +1,175 @@
+import { Unregisterable } from "./shared";
+import {EAppUpdateError} from "./App";
+
+/**
+ * Represents functions related to managing downloads in Steam.
+ */
+export interface Downloads {
+    /**
+     * Enables or disables all downloads in Steam.
+     * @param enable True to enable downloads, false to disable.
+     */
+    EnableAllDownloads(enable: boolean): void;
+
+    /**
+     * Moves the update for a specific app down the download queue.
+     * @param appId The ID of the application to move.
+     */
+    MoveAppUpdateDown(appId: number): void;
+
+    /**
+     * Moves the update for a specific app up the download queue.
+     * @param appId The ID of the application to move.
+     */
+    MoveAppUpdateUp(appId: number): void;
+
+    PauseAppUpdate(appId: number): void; // Broken? It seems to be removing it from download list like RemoveFromDownloadList
+
+    /**
+     * Adds the update for a specific app to the download queue.
+     * @param appId The ID of the application to queue.
+     */
+    QueueAppUpdate(appId: number): void;
+
+    /**
+     * Registers a callback function to be called when download items change.
+     * @param callback The callback function to be called.
+     * @returns an object that can be used to unregister the callback.
+     */
+    RegisterForDownloadItems(
+        callback: (isDownloading: boolean, downloadItems: DownloadItem[]) => void,
+    ): Unregisterable;
+
+    /**
+     * Registers a callback function to be called when download overview changes.
+     * @param callback The callback function to be called.
+     * @returns an object that can be used to unregister the callback.
+     */
+    RegisterForDownloadOverview(callback: (overview: DownloadOverview) => void): Unregisterable;
+
+    /**
+     * Removes the update for a specific app from the download list and places it in the unscheduled list.
+     * @param appId The ID of the application to remove.
+     */
+    RemoveFromDownloadList(appId: number): void;
+
+    /**
+     * Resumes the update for a specific app in the queue.
+     * @param appId The ID of the application to resume.
+     */
+    ResumeAppUpdate(appId: number): void;
+
+    /**
+     * Sets an app to launch when its download is complete.
+     * @param appId The ID of the application to set.
+     */
+    SetLaunchOnUpdateComplete(appId: number): void;
+
+    /**
+     * Sets the queue index for an app in the download queue.
+     * @param appId The ID of the application to set the index for.
+     * @param index The index to set.
+     * @remarks Index of 0 is the current download in progress.
+     */
+    SetQueueIndex(appId: number, index: number): void;
+
+    /**
+     * Suspends or resumes download throttling.
+     * @param suspend Whether to suspend or resume download throttling.
+     */
+    SuspendDownloadThrottling(suspend: boolean): void;
+
+    /**
+     * Suspends or resumes local transfers.
+     * @param suspend Whether to suspend or resume local transfers.
+     */
+    SuspendLanPeerContent(suspend: boolean): void;
+}
+
+export interface DownloadItem {
+    /** True if this app is currently downloading */
+    active: boolean;
+    /** Appid of app */
+    appid: number;
+    /** Current build ID for the installed app, zero if the app isn't installed yet */
+    buildid: number;
+    /** True if this update has been completed */
+    completed: boolean;
+    /** For completed downloads, time of completion, 0 if not completed */
+    completed_time: number;
+    deferred_time: number;
+    /** Bytes already downloaded, sum across all content types */
+    downloaded_bytes: number;
+    /** If true, game will launch when its download completes successfully */
+    launch_on_completion: boolean;
+    /** True if this app has been paused by the user or the system */
+    paused: boolean;
+    /** Queue index, -1 if the item is unqueued */
+    queue_index: number;
+    /** Build ID that this download is moving towards. This can be the same as buildid.*/
+    target_buildid: number;
+    /** Total bytes to download, sum across all content types */
+    total_bytes: number;
+    /**
+     * Update error description, when paused and there has been an error.
+     * Unlocalized and shouldn't be displayed to the user.
+     */
+    update_error: string;
+    update_result: EAppUpdateError;
+    update_type_info: UpdateTypeInfo[];
+}
+
+export interface DownloadOverview {
+    /** Set if we are downloading from LAN peer content server */
+    lan_peer_hostname: string;
+    /** True if all downloads are paused */
+    paused: boolean;
+    /** True if download throttling has been temporarily suspended for the current download */
+    throttling_suspended: boolean;
+    /** Appid of currently updating app */
+    update_appid: number;
+    /** Bytes already downloaded */
+    update_bytes_downloaded: number;
+    /** Bytes already processed in current phase - resets to zero when update stage changes */
+    update_bytes_processed: number;
+    /** Bytes already staged */
+    update_bytes_staged: number;
+    /** Total bytes to download */
+    update_bytes_to_download: number;
+    /** Total bytes to process in current phase - resets to zero when update stage changes */
+    update_bytes_to_process: number;
+    /** Total bytes to be staged */
+    update_bytes_to_stage: number;
+    /** Current disk throughput estimate */
+    update_disc_bytes_per_second: number;
+    /** True if the current update is an initial install */
+    update_is_install: boolean;
+    /** True if download and staging sizes are prefetch estimates */
+    update_is_prefetch_estimate: boolean;
+    /** True if the current update is for shader update */
+    update_is_shader: boolean;
+    /** True if the client is running in peer content server mode serving other peers */
+    update_is_upload: boolean;
+    /** True if the current update is for workshop content */
+    update_is_workshop: boolean;
+    /** Current bandwidth estimate for download */
+    update_network_bytes_per_second: number;
+    /** Peak bandwidth estimate for download */
+    update_peak_network_bytes_per_second: number;
+    /** Estimate of remaining time (in seconds) until download completes (not including staging) */
+    update_seconds_remaining: number;
+    /** Time current update started */
+    update_start_time: number;
+    update_state: 'None' | 'Starting' | 'Updating' | 'Stopping';
+}
+
+export interface UpdateTypeInfo {
+    /** True if this content type had an update and it has completed */
+    completed_update: boolean;
+    /** Bytes already downloaded for this content type */
+    downloaded_bytes: number;
+    /** True if this content type has or had an update */
+    has_update: boolean;
+    /** Total bytes to download for this content type */
+    total_bytes: number;
+}

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

@@ -0,0 +1,30 @@
+import { EResult, Unregisterable } from "./shared";
+
+/**
+ * Represents functions related to Steam Family Sharing.
+ */
+export interface FamilySharing {
+    GetAvailableLenders(appId: number): Promise<Lender[]>;
+
+    RegisterForKickedBorrower: Unregisterable;
+
+    SetPreferredLender(appId: number, param1: number): Promise<EResult>;
+}
+
+interface LenderDLC {
+    rtStoreAssetModifyTime: number;
+    strHeaderFilename: string;
+    strName: string;
+    unAppID: number;
+}
+
+export interface Lender {
+    /**
+     * A Steam64 ID.
+     */
+    steamid: string;
+    appid: number;
+    numDlc: number;
+    bPreferred: boolean;
+    vecDLC: LenderDLC[];
+}

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

@@ -0,0 +1,80 @@
+import { VDFBoolean_t } from "./shared";
+
+/**
+ * Represents friend settings and configuration.
+ */
+export interface FriendSettings {
+    /**
+     * Retrieves a list of enabled friend settings features.
+     * @returns an array of enabled friend settings features.
+     */
+    GetEnabledFeatures(): Promise<FriendSettingsFeatureObject[]>;
+
+    /**
+     * Registers a callback function to be notified of friend settings changes.
+     * @param callback The callback function to be called when friend settings change.
+     * @remarks The callback receives a JSON object string which may be parsed into {@link FriendSettingsChange}.
+     */
+    RegisterForSettingsChanges(callback: (settings: string) => void): void;
+
+    /**
+     * @param details Stringified {@link FriendSettingsChange}.
+     */
+    SetFriendSettings(details: string): void;
+}
+
+export enum EChatFlashMode {
+    Always,
+    Minimized,
+    Never,
+}
+
+export interface FriendSettingsFeatureObject {
+    feature: FriendSettingsFeature_t;
+    bEnabled: boolean;
+}
+
+export type FriendSettingsFeature_t =
+    | "DoNotDisturb"
+    | "FriendsFilter"
+    | "LoaderWindowSynchronization"
+    | "NewVoiceHotKeyState"
+    | "NonFriendMessageHandling"
+    | "PersonaNotifications"
+    | "ServerVirtualizedMemberLists"
+    | "SteamworksChatAPI";
+
+export type FriendSettingsEnabledFeatures<T> = {
+    [feature in FriendSettingsFeature_t]: T;
+};
+
+export interface FriendSettingsChange {
+    bNotifications_ShowIngame: VDFBoolean_t;
+    bNotifications_ShowOnline: VDFBoolean_t;
+    bNotifications_ShowMessage: VDFBoolean_t;
+    bNotifications_EventsAndAnnouncements: VDFBoolean_t;
+    bSounds_PlayIngame: VDFBoolean_t;
+    bSounds_PlayOnline: VDFBoolean_t;
+    bSounds_PlayMessage: VDFBoolean_t;
+    bSounds_EventsAndAnnouncements: VDFBoolean_t;
+    bAlwaysNewChatWindow: VDFBoolean_t;
+    bForceAlphabeticFriendSorting: VDFBoolean_t;
+    nChatFlashMode: EChatFlashMode;
+    bRememberOpenChats: VDFBoolean_t;
+    bCompactQuickAccess: VDFBoolean_t;
+    bCompactFriendsList: VDFBoolean_t;
+    bNotifications_ShowChatRoomNotification: VDFBoolean_t;
+    bSounds_PlayChatRoomNotification: VDFBoolean_t;
+    bHideOfflineFriendsInTagGroups: VDFBoolean_t;
+    bHideCategorizedFriends: VDFBoolean_t;
+    bCategorizeInGameFriendsByGame: VDFBoolean_t;
+    nChatFontSize: number;
+    b24HourClock: VDFBoolean_t;
+    bDoNotDisturbMode: VDFBoolean_t;
+    bDisableEmbedInlining: VDFBoolean_t;
+    bSignIntoFriends: VDFBoolean_t;
+    bDisableSpellcheck: VDFBoolean_t;
+    bDisableRoomEffects: VDFBoolean_t;
+    bAnimatedAvatars: VDFBoolean_t;
+    featuresEnabled: FriendSettingsEnabledFeatures<VDFBoolean_t>;
+}