import type { EResult, JsPbMessage, OperationResponse, Unregisterable, VDFBoolean_t } from './shared';
import type { EControllerRumbleSetting, EThirdPartyControllerConfiguration } from './Input';
import { EUCMFilePrivacyState, Screenshot } from './Screenshots';

/**
 * Represents various functions related to Steam applications.
 */
export interface Apps {
	/**
	 * Adds a non-Steam application shortcut to the local Steam library.
	 * @param appName The name of the non-Steam application.
	 * @param executablePath The path to the executable file of the non-Steam application.
	 * @param directory The working directory for the non-Steam application.
	 * @param launchOptions Options to be passed when launching the non-Steam application.
	 * @returns a unique AppID assigned to the added non-Steam application shortcut.
	 */
	AddShortcut(appName: string, executablePath: string, directory: string, launchOptions: string): Promise<number>;

	/**
	 * Backups an app to the specified path.
	 * @param appId The ID of the application to back up.
	 * @param backupPath The path to store the backup.
	 * @returns a number. This value may be "20" for backup busy and "0" for success.
	 */
	BackupFilesForApp(appId: number, backupPath: string): Promise<number>;

	/**
	 * Opens the screenshot folder for a specific app.
	 * @param appId The ID of the app to browse screenshots for.
	 * @param handle The screenshot handle to use.
	 */
	BrowseScreenshotForApp(appId: string, handle: number): void;

	/**
	 * Opens the screenshot folder for a specific app.
	 * @param appId The ID of the app to browse screenshots for.
	 */
	BrowseScreenshotsForApp(appId: string): void;

	/**
	 * Cancels the current backup process.
	 */
	CancelBackup(): void;

	/**
	 * Cancels a specific game action.
	 * @param gameActionId The ID of the game action to cancel.
	 */
	CancelGameAction(gameActionId: number): void;

	/**
	 * Cancels the launch of an application with the specified ID.
	 * @param appId The ID of the application whose launch is to be canceled.
	 */
	CancelLaunch(appId: string): void;

	/**
	 * Clears the custom artwork for a given application.
	 * @param appId The ID of the application to clear custom artwork for.
	 * @param assetType The type of artwork to clear.
	 */
	ClearCustomArtworkForApp(appId: number, assetType: ELibraryAssetType): Promise<void>;

	/**
	 * Clears the custom logo position for a specific application.
	 * @param appId The ID of the application.
	 * @returns A Promise that resolves once the custom logo position is cleared.
	 */
	ClearCustomLogoPositionForApp(appId: number): Promise<void>;

	ClearProton(appId: number): Promise<void>;

	/**
	 * Continues a specific game action.
	 * @param gameActionId The ID of the game action to continue.
	 * @param actionType The type of action to perform during continuation.
	 * @remarks actionType - "SkipShaders", "skip", "ShowDurationControl" todo:
	 */
	ContinueGameAction(gameActionId: number, actionType: string): void;

	/**
	 * Creates a Steam application shortcut on the desktop.
	 * @param appId The ID of the application for which to create a desktop shortcut.
	 */
	CreateDesktopShortcutForApp(appId: number): void;

	/**
	 * Download a workshop item.
	 * @param appId The ID of the application.
	 * @param itemId The ID of the workshop item.
	 */
	DownloadWorkshopItem(appId: number, itemId: string, param1: boolean): void;

	/**
	 * Retrieves achievements within a specified time range for a given app.
	 * @param appId The ID of the application.
	 * @param start The start of the time range as a Unix timestamp.
	 * @param end The end of the time range as a Unix timestamp.
	 * @returns an array of AppAchievement objects.
	 * @throws OperationResponse
	 */
	GetAchievementsInTimeRange(appId: number, start: number, end: number): Promise<AppAchievement[]>;

	/**
	 * Retrieves a list of active game actions, such as launching an application.
	 * @returns an array of active game actions.
	 */
	GetActiveGameActions(): Promise<GameAction[]>;

	/**
	 * Retrieves a list of available compatibility tools for a specific application.
	 * @param appId The ID of the application to retrieve compatibility tools for.
	 * @returns an array of CompatibilityToolInfo objects.
	 */
	GetAvailableCompatTools(appId: number): Promise<CompatibilityTool[]>;

	/**
	 * Represents a function to retrieve the name of the application in a backup folder.
	 * @param appBackupPath The path to the application's backup folder.
	 * @returns the name of the application in the backup folder, or undefined if the path is invalid.
	 * @remarks This function checks for the "sku.sis" file in that path.
	 */
	GetBackupsInFolder(appBackupPath: string): Promise<string | undefined>;

	/**
	 * Retrieves cached details for a specific application.
	 * @param appId The ID of the application.
	 * @returns a stringified object. Returns {@link CachedAppDetails} when parsed.
	 */
	GetCachedAppDetails(appId: number): Promise<string>;

	/**
	 * @returns a ProtoBuf message. If deserialized, returns {@link CMsgCloudPendingRemoteOperations}.
	 */
	GetCloudPendingRemoteOperations(appId: number): Promise<{
		PendingOperations: ArrayBuffer;
	}>;

	GetCompatExperiment(param0: number): Promise<string>;

	GetConflictingFileTimestamps(appId: number): Promise<ConflictingFileTimestamp>;

	/**
	 * Retrieves details for a specific screenshot upload.
	 * @param appId The ID of the application.
	 * @param hHandle The handle of the screenshot upload.
	 * @returns details about the screenshot upload.
	 */
	GetDetailsForScreenshotUpload(appId: string, hHandle: number): Promise<ScreenshotUploadDetails>;

	/**
	 * Retrieves details for multiple screenshot uploads.
	 * @param appId The ID of the application.
	 * @param hHandles An array of handles of the screenshot uploads.
	 * @returns details about the screenshot uploads.
	 */
	GetDetailsForScreenshotUploads(appId: string, hHandles: number[]): Promise<ScreenshotUploadsDetails>;

	/**
	 * Retrieves a list of downloaded workshop items for a specific application.
	 * @param appId The ID of the application to retrieve downloaded workshop items for.
	 * @returns an array of downloaded workshop items for the specified application.
	 */
	GetDownloadedWorkshopItems(appId: number): Promise<WorkshopItem[]>;

	GetDurationControlInfo(appId: number): Promise<{ bApplicable: boolean }>;

	/**
	 * Retrieves achievement information for a specific application for a given friend.
	 * @param appId The ID of the application to retrieve achievement information for.
	 * @param friendSteam64Id The Steam64 ID of the friend for whom to retrieve achievement information.
	 * @returns an object containing achievement information for the specified friend and application.
	 */
	GetFriendAchievementsForApp(appId: string, friendSteam64Id: string): Promise<AppAchievementResponse>;

	/**
	 * Retrieves a list of friends who play the specified application.
	 * @param appId The ID of the application.
	 * @returns an array of Steam64 IDs representing friends who play the application.
	 */
	GetFriendsWhoPlay(appId: number): Promise<string[]>;

