steamworks.js-timmy 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Gabriel Francisco Dos Santos
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,88 @@
+[![Build Status](https://github.com/ceifa/steamworks.js/actions/workflows/publish.yml/badge.svg)](https://github.com/ceifa/steamworks.js/actions/workflows/publish.yml)
+[![npm](https://img.shields.io/npm/v/steamworks.js.svg)](https://npmjs.com/package/steamworks.js)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Chat](https://img.shields.io/discord/663831597690257431?label=chat&logo=discord)](https://discord.gg/H6B7UE7fMY)
+
+# Steamworks.js
+
+A modern implementation of the Steamworks SDK for HTML/JS and NodeJS based applications.
+
+## Why
+
+I used [greenworks](https://github.com/greenheartgames/greenworks) for a long time and it's great, but I gave up for the following reasons.
+
+* It's not being maintained anymore.
+* It's not up to date.
+* It's not context-aware.
+* You have to build the binaries by yourself.
+* Don't have typescript definitions.
+* The API it's not trustful.
+* The API implement callbacks instead of return flags or promises.
+* I hate C++.
+
+## API
+
+```js
+const steamworks = require('steamworks.js')
+
+// You can pass an appId, or don't pass anything and use a steam_appid.txt file
+const client = steamworks.init(480)
+
+// Print Steam username
+console.log(client.localplayer.getName())
+
+// Tries to activate an achievement
+if (client.achievement.activate('ACHIEVEMENT')) {
+    // ...
+}
+```
+
+You can refer to the [declarations file](https://github.com/ceifa/steamworks.js/blob/main/client.d.ts) to check the API support and get more detailed documentation of each function.
+
+## Installation
+
+To use steamworks.js you don't have to build anything, just install it from npm:
+
+```sh
+$: npm i steamworks.js
+```
+
+### Electron
+
+Steamworks.js is a native module and cannot be used by default in the renderer process. To enable the usage of native modules on the renderer process, the following configurations should be made on `main.js`:
+
+```js
+const mainWindow = new BrowserWindow({
+    // ...
+    webPreferences: {
+        // ...
+        contextIsolation: false,
+        nodeIntegration: true
+    }
+})
+```
+
+To make the steam overlay working, call the `electronEnableSteamOverlay` on the end of your `main.js` file:
+
+```js
+require('steamworks.js').electronEnableSteamOverlay()
+```
+
+For the production build, copy the relevant distro files from `sdk/redistributable_bin/{YOUR_DISTRO}` into the root of your build. If you are using electron-forge, look for [#75](https://github.com/ceifa/steamworks.js/issues/75).
+
+
+## How to build
+
+> You **only** need to build if you are going to change something on steamworks.js code, if you are looking to just consume the library or use it in your game, refer to the [installation section](#installation).
+
+Make sure you have the latest [node.js](https://nodejs.org/en/), [Rust](https://www.rust-lang.org/tools/install) and [Clang](https://rust-lang.github.io/rust-bindgen/requirements.html). We also need [Steam](https://store.steampowered.com/about/) installed and running.
+
+Install dependencies with `npm install` and then run `npm run build:debug` to build the library.
+
+There is no way to build for all targets easily. The good news is that you don't need to. You can develop and test on your current target, and open a PR. When the code is merged to main, a github action will build for all targets and publish a new version.
+
+### Testing Electron
+
+Go to the [test/electron](./test/electron) directory. There, you can run `npm install` and then `npm start` to run the Electron app.
+
+Click "activate overlay" to test the overlay.

package/callbacks.d.ts

@@ -0,0 +1,56 @@
+import client = require('./client')
+
+export const enum ChatMemberStateChange {
+    /** This user has joined or is joining the lobby. */
+    Entered,
+    /** This user has left or is leaving the lobby. */
+    Left,
+    /** User disconnected without leaving the lobby first. */
+    Disconnected,
+    /** The user has been kicked. */
+    Kicked,
+    /** The user has been kicked and banned. */
+    Banned,
+}
+
+export interface CallbackReturns {
+    [client.callback.SteamCallback.PersonaStateChange]: {
+        steam_id: bigint
+        flags: { bits: number }
+    }
+    [client.callback.SteamCallback.SteamServersConnected]: {}
+    [client.callback.SteamCallback.SteamServersDisconnected]: {
+        reason: number
+    }
+    [client.callback.SteamCallback.SteamServerConnectFailure]: {
+        reason: number
+        still_retrying: boolean
+    }
+    [client.callback.SteamCallback.LobbyDataUpdate]: {
+        lobby: bigint
+        member: bigint
+        success: boolean
+    }
+    [client.callback.SteamCallback.LobbyChatUpdate]: {
+        lobby: bigint
+        user_changed: bigint
+        making_change: bigint
+        member_state_change: ChatMemberStateChange
+    }
+    [client.callback.SteamCallback.P2PSessionRequest]: {
+        remote: bigint
+    }
+    [client.callback.SteamCallback.P2PSessionConnectFail]: {
+        remote: bigint
+        error: number
+    }
+    [client.callback.SteamCallback.GameLobbyJoinRequested]: {
+        lobby_steam_id: bigint
+        friend_steam_id: bigint
+    }
+    [client.callback.SteamCallback.MicroTxnAuthorizationResponse]: {
+        app_id: number
+        order_id: number | bigint
+        authorized: boolean
+    }
+}

package/client.d.ts

@@ -0,0 +1,497 @@
+export declare function init(appId?: number | undefined | null): void
+export declare function restartAppIfNecessary(appId: number): boolean
+export declare function runCallbacks(): void
+export interface PlayerSteamId {
+  steamId64: bigint
+  steamId32: string
+  accountId: number
+}
+export declare namespace achievement {
+  export function activate(achievement: string): boolean
+  export function isActivated(achievement: string): boolean
+  export function clear(achievement: string): boolean
+  export function names(): Array<string>
+}
+export declare namespace apps {
+  export function isSubscribedApp(appId: number): boolean
+  export function isAppInstalled(appId: number): boolean
+  export function isDlcInstalled(appId: number): boolean
+  export function isSubscribedFromFreeWeekend(): boolean
+  export function isVacBanned(): boolean
+  export function isCybercafe(): boolean
+  export function isLowViolence(): boolean
+  export function isSubscribed(): boolean
+  export function appBuildId(): number
+  export function appInstallDir(appId: number): string
+  export function appOwner(): PlayerSteamId
+  export function availableGameLanguages(): Array<string>
+  export function currentGameLanguage(): string
+  export function currentBetaName(): string | null
+}
+export declare namespace auth {
+  /**
+   * @param steamId64 - The user steam id or game server steam id. Use as NetworkIdentity of the remote system that will authenticate the ticket. If it is peer-to-peer then the user steam ID. If it is a game server, then the game server steam ID may be used if it was obtained from a trusted 3rd party
+   * @param timeoutSeconds - The number of seconds to wait for the ticket to be validated. Default value is 10 seconds.
+   */
+  export function getSessionTicketWithSteamId(steamId64: bigint, timeoutSeconds?: number | undefined | null): Promise<Ticket>
+  /**
+   * @param ip - The string of IPv4 or IPv6 address. Use as NetworkIdentity of the remote system that will authenticate the ticket.
+   * @param timeoutSeconds - The number of seconds to wait for the ticket to be validated. Default value is 10 seconds.
+   */
+  export function getSessionTicketWithIp(ip: string, timeoutSeconds?: number | undefined | null): Promise<Ticket>
+  export function getAuthTicketForWebApi(identity: string, timeoutSeconds?: number | undefined | null): Promise<Ticket>
+  export class Ticket {
+    cancel(): void
+    getBytes(): Buffer
+  }
+}
+export declare namespace callback {
+  export const enum SteamCallback {
+    PersonaStateChange = 0,
+    SteamServersConnected = 1,
+    SteamServersDisconnected = 2,
+    SteamServerConnectFailure = 3,
+    LobbyDataUpdate = 4,
+    LobbyChatUpdate = 5,
+    P2PSessionRequest = 6,
+    P2PSessionConnectFail = 7,
+    GameLobbyJoinRequested = 8,
+    MicroTxnAuthorizationResponse = 9
+  }
+  export function register<C extends keyof import('./callbacks').CallbackReturns>(steamCallback: C, handler: (value: import('./callbacks').CallbackReturns[C]) => void): Handle
+  export class Handle {
+    disconnect(): void
+  }
+}
+export declare namespace cloud {
+  export function isEnabledForAccount(): boolean
+  export function isEnabledForApp(): boolean
+  export function setEnabledForApp(enabled: boolean): void
+  export function readFile(name: string): string
+  export function writeFile(name: string, content: string): boolean
+  export function deleteFile(name: string): boolean
+  export function fileExists(name: string): boolean
+  export function listFiles(): Array<FileInfo>
+  export class FileInfo {
+    name: string
+    size: bigint
+  }
+}
+export declare namespace input {
+  export const enum InputType {
+    Unknown = 'Unknown',
+    SteamController = 'SteamController',
+    XBox360Controller = 'XBox360Controller',
+    XBoxOneController = 'XBoxOneController',
+    GenericGamepad = 'GenericGamepad',
+    PS4Controller = 'PS4Controller',
+    AppleMFiController = 'AppleMFiController',
+    AndroidController = 'AndroidController',
+    SwitchJoyConPair = 'SwitchJoyConPair',
+    SwitchJoyConSingle = 'SwitchJoyConSingle',
+    SwitchProController = 'SwitchProController',
+    MobileTouch = 'MobileTouch',
+    PS3Controller = 'PS3Controller',
+    PS5Controller = 'PS5Controller',
+    SteamDeckController = 'SteamDeckController'
+  }
+  export interface MotionData {
+    /** Absolute Rotation (drift) X axis */
+    rotQuatX: number
+    /** Absolute Rotation (drift) Y axis */
+    rotQuatY: number
+    /** Absolute Rotation (drift) Z axis */
+    rotQuatZ: number
+    /** Absolute Rotation (drift) W axis */
+    rotQuatW: number
+    /** Positional Acceleration X axis */
+    posAccelX: number
+    /** Positional Acceleration Y axis */
+    posAccelY: number
+    /** Positional Acceleration Z axis */
+    posAccelZ: number
+    /** Rotational Velocity X axis */
+    rotVelX: number
+    /** Rotational Velocity Y axis */
+    rotVelY: number
+    /** Rotational Velocity Z axis */
+    rotVelZ: number
+  }
+  export interface AnalogActionVector {
+    x: number
+    y: number
+  }
+  export function init(): void
+  export function getControllers(): Array<Controller>
+  export function getActionSet(actionSetName: string): bigint
+  export function getDigitalAction(actionName: string): bigint
+  export function getAnalogAction(actionName: string): bigint
+  export function shutdown(): void
+  export class Controller {
+    activateActionSet(actionSetHandle: bigint): void
+    isDigitalActionPressed(actionHandle: bigint): boolean
+    getAnalogActionVector(actionHandle: bigint): AnalogActionVector
+    getType(): InputType
+    getHandle(): bigint
+    /** Gets controller latest data, best use for low latency if you call this all the time */
+    runFrame(): void
+    /** Gets controller's motion sensors */
+    getMotionData(): MotionData | null
+  }
+}
+export declare namespace localplayer {
+  export function getSteamId(): PlayerSteamId
+  export function getName(): string
+  export function getLevel(): number
+  /** @returns the 2 digit ISO 3166-1-alpha-2 format country code which client is running in, e.g. "US" or "UK". */
+  export function getIpCountry(): string
+  export function setRichPresence(key: string, value?: string | undefined | null): void
+}
+export declare namespace matchmaking {
+  export const enum LobbyType {
+    Private = 0,
+    FriendsOnly = 1,
+    Public = 2,
+    Invisible = 3
+  }
+  export function createLobby(lobbyType: LobbyType, maxMembers: number): Promise<Lobby>
+  export function joinLobby(lobbyId: bigint): Promise<Lobby>
+  export function getLobbies(): Promise<Array<Lobby>>
+  export class Lobby {
+    join(): Promise<Lobby>
+    leave(): void
+    openInviteDialog(): void
+    getMemberCount(): bigint
+    getMemberLimit(): bigint | null
+    getMembers(): Array<PlayerSteamId>
+    getOwner(): PlayerSteamId
+    setJoinable(joinable: boolean): boolean
+    getData(key: string): string | null
+    setData(key: string, value: string): boolean
+    deleteData(key: string): boolean
+    /** Get an object containing all the lobby data */
+    getFullData(): Record<string, string>
+    /**
+     * Merge current lobby data with provided data in a single batch
+     * @returns true if all data was set successfully
+     */
+    mergeFullData(data: Record<string, string>): boolean
+
+    id(): BigInt
+    idAsU64(): number
+  }
+}
+export declare namespace networking {
+  export interface P2PPacket {
+    data: Buffer
+    size: number
+    steamId: PlayerSteamId
+  }
+  /** The method used to send a packet */
+  export const enum SendType {
+    /**
+     * Send the packet directly over udp.
+     *
+     * Can't be larger than 1200 bytes
+     */
+    Unreliable = 0,
+    /**
+     * Like `Unreliable` but doesn't buffer packets
+     * sent before the connection has started.
+     */
+    UnreliableNoDelay = 1,
+    /**
+     * Reliable packet sending.
+     *
+     * Can't be larger than 1 megabyte.
+     */
+    Reliable = 2,
+    /**
+     * Like `Reliable` but applies the nagle
+     * algorithm to packets being sent
+     */
+    ReliableWithBuffering = 3
+  }
+  export function sendP2PPacket(steamId64: bigint, sendType: SendType, data: Buffer): boolean
+  export function isP2PPacketAvailable(): number
+  export function readP2PPacket(size: number): P2PPacket
+  export function acceptP2PSession(steamId64: bigint): void
+}
+export declare namespace overlay {
+  export const enum Dialog {
+    Friends = 0,
+    Community = 1,
+    Players = 2,
+    Settings = 3,
+    OfficialGameGroup = 4,
+    Stats = 5,
+    Achievements = 6
+  }
+  export const enum StoreFlag {
+    None = 0,
+    AddToCart = 1,
+    AddToCartAndShow = 2
+  }
+  export function activateDialog(dialog: Dialog): void
+  export function activateDialogToUser(dialog: Dialog, steamId64: bigint): void
+  export function activateInviteDialog(lobbyId: bigint): void
+  export function activateToWebPage(url: string): void
+  export function activateToStore(appId: number, flag: StoreFlag): void
+}
+export declare namespace stats {
+  export function getInt(name: string): number | null
+  export function setInt(name: string, value: number): boolean
+  export function store(): boolean
+  export function resetAll(achievementsToo: boolean): boolean
+}
+export declare namespace utils {
+  export function getAppId(): number
+  export function getServerRealTime(): number
+  export function isSteamRunningOnSteamDeck(): boolean
+  export const enum GamepadTextInputMode {
+    Normal = 0,
+    Password = 1
+  }
+  export const enum GamepadTextInputLineMode {
+    SingleLine = 0,
+    MultipleLines = 1
+  }
+  /** @returns the entered text, or null if cancelled or could not show the input */
+  export function showGamepadTextInput(inputMode: GamepadTextInputMode, inputLineMode: GamepadTextInputLineMode, description: string, maxCharacters: number, existingText?: string | undefined | null): Promise<string | null>
+  export const enum FloatingGamepadTextInputMode {
+    SingleLine = 0,
+    MultipleLines = 1,
+    Email = 2,
+    Numeric = 3
+  }
+  /** @returns true if the floating keyboard was shown, otherwise, false */
+  export function showFloatingGamepadTextInput(keyboardMode: FloatingGamepadTextInputMode, x: number, y: number, width: number, height: number): Promise<boolean>
+}
+export declare namespace workshop {
+  export interface UgcResult {
+    itemId: bigint
+    needsToAcceptAgreement: boolean
+  }
+  export const enum UgcItemVisibility {
+    Public = 0,
+    FriendsOnly = 1,
+    Private = 2,
+    Unlisted = 3
+  }
+  export interface UgcUpdate {
+    title?: string
+    description?: string
+    changeNote?: string
+    previewPath?: string
+    contentPath?: string
+    tags?: Array<string>
+    visibility?: UgcItemVisibility
+  }
+  export interface InstallInfo {
+    folder: string
+    sizeOnDisk: bigint
+    timestamp: number
+  }
+  export interface DownloadInfo {
+    current: bigint
+    total: bigint
+  }
+  export const enum UpdateStatus {
+    Invalid = 0,
+    PreparingConfig = 1,
+    PreparingContent = 2,
+    UploadingContent = 3,
+    UploadingPreviewFile = 4,
+    CommittingChanges = 5
+  }
+  export interface UpdateProgress {
+    status: UpdateStatus
+    progress: bigint
+    total: bigint
+  }
+  export function createItem(appId?: number | undefined | null): Promise<UgcResult>
+  export function updateItem(itemId: bigint, updateDetails: UgcUpdate, appId?: number | undefined | null): Promise<UgcResult>
+  export function updateItemWithCallback(itemId: bigint, updateDetails: UgcUpdate, appId: number | undefined | null, successCallback: (data: UgcResult) => void, errorCallback: (err: any) => void, progressCallback?: (data: UpdateProgress) => void, progressCallbackIntervalMs?: number | undefined | null): void
+  /**
+   * Subscribe to a workshop item. It will be downloaded and installed as soon as possible.
+   *
+   * {@link https://partner.steamgames.com/doc/api/ISteamUGC#SubscribeItem}
+   */
+  export function subscribe(itemId: bigint): Promise<void>
+  /**
+   * Unsubscribe from a workshop item. This will result in the item being removed after the game quits.
+   *
+   * {@link https://partner.steamgames.com/doc/api/ISteamUGC#UnsubscribeItem}
+   */
+  export function unsubscribe(itemId: bigint): Promise<void>
+  /**
+   * Gets the current state of a workshop item on this client. States can be combined.
+   *
+   * @returns a number with the current item state, e.g. 9
+   * 9 = 1 (The current user is subscribed to this item) + 8 (The item needs an update)
+   *
+   * {@link https://partner.steamgames.com/doc/api/ISteamUGC#GetItemState}
+   * {@link https://partner.steamgames.com/doc/api/ISteamUGC#EItemState}
+   */
+  export function state(itemId: bigint): number
+  /**
+   * Gets info about currently installed content on the disc for workshop item.
+   *
+   * @returns an object with the the properties {folder, size_on_disk, timestamp}
+   *
+   * {@link https://partner.steamgames.com/doc/api/ISteamUGC#GetItemInstallInfo}
+   */
+  export function installInfo(itemId: bigint): InstallInfo | null
+  /**
+   * Get info about a pending download of a workshop item.
+   *
+   * @returns an object with the properties {current, total}
+   *
+   * {@link https://partner.steamgames.com/doc/api/ISteamUGC#GetItemDownloadInfo}
+   */
+  export function downloadInfo(itemId: bigint): DownloadInfo | null
+  /**
+   * Download or update a workshop item.
+   *
+   * @param highPriority - If high priority is true, start the download in high priority mode, pausing any existing in-progress Steam downloads and immediately begin downloading this workshop item.
+   * @returns true or false
+   *
+   * {@link https://partner.steamgames.com/doc/api/ISteamUGC#DownloadItem}
+   */
+  export function download(itemId: bigint, highPriority: boolean): boolean
+  /**
+   * Get all subscribed workshop items.
+   * @returns an array of subscribed workshop item ids
+   */
+  export function getSubscribedItems(): Array<bigint>
+  export function deleteItem(itemId: bigint): Promise<void>
+  export const enum UGCQueryType {
+    RankedByVote = 0,
+    RankedByPublicationDate = 1,
+    AcceptedForGameRankedByAcceptanceDate = 2,
+    RankedByTrend = 3,
+    FavoritedByFriendsRankedByPublicationDate = 4,
+    CreatedByFriendsRankedByPublicationDate = 5,
+    RankedByNumTimesReported = 6,
+    CreatedByFollowedUsersRankedByPublicationDate = 7,
+    NotYetRated = 8,
+    RankedByTotalVotesAsc = 9,
+    RankedByVotesUp = 10,
+    RankedByTextSearch = 11,
+    RankedByTotalUniqueSubscriptions = 12,
+    RankedByPlaytimeTrend = 13,
+    RankedByTotalPlaytime = 14,
+    RankedByAveragePlaytimeTrend = 15,
+    RankedByLifetimeAveragePlaytime = 16,
+    RankedByPlaytimeSessionsTrend = 17,
+    RankedByLifetimePlaytimeSessions = 18,
+    RankedByLastUpdatedDate = 19
+  }
+  export const enum UGCType {
+    Items = 0,
+    ItemsMtx = 1,
+    ItemsReadyToUse = 2,
+    Collections = 3,
+    Artwork = 4,
+    Videos = 5,
+    Screenshots = 6,
+    AllGuides = 7,
+    WebGuides = 8,
+    IntegratedGuides = 9,
+    UsableInGame = 10,
+    ControllerBindings = 11,
+    GameManagedItems = 12,
+    All = 13
+  }
+  export const enum UserListType {
+    Published = 0,
+    VotedOn = 1,
+    VotedUp = 2,
+    VotedDown = 3,
+    Favorited = 4,
+    Subscribed = 5,
+    UsedOrPlayed = 6,
+    Followed = 7
+  }
+  export const enum UserListOrder {
+    CreationOrderAsc = 0,
+    CreationOrderDesc = 1,
+    TitleAsc = 2,
+    LastUpdatedDesc = 3,
+    SubscriptionDateDesc = 4,
+    VoteScoreDesc = 5,
+    ForModeration = 6
+  }
+  export interface WorkshopItemStatistic {
+    numSubscriptions?: bigint
+    numFavorites?: bigint
+    numFollowers?: bigint
+    numUniqueSubscriptions?: bigint
+    numUniqueFavorites?: bigint
+    numUniqueFollowers?: bigint
+    numUniqueWebsiteViews?: bigint
+    reportScore?: bigint
+    numSecondsPlayed?: bigint
+    numPlaytimeSessions?: bigint
+    numComments?: bigint
+    numSecondsPlayedDuringTimePeriod?: bigint
+    numPlaytimeSessionsDuringTimePeriod?: bigint
+  }
+  export interface WorkshopItem {
+    publishedFileId: bigint
+    creatorAppId?: number
+    consumerAppId?: number
+    title: string
+    description: string
+    owner: PlayerSteamId
+    /** Time created in unix epoch seconds format */
+    timeCreated: number
+    /** Time updated in unix epoch seconds format */
+    timeUpdated: number
+    /** Time when the user added the published item to their list (not always applicable), provided in Unix epoch format (time since Jan 1st, 1970). */
+    timeAddedToUserList: number
+    visibility: UgcItemVisibility
+    banned: boolean
+    acceptedForUse: boolean
+    tags: Array<string>
+    tagsTruncated: boolean
+    url: string
+    numUpvotes: number
+    numDownvotes: number
+    numChildren: number
+    previewUrl?: string
+    statistics: WorkshopItemStatistic
+  }
+  export interface WorkshopPaginatedResult {
+    items: Array<WorkshopItem | undefined | null>
+    returnedResults: number
+    totalResults: number
+    wasCached: boolean
+  }
+  export interface WorkshopItemsResult {
+    items: Array<WorkshopItem | undefined | null>
+    wasCached: boolean
+  }
+  export interface WorkshopItemQueryConfig {
+    cachedResponseMaxAge?: number
+    includeMetadata?: boolean
+    includeLongDescription?: boolean
+    includeAdditionalPreviews?: boolean
+    onlyIds?: boolean
+    onlyTotal?: boolean
+    language?: string
+    matchAnyTag?: boolean
+    requiredTags?: Array<string>
+    excludedTags?: Array<string>
+    searchText?: string
+    rankedByTrendDays?: number
+  }
+  export interface AppIDs {
+    creator?: number
+    consumer?: number
+  }
+  export function getItem(item: bigint, queryConfig?: WorkshopItemQueryConfig | undefined | null): Promise<WorkshopItem | null>
+  export function getItems(items: Array<bigint>, queryConfig?: WorkshopItemQueryConfig | undefined | null): Promise<WorkshopItemsResult>
+  export function getAllItems(page: number, queryType: UGCQueryType, itemType: UGCType, creatorAppId: number, consumerAppId: number, queryConfig?: WorkshopItemQueryConfig | undefined | null): Promise<WorkshopPaginatedResult>
+  export function getUserItems(page: number, accountId: number, listType: UserListType, itemType: UGCType, sortOrder: UserListOrder, appIds: AppIDs, queryConfig?: WorkshopItemQueryConfig | undefined | null): Promise<WorkshopPaginatedResult>
+}