	/**
	 * Retrieves details of a game action.
	 * @param appId The ID of the application.
	 * @param callback The callback function to handle the retrieved game action details and state.
	 * @param callback.gameAction The game action received in the callback.
	 * @param callback.state The state manager received in the callback.
	 */
	GetGameActionDetails(appId: number, callback: (gameAction: GameAction) => void): void;

	GetGameActionForApp(appId: string, callback: (gameActionId: number, appId: 0 | string, taskName: AppAction_t) => void): void;

	/**
	 * Retrieves launch options for a specified application.
	 * These options may include different configurations or settings for launching the application, such as DirectX, Vulkan, OpenGL, 32-bit, 64-bit, etc.
	 * This function does not retrieve launch/argument options inputted by the user.
	 * @param appId The ID of the application.
	 * @returns an array of launch options for the specified application.
	 */
	GetLaunchOptionsForApp(appId: number): Promise<LaunchOption[]>;

	/**
	 * @returns a ProtoBuf message. If deserialized, returns {@link CLibraryBootstrapData}.
	 */
	GetLibraryBootstrapData(): Promise<ArrayBuffer>;

	/**
	 * Retrieves achievement information for the authenticated user in a specific Steam application.
	 * @param appId The ID of the application to retrieve achievement information for.
	 * @returns an AppAchievementResponse object containing the achievement information for the authenticated user in the specified application.
	 */
	GetMyAchievementsForApp(appId: string): Promise<AppAchievementResponse>;

	/**
	 * Retrieves the playtime information for a specific application.
	 * @param appId The ID of the application to get playtime information for.
	 * @returns playtime information or undefined if not available.
	 */
	GetPlaytime(appId: number): Promise<Playtime | undefined>;

	GetPrePurchasedApps(appIds: number[]): Promise<PrePurchaseInfo>;

	/**
	 * Retrieves the resolution override for a specific application.
	 * @param appId The ID of the application to retrieve the resolution override for.
	 * @returns a string of the resolution override.
	 */
	GetResolutionOverrideForApp(appId: number): Promise<string>;

	/**
	 * Represents a function to retrieve detailed information about a specific screenshot.
	 * @param appId The ID of the application the screenshot belongs to.
	 * @param hHandle The handle of the screenshot.
	 * @returns detailed information about the specified screenshot.
	 */
	GetScreenshotInfo(appId: string, hHandle: number): Promise<Screenshot>;

	/**
	 * Represents a function to retrieve screenshots within a specified time range.
	 * @param appId The ID of the application.
	 * @param start The start of the time range as a Unix timestamp.
	 * @param end The end of the time range as a Unix timestamp.
	 * @returns an array of screenshots taken within the specified time range.
	 */
	GetScreenshotsInTimeRange(appId: number, start: number, end: number): Promise<Screenshot[]>;

	/**
	 * Retrieves shortcut data for a given shortcut file path.
	 * @param pathToShortcut The path to the shortcut file.
	 * @returns the shortcut data.
	 */
	GetShortcutDataForPath(pathToShortcut: string): Promise<Shortcut>;

	/**
	 * Represents a function to retrieve details about a soundtrack associated with a soundtrack application.
	 * The soundtrack has to be installed.
	 * @param appId The ID of the soundtrack application.
	 * @returns the details of the soundtrack associated with the specified soundtrack application.
	 */
	GetSoundtrackDetails(appId: number): Promise<SoundtrackDetails>;

	// [...appStore.m_mapStoreTagLocalization.keys()]
	GetStoreTagLocalization(tags: number[]): Promise<StoreTagLocalization[]>;

	/**
	 * Retrieves a list of subscribed workshop item details for a specific application.
	 * @param appId The ID of the application to retrieve subscribed workshop item details for.
	 * @param itemIds Workshop item IDs to retrieve details for.
	 * @returns an array of subscribed workshop item details for the specified application.
	 * @throws Throws if the query failed.
	 */
	GetSubscribedWorkshopItemDetails(appId: number, itemIds: string[]): Promise<WorkshopItem[] | OperationResponse>;

	/**
	 * Retrieves a list of subscribed workshop items for a specific application.
	 * @param appId The ID of the application to retrieve subscribed workshop items for.
	 * @returns an array of subscribed workshop items for the specified application.
	 */
	GetSubscribedWorkshopItems(appId: number): Promise<WorkshopItem[]>;

	InstallFlatpakAppAndCreateShortcut(
		appName: string,
		appCommandLineOptions: string,
	): Promise<{
		appid: number;
		strInstallOutput: string;
	}>;

	/**
	 * Join an app beta.
	 * @param appId App ID of the beta to join.
	 * @param name Beta name. Empty to opt out of betas.
	 * @throws EResult if no beta found.
	 */
	JoinAppContentBeta(appId: number, name: string): Promise<EResult>;

	/**
	 * Join an app beta by password.
	 * @throws EResult if no beta found.
	 */
	JoinAppContentBetaByPassword(appId: number, accessCode: string): Promise<any>; // any.strName

	ListFlatpakApps(): Promise<any>;

	/**
	 * @throws if the user does not own the app or no EULA.
	 */
	LoadEula(appId: number): Promise<EndUserLicenseAgreement[]>; // Doesn't bring up the EULA dialog, just returns the eula data
	MarkEulaAccepted(appId: number, id: string, version: number): void;

	MarkEulaRejected(appId: number, id: string, version: number): void;

	/**
	 * Move specified workshop item load order.
	 * @param appId The ID of the application.
	 * @param oldOrder The item to move, referenced by its position number.
	 * @param newOrder The position number to move the item to.
	 * @remarks Orders are zero-indexed.
	 */
	MoveWorkshopItemLoadOrder(appId: number, oldOrder: number, newOrder: number): void;

	/**
	 * Opens the settings dialog for a specific application.
	 * @param appId The ID of the application for which to open the settings dialog.
	 * @param section The section (tab) to switch to.
	 */
	OpenAppSettingsDialog(appId: number, section: string): void;

	/**
	 * Raises the window for a given application.
	 * @param appId The ID of the application to raise the window of.
	 */
	RaiseWindowForGame(appId: number): Promise<ERaiseGameWindowResult>; // ResumeGameInProgress

	/*
    "CMsgAchievementChange"
        OnAchievementChange(e) {
            var t;
            const n = l.on.deserializeBinary(e).toObject(),
                o = null !== (t = null == n ? void 0 : n.appid) && void 0 !== t ? t : 0;
            0 != o ? (this.m_mapMyAchievements.has(o) || this.m_mapInflightMyAchievementsRequests.has(o)) && this.LoadMyAchievements(o) : console.error("Received invalid appid in OnAchievementChange")
        }

        message CMsgAchievementChange {
            optional uint32 appid = 1;
        }
     */
	/**
	 * Registers a callback function to be called when achievement changes occur.
	 * @param callback The callback function to be called.
	 * @returns an object that can be used to unregister the callback.
	 */
	RegisterForAchievementChanges(callback: (data: ArrayBuffer) => void): Unregisterable;

	RegisterForAppBackupStatus(callback: (status: AppBackupStatus) => void): Unregisterable;

	/**
	 * Registers a callback function to be called when app details change.
	 * @param appId The ID of the application to monitor.
	 * @param callback The callback function to be called.
	 * @returns an object that can be used to unregister the callback.
	 */
	RegisterForAppDetails(appId: number, callback: (data: AppDetails) => void): Unregisterable;

	/**
	 * If `data` is deserialized, returns {@link CAppOverview_Change}.
	 * @remarks This is not a mistake, it doesn't return anything.
	 */
	RegisterForAppOverviewChanges(callback: (data: ArrayBuffer) => void): void;

	RegisterForDRMFailureResponse(callback: (appid: number, eResult: EResult, errorCode: number) => void): Unregisterable;

	/**
	 * Registers a callback function to be called when a game action ends.
	 * @param callback The callback function to be called.
	 * @returns an object that can be used to unregister the callback.
	 */
	RegisterForGameActionEnd(callback: (gameActionId: number) => void): Unregisterable;

	RegisterForGameActionShowError(
		callback: (
			gameActionId: number,
			appId: string,
			actionName: string,
			/**
			 * Localization token.
			 */
			error: string,
			param4: string,
		) => void,
	): Unregisterable;

	/**
	 * Registers a callback function to be called when a game action UI is shown.
	 * @param callback The callback function to be called.
	 * @returns an object that can be used to unregister the callback.
	 */
	RegisterForGameActionShowUI(callback: () => void): Unregisterable; // todo: no idea what this callback is from

	/**
	 * Registers a callback function to be called when a game action starts.
	 * @param callback The callback function to be called.
	 * @returns an object that can be used to unregister the callback.
	 */
	RegisterForGameActionStart(callback: (gameActionId: number, appId: string, action: string, param3: ELaunchSource) => void): Unregisterable;

	/**
	 * Registers a callback function to be called when a game action task changes.
	 * @param callback The callback function to be called.
	 * @returns an object that can be used to unregister the callback.
	 */
	RegisterForGameActionTaskChange(callback: (gameActionId: number, appId: string, action: string, requestedAction: string, param4: string) => void): Unregisterable;

	/**
	 * Registers a callback function to be called when a user requests a game action.
	 * @param callback The callback function to be called.
	 * @returns an object that can be used to unregister the callback.
	 */
	RegisterForGameActionUserRequest(callback: (gameActionId: number, appId: string, action: string, requestedAction: string, appId2: string) => void): Unregisterable;

	RegisterForPrePurchasedAppChanges(callback: () => void): Unregisterable; // Unknown, did have it show up a few times, but not callback parameters
	RegisterForShowMarketingMessageDialog: Unregisterable;

	/**
	 * Registers a callback function to be notified when workshop items are added or removed from a Steam application.
	 * @param callback The callback function to be called.
	 * @returns an object that can be used to unregister the callback.
	 */
	RegisterForWorkshopChanges(callback: (appId: number) => void): Unregisterable;

	RegisterForWorkshopItemDownloads(appId: number, callback: (appId: number, publishedFileId: string, param2: number) => void): Unregisterable;

	RegisterForWorkshopItemInstalled(callback: (item: InstalledWorkshopItem) => void): Unregisterable;

	/**
	 * Removes a non-Steam application shortcut from the Steam library.
	 * @param appId The ID of the application for which to remove the shortcut.
	 */
	RemoveShortcut(appId: number): void;

	ReportLibraryAssetCacheMiss(appId: number, assetType: ELibraryAssetType): void;

	ReportMarketingMessageDialogShown(): void;

	RequestIconDataForApp(appId: number): void;

	RequestLegacyCDKeysForApp(appId: number): void;

	/**
	 * Runs a game with specified parameters. Focuses the game if already launched.
	 * @param appId The ID of the application to run.
	 * @param launchOptions Additional launch options for the application.
	 * @param param2 Additional parameter (exact usage may vary).
	 * @param launchSource
	 * @remarks `launchOptions` is appended before the ones specified in the application's settings.
	 */
	RunGame(appId: string, launchOptions: string, param2: number, launchSource: ELaunchSource): void;

	/*
      function u(e, t) {
        return t instanceof Map || t instanceof Set ? Array.from(t) : t;
      }
      SteamClient.Apps.SaveAchievementProgressCache(
        JSON.stringify(this.m_achievementProgress, u)
      );
    */
	SaveAchievementProgressCache(progress: string): Promise<void>;

	/**
	 * Scans the system for installed non-Steam applications.
	 * @returns an array of NonSteamApp objects representing installed non-Steam applications.
	 * @remarks This function scans the user's system for installed applications that are not part of the Steam library. It does not scan for shortcuts added to the Steam library.
	 *
	 * On Linux, it scans inside /usr/share/applications and $XDG_DATA_HOME/applications.
	 */
	ScanForInstalledNonSteamApps(): Promise<NonSteamApp[]>;

	/**
	 * Sets the automatic update behavior for a Steam application.
	 * @param appId The ID of the application to set the update behavior for.
	 * @param mode The update behavior mode to set.
	 * @remarks This function only works with installed Steam applications.
	 */
	SetAppAutoUpdateBehavior(appId: number, mode: EAppAutoUpdateBehavior): void;

	/**
	 * Sets the background downloads behavior for a specific Steam application.
	 * @param appId The ID of the application to set the background downloads behavior for.
	 * @param mode The background downloads mode to set.
	 * @remarks This function only works with installed Steam applications.
	 */
	SetAppBackgroundDownloadsBehavior(appId: number, mode: EAppAllowDownloadsWhileRunningBehavior): void;

	/**
	 * Sets the current language for a specific Steam application.
	 * @param appId The ID of the application to set the current language for.
	 * @param language The language to set, represented as a language (e.g., "english", "spanish", "tchinese", "schinese").
	 */
	SetAppCurrentLanguage(appId: number, language: string): void;

	/**
	 * Sets the blocked state for apps.
	 * @param appIds An array of app IDs to set the blocked state for.
	 * @param state The state to set (true for blocked, false for unblocked).
	 */
	SetAppFamilyBlockedState(appIds: number[], state: boolean): void;

	/**
	 * Sets launch options for a Steam application.
	 * @param appId The ID of the application to set launch options for.
	 * @param launchOptions The launch options to be set for the application.
	 */
	SetAppLaunchOptions(appId: number, launchOptions: string): void;

	/**
	 * Sets a resolution override for a Steam application.
	 * @param appId The ID of the application to set the resolution override for.
	 * @param resolution The resolution to be set for the application. It can be "Default", "Native", or other compatible resolutions for the user's monitor.
	 */
	SetAppResolutionOverride(appId: number, resolution: string): void;

	/**
	 * Sets cached details for a specific application.
	 * @param appId The ID of the application.
	 * @param details The details to be cached, a stringified object.
	 * @returns A Promise that resolves when the details are successfully cached.
	 */
	SetCachedAppDetails(appId: number, details: string): Promise<void>;

	SetControllerRumblePreference(appId: number, value: EControllerRumbleSetting): void;

	/**
	 * Sets the custom artwork for a given application.
	 * @param appId The ID of the application to set custom artwork for.
	 * @param base64 Base64 encoded image.
	 * @param assetType The type of artwork to set.
	 * @returns A Promise that resolves after the custom artwork is set.
	 */
	SetCustomArtworkForApp(appId: number, base64: string, imageType: 'jpg' | 'png', assetType: ELibraryAssetType): Promise<void>;

	/**
	 * Sets a custom logo position for a specific app.
	 * @param appId The ID of the application.
	 * @param details The details of the custom logo position, expected to be a stringified {@link LogoPositionForApp} object.
	 * @returns A Promise that resolves when the custom logo position is successfully set.
	 */
	SetCustomLogoPositionForApp(appId: number, details: string): Promise<void>;

	/**
	 * Sets the enabled state for downloadable content (DLC) of a specific app.
	 * @param appId The ID of the parent application.
	 * @param appDLCId The ID of the DLC to set the state for.
	 * @param value The value to set (true for enabled, false for disabled).
	 */
	SetDLCEnabled(appId: number, appDLCId: number, value: boolean): void;

	/**
	 * Set a local screenshot's caption.
	 * @param appId The application ID the screenshot belongs to.
	 * @param hHandle The handle of the screenshot.
	 * @param caption
	 */
	SetLocalScreenshotCaption(appId: string, hHandle: number, caption: string): void;

	/**
	 * Set a local screenshot's privacy state.
	 * @param appId The application ID the screenshot belongs to.
	 * @param hHandle The handle of the screenshot.
	 * @param privacy Screenshot privacy state.
	 */
	SetLocalScreenshotPrivacy(appId: string, hHandle: number, privacy: EUCMFilePrivacyState): void;

	/**
	 * Set a local screenshot's spoiler state.
	 * @param appId The application ID the screenshot belongs to.
	 * @param hHandle The handle of the screenshot.
	 * @param spoilered Is the screenshot spoilered?
	 */
	SetLocalScreenshotSpoiler(appId: string, hHandle: number, spoilered: boolean): void;

	/**
	 * Sets the executable path for a non-Steam application shortcut.
	 * @param appId The ID of the application to set the shortcut executable for.
	 * @param path The path to the executable.
	 */
	SetShortcutExe(appId: number, path: string): void;

	/**
	 * Sets the icon for a non-Steam application shortcut.
	 * @param appId The ID of the application to set the shortcut icon for.
	 * @param path The path to the icon image (can be png or tga format).
	 */
	SetShortcutIcon(appId: number, path: string): void;

	/**
	 * Sets whether a non-Steam application shortcut should be included in the VR library.
	 * @param appId The ID of the application to set the VR status for.
	 * @param value A boolean indicating whether the application should be included in the VR library.
	 */
	SetShortcutIsVR(appId: number, value: boolean): void;

	/**
	 * Sets launch options for a non-Steam application shortcut.
	 * @param appId The ID of the application to set the launch options for.
	 * @param options The launch options to be used when starting the application.
	 */
	SetShortcutLaunchOptions(appId: number, options: string): void;

	/**
	 * Sets the name for a non-Steam application shortcut.
	 * @param appId The ID of the application to set the shortcut name for.
	 * @param name The name to be displayed for the application shortcut.
	 */
	SetShortcutName(appId: number, name: string): void;

	/**
	 * Sets the starting directory for a non-Steam application shortcut.
	 * @param appId The ID of the application to set the starting directory for.
	 * @param directory The directory from which the application should be launched.
	 */
	SetShortcutStartDir(appId: number, directory: string): void;

	/**
	 * Sets the client ID for streaming for a specific application.
	 * @param appId The ID of the application.
	 * @param clientId The client ID for streaming.
	 */
	SetStreamingClientForApp(appId: number, clientId: string): void;

	SetThirdPartyControllerConfiguration(appId: number, value: EThirdPartyControllerConfiguration): void;

	/**
	 * Sets the workshop items disabled state.
	 * @param appId The ID of the application.
	 * @param itemIds Workshop item IDs to change the state for.
	 * @param value `true` to disable, `false` otherwise.
	 */
	SetWorkshopItemsDisabledLocally(appId: number, itemIds: string[], value: boolean): void;

	/**
	 * Sets the workshop items load order for a specified application.
	 * @param appId The ID of the application.
	 * @param itemIds Workshop item IDs. Has to be the full list of subscribed items, otherwise the specified items get moved to the last position.
	 */
	SetWorkshopItemsLoadOrder(appId: number, itemIds: string[]): void;

	/**
	 * Opens the controller configurator for a specific application.
	 * @param appId The ID of the application for which to open the controller configurator.
	 */
	ShowControllerConfigurator(appId: number): void;

	/**
	 * Opens the Steam store page for a specific application.
	 * @param appId The ID of the application.
	 */
	ShowStore(appId: number): void;

	SpecifyCompatExperiment(appId: number, param1: string): void;

	/**
	 * Specifies a compatibility tool by its name for a given application. If strToolName is an empty string, the specified application will no longer use a compatibility tool.
	 * @param appId The ID of the application to specify compatibility tool for.
	 * @param strToolName The name of the compatibility tool to specify.
	 */
	SpecifyCompatTool(appId: number, strToolName: string): void;

	StreamGame(appId: number, clientId: string, param2: number): void;

	/**
	 * Subscribes or unsubscribes from a workshop item for a specific app.
	 * @param appId The ID of the application.
	 * @param workshopId The ID of the workshop item.
	 * @param subscribed True to subscribe, false to unsubscribe.
	 */
	SubscribeWorkshopItem(appId: number, workshopId: string, subscribed: boolean): void;

	/**
	 * Terminates a running application.
	 * @param appId The ID of the application to terminate.
	 * @param param1 Additional parameter. Exact usage may vary.
	 */
	TerminateApp(appId: string, param1: boolean): void;

	// "#AppProperties_SteamInputDesktopConfigInLauncher"
	ToggleAllowDesktopConfiguration(appId: number): void;

	/**
	 * Toggles the Steam Cloud synchronization for game saves for a specific application.
	 * @param appId The ID of the application.
	 * @remarks This function modifies the "<STEAMPATH>/userdata/<STEAMID3>/7/remote/sharedconfig.vdf" file.
	 */
	ToggleAppSteamCloudEnabled(appId: number): void;

	// "#AppProperties_EnableSteamCloudSyncOnSuspend"
	ToggleAppSteamCloudSyncOnSuspendEnabled(appId: number): void;

	/**
	 * Toggles the Steam Overlay setting for a specific application.
	 * @param appId The ID of the application.
	 */
	ToggleEnableSteamOverlayForApp(appId: number): void;

	// "#AppProperties_ResolutionOverride_Internal"
	ToggleOverrideResolutionForInternalDisplay(appId: number): void;

	UninstallFlatpakApp(app: string): Promise<boolean>;

	/**
	 * Verifies the integrity of an app's files.
	 * @param appId The ID of the app to verify.
	 */
	VerifyApp(appId: number): Promise<{ nGameActionID: number }>;
}

export enum ELibraryAssetType {
	Capsule,
	Hero,
	Logo,
	Header,
	Icon,
	HeroBlur,
}

export interface AppAchievements {
	nAchieved: number;
	nTotal: number;
	vecAchievedHidden: AppAchievement[];
	vecHighlight: AppAchievement[];
	vecUnachieved: AppAchievement[];
}

export interface AppAchievement {
	bAchieved: boolean;
	/** Is it a hidden achievement before unlocking it? */
	bHidden: boolean;
	flMinProgress: number;
	flCurrentProgress: number;
	flMaxProgress: number;
	/** How many players have this achievement, in 0-100 range. */
	flAchieved: number;
	/** When this achievement was unlocked. */
	rtUnlocked: number;
	/** Localized achievement description. */
	strDescription: string;
	/** Achievement ID. */
	strID: string;
	/** Achievement icon. */
	strImage: string;
	/** Localized achievement name. */
	strName: string;
}

export type AppAction_t = 'LaunchApp' | 'VerifyApp';

export type LaunchAppTask_t =
	| 'None'
	| 'Completed'
	| 'Cancelled'
	| 'Failed'
	| 'Starting'
	| 'ConnectingToSteam'
	| 'RequestingLicense'
	| 'UpdatingAppInfo'
	| 'UpdatingAppTicket'
	| 'UnlockingH264'
	| 'WaitingOnWideVineUpdate'
	| 'ShowCheckSystem'
	| 'CheckTimedTrial'
	| 'GetDurationControl'
	| 'ShowDurationControl'
	| 'ShowLaunchOption'
	| 'ShowEula'
	| 'ShowVR2DWarning'
	| 'ShowVROculusOnly'
	| 'ShowVRStreamingLaunch'
	| 'ShowGameArgs'
	| 'ShowCDKey'
	| 'WaitingPrevProcess'
	| 'DownloadingDepots'
	| 'DownloadingWorkshop'
	| 'UpdatingDRM'
	| 'GettingLegacyKey'
	| 'ProcessingInstallScript'
	| 'RunningInstallScript'
	| 'SynchronizingCloud'
	| 'SynchronizingControllerConfig'
	| 'ShowNoControllerConfig'
	| 'ProcessingShaderCache'
	| 'VerifyingFiles'
	| 'KickingOtherSession'
	| 'WaitingOpenVRAppQuit'
	| 'SiteLicenseSeatCheckout'
	| 'DelayLaunch'
	| 'CreatingProcess'
	| 'WaitingGameWindow';

export interface GameAction {
	nGameActionID: number;
	gameid: string;
	strActionName: AppAction_t;
	strTaskName: LaunchAppTask_t;
	strTaskDetails: string;
	nLaunchOption: number;
	nSecondsRemaing: number; //fixme: not a typo, actually valve
	strNumDone: string;
	strNumTotal: string;
	bWaitingForUI: boolean;
}

export interface ConflictingFileTimestamp {
	rtLocalTime: number;
	rtRemoteTime: number;
}

/**
 * Represents information about a compatibility tool.
 */
export interface CompatibilityTool {
	/** Name of the compatibility tool. */
	strToolName: string;
	/** Display name of the compatibility tool. */
	strDisplayName: string;
}

/**
 * Represents details about a single screenshot upload.
 */
export interface ScreenshotUploadDetails {
	/**
	 * The size of the screenshot upload on disk (including thumbnail).
	 */
	strSizeOnDisk: string;

	/**
	 * The amount of cloud storage available.
	 */
	strCloudAvailable: string;

	/**
	 * The total cloud storage.
	 */
	strCloudTotal: string;
}

/**
 * Represents details about multiple screenshot uploads.
 */
export interface ScreenshotUploadsDetails {
	/**
	 * The total size of all screenshot uploads on disk (sum of sizes including thumbnails).
	 */
	unSizeOnDisk: number;

	/**
	 * The amount of cloud storage available.
	 */
	strCloudAvailable: string;

	/**
	 * The total cloud storage.
	 */
	strCloudTotal: string;
}

interface InstalledWorkshopItem {
	appid: number;
	legacy_content: string;
	manifestid: string;
	publishedfileid: string;
}

export interface WorkshopItem {
	unAppID: number;
	ulPublishedFileID: string;
}

export interface AppAchievementData {
	rgAchievements: AppAchievement[];
}

export interface AppAchievementResponse {
	result: EResult;
	data: AppAchievementData;
}

export interface LaunchOption {
	bIsLaunchOptionTypeExemptFromGameTheater: VDFBoolean_t;
	bIsVRLaunchOption: VDFBoolean_t;
	eType: EAppLaunchOptionType;
	nIndex: number;
	/**
	 * @note May be a localization string.
	 */
	strDescription: string;
	strGameName: string;
}

/**
 * Represents playtime information for an application.
 */
export interface Playtime {
	/** Total playtime in minutes for the last 2 weeks. */
	nPlaytimeLastTwoWeeks: number;
	/** Total playtime in minutes. */
	nPlaytimeForever: number;
	/** Last played time in Unix Epoch time format. */
	rtLastTimePlayed: number;
}

export interface PrePurchaseApp {
	nAppID: number;
	eState: EAppReleaseState;
}

export interface PrePurchaseInfo {
	apps: PrePurchaseApp[];
	lastChangeNumber: number;
}

export enum EAppReleaseState {
	Unknown,
	Unavailable,
	Prerelease,
	PreloadOnly,
	Released,
	Disabled,
}

export enum EAppLaunchOptionType {
	None,
	Default,
	SafeMode,
	Multiplayer,
	Config,
	OpenVR,
	Server,
	Editor,
	Manual,
	Benchmark,
	Option1,
	Option2,
	Option3,
	OculusVR,
	OpenVROverlay,
	OSVR,
	OpenXR,
	Dialog = 1e3,
}

export interface SoundtrackDetails {
	tracks: SoundtrackTrack[];
	metadata: SoundtrackMetadata;
	vecAdditionalImageAssetURLs: string[];
	strCoverImageAssetURL: string;
}

export interface SoundtrackTrack {
	discNumber: number;
	trackNumber: number;
	durationSeconds: number;
	trackDisplayName: string;
}

export interface SoundtrackMetadata {
	artist: string;
}

export interface StoreTagLocalization {
	tag: number;
	string: string;
}

export interface WorkshopItem {
	/**
	 * Required items' IDs.
	 */
	children: string[];
	eresult: EResult;
	/**
	 * Item size, in byts.
	 */
	file_size: string;
	/**
	 * Workshop file type.
	 */
	file_type: EWorkshopFileType;
	/**
	 * Item preview image URL.
	 */
	preview_url: string;
	/**
	 * Item ID.
	 */
	publishedfileid: string;
	/**
	 * Item description.
	 */
	short_description: string;
	/**
	 * Item tags.
	 */
	tags: string[];
	/**
	 * Item title.
	 */
	title: string;
}

export enum EWorkshopFileType {
	Invalid = -1,
	Community,
	Microtransaction,
	Collection,
	Art,
	Video,
	Screenshot,
	Game,
	Software,
	Concept,
	WebGuide,
	IntegratedGuide,
	Merch,
	ControllerBinding,
	SteamworksAccessInvite,
	SteamVideo,
	GameManagedItem,
	Max,
}

export interface EndUserLicenseAgreement {
	id: string;
	url: string;
	version: number;
}

export interface AppBackupStatus {
	appid: number;
	eError: EAppUpdateError;
	strBytesToProcess: string;
	strBytesProcessed: string;
	strTotalBytesWritten: string;
}

export enum EAppUpdateError {
	None,
	Unspecified,
	Paused,
	Canceled,
	Suspended,
	NoSubscription,
	NoConnection,
	Timeout,
	MissingKey,
	MissingConfig,
	DiskReadFailure,
	DiskWriteFailure,
	NotEnoughDiskSpace,
	CorruptGameFiles,
	WaitingForNextDisk,
	InvalidInstallPath,
	AppRunning,
	DependencyFailure,
	NotInstalled,
	UpdateRequired,
	Busy,
	NoDownloadSources,
	InvalidAppConfig,
	InvalidDepotConfig,
	MissingManifest,
	NotReleased,
	RegionRestricted,
	CorruptDepotCache,
	MissingExecutable,
	InvalidPlatform,
	InvalidFileSystem,
	CorruptUpdateFiles,
	DownloadDisabled,
	SharedLibraryLocked,
	PendingLicense,
	OtherSessionPlaying,
	CorruptDownload,
	CorruptDisk,
	FilePermissions,
	FileLocked,
	MissingContent,
	Requires64BitOS,
	MissingUpdateFiles,
	NotEnoughDiskQuota,
	LockedSiteLicense,
	ParentalControlBlocked,
	CreateProcessFailure,
	SteamClientOutdated,
	PlaytimeExceeded,
	CorruptFileSignature,
	MissingInstalledFiles,
	CompatibilityToolFailure,
	UnmountedUninstallPath,
	InvalidBackupPath,
	InvalidPasscode,
	ThirdPartyUpdater,
	ParentalPlaytimeExceeded,
	Max,
}

// TODO: not the actual name
export enum ESteamInputController {
	PlayStation = 1 << 0,
	Xbox = 1 << 1,
	Generic = 1 << 2,
	NintendoSwitch = 1 << 3,
}

type AppPlatform_t = 'windows' | 'osx' | 'linux';

export interface AppDetails {
	achievements: AppAchievements;
	/** Indicates whether the application is available on the store. */
	bAvailableContentOnStore: boolean;
	bCanMoveInstallFolder: boolean;
	bCloudAvailable: boolean;
	bCloudEnabledForAccount: boolean;
	bCloudEnabledForApp: boolean;
	bCloudSyncOnSuspendAvailable: boolean;
	bCloudSyncOnSuspendEnabled: boolean;
	/** Indicates whether the application has community market available. */
	bCommunityMarketPresence: boolean;
	bEnableAllowDesktopConfiguration: boolean;
	bFreeRemovableLicense: boolean;
	bHasAllLegacyCDKeys: boolean;
	bHasAnyLocalContent: boolean;
	bHasLockedPrivateBetas: boolean;
	bIsExcludedFromSharing: boolean;
	bIsSubscribedTo: boolean;
	bIsThirdPartyUpdater: boolean;
	bOverlayEnabled: boolean;
	bOverrideInternalResolution: boolean;
	bRequiresLegacyCDKey: boolean;
	bShortcutIsVR: boolean;
	bShowCDKeyInMenus: boolean;
	bShowControllerConfig: boolean;
	bSupportsCDKeyCopyToClipboard: boolean;
	bVRGameTheatreEnabled: boolean;
	bWorkshopVisible: boolean;
	deckDerivedProperties?: AppDeckDerivedProperties;
	/**
	 * @see {@link EAppOwnershipFlags}
	 */
	eAppOwnershipFlags: number;
	eAutoUpdateValue: EAppAutoUpdateBehavior;
	eBackgroundDownloads: EAppAllowDownloadsWhileRunningBehavior;
	eCloudStatus: EAppCloudStatus;
	/**
	 * @todo enum
	 */
	eCloudSync: number;
	eControllerRumblePreference: EControllerRumbleSetting;
	eDisplayStatus: EDisplayStatus;
	eEnableThirdPartyControllerConfiguration: EThirdPartyControllerConfiguration;
	/**
	 * @see {@link ESteamInputController}
	 */
	eSteamInputControllerMask: number;
	/**
	 * Index of the install folder. -1 if not installed.
	 */
	iInstallFolder: number;
	/** Disk space required for installation, in bytes. */
	lDiskSpaceRequiredBytes: number;
	/** Application disk space usage, in bytes. */
	lDiskUsageBytes: number;
	/** DLC disk space usage, in bytes. */
	lDlcUsageBytes: number;
	nBuildID: number;
	nCompatToolPriority: number;
	/** Total play time, in minutes. */
	nPlaytimeForever: number;
	/** Screenshot count. */
	nScreenshots: number;
	rtLastTimePlayed: number;
	rtLastUpdated: number;
	rtPurchased: number;
	selectedLanguage: AppLanguage;
	strCloudBytesAvailable: string;
	strCloudBytesUsed: string;
	strCompatToolDisplayName: string;
	strCompatToolName: string;
	strDeveloperName: string;
	strDeveloperURL: string;
	strDisplayName: string;
	strExternalSubscriptionURL: string;
	strFlatpakAppID: string;
	strHomepageURL: string;
	strLaunchOptions: string;
	strManualURL: string;
	/** Steam64 ID. */
	strOwnerSteamID: string;
	strResolutionOverride: string;
	strSelectedBeta: string;
	strShortcutExe: string;
	strShortcutLaunchOptions: string;
	strShortcutStartDir: string;
	strSteamDeckBlogURL: string;
	unAppID: number;
	unEntitledContentApp: number;
	unTimedTrialSecondsAllowed: number;
	unTimedTrialSecondsPlayed: number;
	vecBetas: AppBeta[];
	vecChildConfigApps: number[];
	vecDLC: AppDLC[];
	vecDeckCompatTestResults: DeckCompatTestResult[];
	vecLanguages: AppLanguage[];
	vecLegacyCDKeys: LegacyCDKey[];
	vecMusicAlbums: AppSoundtrack[];
	vecPlatforms: AppPlatform_t[];
	vecScreenShots: Screenshot[];
	libraryAssets?: AppLibraryAsset;
}

interface AppAssociation {
	strName: string;
	strURL: string;
}

export interface AppAssociations {
	rgDevelopers: AppAssociation[];
	rgFranchises: AppAssociation[];
	rgPublishers: AppAssociation[];
}

export interface BadgeCard {
	nOwned: number;
	strArtworkURL: string;
	strImgURL: string;
	strMarketHash: string;
	strName: string;
	strTitle: string;
}

export interface Badge {
	bMaxed: VDFBoolean_t;
	dtNextRetry: number | null;
	nLevel: number;
	nMaxLevel: number;
	nNextLevelXP: number;
	nXP: number;
	rgCards: BadgeCard[];
	strIconURL: string;
	strName: string;
	strNextLevelName: string;
}

interface AppDescription {
	/**
	 * Full app description. Note that it uses BB code and so must be rendered.
	 */
	strFullDescription: string;

	/**
	 * Short game description.
	 */
	strSnippet: string;
}

interface CachedAppDetailMap {
	/**
	 * Stringified JSON data of achievements.
	 */
	achievementmap: string;
	achievements: AppAchievements;
	associations: AppAssociations;
	badge: Badge;
	descriptions: AppDescription;
	gameactivity: any[];
	/**
	 * Each string is a base64 encoded binary data.
	 */
	usernews: string[];
	workshop_trendy_items: any;
}

export type CachedAppDetails = {
	[K in keyof CachedAppDetailMap]: {
		version: number;
		data: CachedAppDetailMap[K];
	};
};

export interface AppDeckDerivedProperties {
	gamescope_frame_limiter_not_supported?: boolean;
	non_deck_display_glyphs: boolean;
	primary_player_is_controller_slot_0: boolean;
	requires_h264: boolean;
	requires_internet_for_setup: boolean;
	requires_internet_for_singleplayer: boolean;
	requires_manual_keyboard_invoke: false;
	requires_non_controller_launcher_nav: false;
	small_text: boolean;
	supported_input: number;
}

export enum EAppOwnershipFlags {
	None,
	Subscribed = 1 << 0,
	Free = 1 << 1,
	RegionRestricted = 1 << 2,
	LowViolence = 1 << 3,
	InvalidPlatform = 1 << 4,
	Borrowed = 1 << 5,
	FreeWeekend = 1 << 6,
	Retail = 1 << 7,
	Locked = 1 << 8,
	Pending = 1 << 9,
	Expired = 1 << 10,
	Permanent = 1 << 11,
	Recurring = 1 << 12,
	Canceled = 1 << 13,
	AutoGrant = 1 << 14,
	PendingGift = 1 << 15,
	RentalNotActivated = 1 << 16,
	Rental = 1 << 17,
	SiteLicense = 1 << 18,
	LegacyFreeSub = 1 << 19,
	InvalidOSType = 1 << 20,
	TimedTrial = 1 << 21,
}

export enum EAppAutoUpdateBehavior {
	Always,
	Launch,
	HighPriority,
}

export enum EAppAllowDownloadsWhileRunningBehavior {
	UseGlobal,
	AlwaysAllow,
	NeverAllow,
}

export enum EDisplayStatus {
	Invalid,
	Launching,
	Uninstalling,
	Installing,
	Running,
	Validating,
	Updating,
	Downloading,
	Synchronizing,
	ReadyToInstall,
	ReadyToPreload,
	ReadyToLaunch,
	RegionRestricted,
	PresaleOnly,
	InvalidPlatform,
	// ty valve
	PreloadComplete = 16,
	BorrowerLocked,
	UpdatePaused,
	UpdateQueued,
	UpdateRequired,
	UpdateDisabled,
	DownloadPaused,
	DownloadQueued,
	DownloadRequired,
	DownloadDisabled,
	LicensePending,
	LicenseExpired,
	AvailForFree,
	AvailToBorrow,
	AvailGuestPass,
	Purchase,
	Unavailable,
	NotLaunchable,
	CloudError,
	CloudOutOfDate,
	Terminating,
	OwnerLocked,
	DownloadFailed,
	UpdateFailed,
}

export enum ESteamDeckCompatibilityTestResult {
	Invalid,
	NotApplicable,
	Pass,
	Fail,
	FailMinor,
}

export interface AppLanguage {
	strDisplayName: string;
	/** A localization string for the language. */
	strShortName: string;
}

export interface LegacyCDKey {
	eResult: EResult;
	strKey: string;
	strName: string;
}

export interface AppBeta {
	/** Beta name. */
	strName: string;
	/** Beta description. */
	strDescription: string;
}

export interface AppDLC {
	/** Is the DLC availble on the store? */
	bAvailableOnStore: boolean;
	bEnabled: boolean;
	/** Disk usage, in bytes. */
	lDiskUsageBytes: number;
	/** Purchase date. */
	rtPurchaseDate: number;
	rtStoreAssetModifyType: number;
	/** Store header image filename. */
	strHeaderFilename: string;
	/** Display name. */
	strName: string;
	/** State (installed/notinstalled). */
	strState: string;
	/** App ID. */
	unAppID: number;
}

export interface DeckCompatTestResult {
	test_result: ESteamDeckCompatibilityTestResult;
	/** A localization string. */
	test_loc_token: string;
}

export interface AppSoundtrack {
	/** Purchase date. */
	rtPurchaseDate: number;
	rtStoreAssetModifyType: number;
	/** Display name. */
	strName: string;
	/** State (installed/notinstalled). */
	strState: string;
	/** App ID. */
	unAppID: number;
}

export interface AppLibraryAsset {
	logoPosition?: LogoPosition;
	strCapsuleImage: string;
	strHeroBlurImage: string;
	strHeroImage: string;
	strLogoImage: string;
}

export interface LogoPosition {
	pinnedPosition: LogoPinPosition_t;
	nWidthPct: number;
	nHeightPct: number;
}

export type LogoPinPosition_t = 'BottomLeft' | 'UpperLeft' | 'CenterCenter' | 'UpperCenter' | 'BottomCenter';

export enum ELaunchSource {
	None,
	_2ftLibraryDetails = 100,
	_2ftLibraryListView,
	_2ftLibraryGrid,
	InstallSubComplete,
	DownloadsPage,
	RemoteClientStartStreaming,
	_2ftMiniModeList,
	_10ft = 200,
	DashAppLaunchCmdLine = 300,
	DashGameIdLaunchCmdLine,
	RunByGameDir,
	SubCmdRunDashGame,
	SteamURL_Launch = 400,
	SteamURL_Run,
	SteamURL_JoinLobby,
	SteamURL_RunGame,
	SteamURL_RunGameIdOrJumplist,
	SteamURL_RunSafe,
	TrayIcon = 500,
	LibraryLeftColumnContextMenu = 600,
	LibraryLeftColumnDoubleClick,
	Dota2Launcher = 700,
	IRunGameEngine = 800,
	DRMFailureResponse,
	DRMDataRequest,
	CloudFilePanel,
	DiscoveredAlreadyRunning,
	GameActionJoinParty = 900,
	AppPortraitContextMenu = 1000,
}

export interface NonSteamApp {
	bIsApplication: boolean;
	strAppName: string;
	strExePath: string;
	strArguments: string;
	strCmdline: string;
	strIconDataBase64: string | undefined;
}

export interface Shortcut extends NonSteamApp {
	strShortcutPath: string | undefined;
	strSortAs: string | undefined;
}

export interface LogoPositionForApp {
	nVersion: number; // Usually 1
	logoPosition: LogoPosition;
}

export interface CLibraryBootstrapData extends JsPbMessage {
	app_data(): AppBootstrapData[];

	add_app_data(param0: any, param1: any): any;

	set_app_data(param0: any): any;
}

export interface AppBootstrapData {
	appid: number;
	hidden: boolean;
	user_tag: string[];
}

export interface CAppOverview_Change extends JsPbMessage {
	app_overview(): SteamAppOverview[];

	full_update(): boolean;

	removed_appid(): number[];

	update_complete(): boolean;

	add_app_overview(param0: any, param1: any): any;

	add_removed_appid(param0: any, param1: any): any;

	set_app_overview(param0: any): any;

	set_full_update(param0: any): any;

	set_removed_appid(param0: any): any;

	set_update_complete(param0: any): any;
}

export enum ECloudPendingRemoteOperation {
	None,
	AppSessionActive,
	UploadInProgress,
	UploadPending,
	AppSessionSuspended,
}

export interface CCloud_PendingRemoteOperation {
	operation(): ECloudPendingRemoteOperation;
	machine_name(): string;
	client_id(): number;
	time_last_updated(): number;
	os_type(): number;
	device_type(): number;
}

export interface CMsgCloudPendingRemoteOperations extends JsPbMessage {
	operations: CCloud_PendingRemoteOperation[];
}

// Appears to be all optional fields :disaster:
export interface SteamAppOverview {
	appid: number;
	display_name: string;
	visible_in_game_list: boolean;
	sort_as: string;

	/*
	 * Possible bitmask values, but I haven't spotted any of them being masked in the app_type field.
	 * Should be safe as an enum.
	 */
	app_type: EAppType;
	mru_index: number | undefined;
	rt_recent_activity_time: number;
	minutes_playtime_forever: number;
	minutes_playtime_last_two_weeks: number;
	rt_last_time_played_or_installed: number;
	rt_last_time_played: number;
	store_tag?: number[];
	association: SteamAppOverviewAssociation[];
	store_category?: number[];
	rt_original_release_date: number;
	rt_steam_release_date: number;
	icon_hash: string;
	controller_support?: EAppControllerSupportLevel; // default none
	vr_supported?: boolean;
	metacritic_score: number;
	size_on_disk?: number;
	third_party_mod?: boolean;
	icon_data?: string;
	icon_data_format?: string;
	gameid: string;
	library_capsule_filename?: string;
	per_client_data: SteamAppOverviewRemoteClientData[];
	most_available_clientid: string;
	selected_clientid?: string;
	rt_store_asset_mtime: number;
	rt_custom_image_mtime?: number;
	optional_parent_app_id?: number;
	owner_account_id?: number;
	review_score_with_bombs: number;
	review_percentage_with_bombs: number;
	review_score_without_bombs: number;
	review_percentage_without_bombs: number;
	library_id?: string;
	vr_only?: boolean;
	mastersub_appid?: number;
	mastersub_includedwith_logo?: string;
	site_license_site_name?: string;
	shortcut_override_appid?: number;
	steam_deck_compat_category: ESteamDeckCompatibilityCategory; // Default should be Unknown
	rt_last_time_locally_played?: number;
	rt_purchased_time: number;
	header_filename?: string;
	local_cache_version?: number;
	ps4_controller_support?: EAppControllerSupportLevel;
	ps5_controller_support?: EAppControllerSupportLevel;
	gamepad_preferred?: boolean;
	canonicalAppType: number;
	local_per_client_data: SteamAppOverviewRemoteClientData;
	most_available_per_client_data: SteamAppOverviewRemoteClientData;
	selected_per_client_data: SteamAppOverviewRemoteClientData;
}

export enum EAppType {
	DepotOnly = -2147483648,
	Invalid = 0,
	Game = 1 << 0,
	Application = 1 << 1,
	Tool = 1 << 2,
	Demo = 1 << 3,
	Deprecated = 1 << 4,
	DLC = 1 << 5,
	Guide = 1 << 6,
	Driver = 1 << 7,
	Config = 1 << 8,
	Hardware = 1 << 9,
	Franchise = 1 << 10,
	Video = 1 << 11,
	Plugin = 1 << 12,
	MusicAlbum = 1 << 13,
	Series = 1 << 14,
	Comic = 1 << 15,
	Beta = 1 << 16,
	Shortcut = 1073741824,
}

export interface SteamAppOverviewAssociation {
	type: EAppAssociationType; // Default should be Invalid
	name: string;
}

export enum EAppAssociationType {
	Invalid,
	Publisher,
	Developer,
	Franchise,
}

export enum EAppControllerSupportLevel {
	None,
	Partial,
	Full,
}

export interface SteamAppOverviewRemoteClientData {
	clientid: string;
	client_name: string;
	display_status: EDisplayStatus; // Default should be Invalid
	status_percentage: number;
	active_beta?: string;
	installed?: boolean;
	bytes_downloaded: string;
	bytes_total: string;
	streaming_to_local_client?: boolean;
	is_available_on_current_platform: boolean;
	is_invalid_os_type?: boolean;
	playtime_left?: number;
	cloud_status: EAppCloudStatus;
}

export enum ESteamDeckCompatibilityCategory {
	Unknown,
	Unsupported,
	Playable,
	Verified,
}

export enum EAppCloudStatus {
	Invalid,
	Disabled,
	Unknown,
	Synchronized,
	Checking,
	OutOfSync,
	Uploading,
	Downloading,
	SyncFailed,
	Conflict,
	PendingElsewhere,
}

export enum ERaiseGameWindowResult {
	NotRunning = 1,
	Success,
	Failure,
}