open-index/open-npm huggingface dataset:
npm package: @sulphate/steamlogin
Description: Simple wrapper for Dr. McKay's steamcommunity and steam-tradeoffer-manager packages to set things up.
Author: Matthew Lester
Latest version: 1.1.1

A simple wrapper around Dr. McKay's steammcommunity and steam-tradeoffer-manager NPM packages
to create a single-method log-on system for multiple Steam accounts.

## Installation
`npm install @sulphate/steamlogin`

## About
This package will most likely not be useful to you, it's very specific and made mostly
for personal convenience uses. It logs into Steam using a given accounts file, and sets
up a trade manager for each one, all with one line. It uses McKay's steamcommunity,
steam-totp and steam-tradeoffer-manager packages.

## Usage
* Create a file called `accounts.json` in your project root folder.
* The format of the file should be as follows:
```json
{
    "accounts": [
        {
            "accountName": "Steam Username",
            "password": "Password",
            "sharedSecret": "Shared Secret",
            "identitySecret": "Optional Identity Secret"
        }
    ]
}
```
**Note:** The identity secret will be added to the returned object for each account, which
can be used to confirm trade offers and other confirmations.

* Require/import the package:
```js
// ES6
import SteamLogin from "@sulphate/steamlogin";

// ES5
const SteamLogin = require("@sulphate/steamlogin");
```

* Call the SteamLogin#login() function to log in to your Steam accounts. A promise is returned
as this function is asynchronous
```js
// Async/Await
let loggedInAccounts = await SteamLogin.login();

// Promises
SteamLogin.login().then(accounts => {
    // Do something with the accounts.
}, err => {
    // Handle the error.
});
```

* The returned object contains the logged-in `steamcommunity` and `steam-tradeoffer-manager`
instances, accessible by the account name that it corresponds to.
* The community instance is under `accounts[accountName].community`, and the manager instance
is under `accounts[accountName].manager`. The identity secret is the same, but `.identitySecret`.

* Finally, you can pass in an instance of `coloured-logger` (package) and it will use it instead
of default console logging.
npm package: @sulphate/steamprice
Description: A simple library that uses various APIs to get prices for CSGO items.
Author: Matthew Lester
Latest version: 1.1.0

Uses Dr. McKay's `steamcommunity` package (for development use) and unofficial Steam
APIs (API keys required) to get prices for CS:GO items.

## Installation
`npm install @sulphate/steamprice`

## About
This package allows you to get prices for one, two or all of the items on CS:GO, in
a few lines of code.

## Usage
The main file exports a `PricingMethod` constant, to decide which method you are using,
and a `PriceManager` class which you can use to fetch the prices.

* Require/Import the package:
```js
// ES6
import { PricingMethod, PriceManager } from "@sulphate/steamprice";

// ES5
const { PricingMethod, PriceManager } = require("@sulphate/steamprice");
```

### Available Pricing Methods
**Note:** Only the `PricingMethod.STEAM_COMMUNITY` is currently functional, others will
be added in the near future.
* `PricingMethod.STEAM_COMMUNITY` - Uses an instance of the `steamcommunity` package to
fetch the price of items from the Steam Community Market.
* `PricingMethod.STEAMAPI_IO_KEY` - Uses an API key to communicate with the SteamAPI.io
pricing endpoints. **Note:** This API may have additional terms that you need to comply
with.
* `PricingMethod.STEAMLYTICS_KEY` - Uses an API key to communicate with the Steamlytics.xyz
(CS:GO) pricing endpoints.

### Example Usage
This example uses the `STEAM_COMMUNITY` pricing method to fetch the price of an item.

```js
import { PricingMethod, PriceManager } from "@sulphate/steamprice";

// community is a logged-in instance of steamcommunity.
let method = PricingMethod.STEAM_COMMUNITY;
let pManager = new PriceManager(method, community);
let itemHashName = "MP7 | Urban Hazard (Minimal Wear)";

pManager.getPriceForItem(itemHashName)
    .then(price => {
        // Price is in cents.
        console.log(`Price for ${itemHashName}: $${ price.price / 100 }`);
    })
    .catch(err => {
        console.log(err.message);
    });
```

The available methods you can use are:
* `getPriceForItem(marketHashName)` - Returns a promise, which will resolve to the price
of the given item.
* `getPricesForAllItems()` - Returns an object with market hash names as keys with the price
of every item for CS:GO. Does not work with the `STEAM_COMMUNITY` pricing method.
npm package: @sulphate/steamtrade
Description: A simple wrapper around McKay's steam-tradeoffer-manager package, for automatic trade handling. Centered around multi-account trading.
Author: Matthew Lester
Latest version: 1.1.1

A wrapper around instances of Dr. McKay's steam-tradeoffer-manager and
steamcommunity packages. Designed around multi-account trading.

## Installation
`npm install @sulphate/steamtrade`

## About
This package provides single-line trade handling for Steam, using Dr. McKay's
`steam-tradeoffer-manager` package. It automatically loads accounts inventories
and trade URLs, and can return the trade URL of the smallest inventory if you
need it.

## Usage
**Note:** You must use `@sulphate/steamlogin` to generate the list of accounts,
or you can provide them in the constructor (see below) as an object of the
following structure:
```js
{
    accountName: {
        community: (logged-in instance of steamcommunity),
        manager: (logged-in instance of steam-tradeoffer-manager, cookies set),
        identitySecret: (your identity secret, used to confirm trade offers)
    }
}
```

* Import the package:
```js
// ES6
import { TradeManager } from "@sulphate/steamtrade";

// ES5
const { TradeManager } = require("@sulphate/steamtrade");
```

* Initialise a new instance of the trade manager:
```js
let manager = new TradeManager(accounts, tradeHandlerFunction, log);
// Log is an instance of coloured-logger (optional, will use console).

// Init the manager.
// async/await
await manager.init();

// Promise
manager.init().then(() => {
    // Do something
});
```

The `tradeHandlerFunction` must be a function that takes one parameter, offer.

You can then use methods to see information about the trade offer, and then
accept, decline, counter etc. based on what you want to do.

### Available Methods
`offer.accept()` - Accepts an offer, returning a Promise. Automatically confirms
the offer, if needed.
`offer.send()` - Sends an offer, returning a Promise. Automaticallly confirms the
offer, if needed. **Note:** creation of trades has not been implemented yet.
`offer.decline()` - Declines an offer, returning a Promise.

`offer.getItemsToReceive()` - Returns the items you will receive when accepting an
offer.
`offer.getItemsToGive()` - Returns the items you will lose when accepting an offer.
`offer.getPartner()` - Returns the SteamID64 of the partner you are trading with.
`offer.getMyID()` - Returns the SteamID64 of the account that is trading.
`offer.getMyName()` - Returns the accountName of the account that is trading.

`manager.init(appid, contextid)` - Initialises the trade manager, loading
inventories for the given appid and contextid. Returns a Promise.
`manager.getInventory(accountName)` - Returns the inventory of the accountName.
`manager.getSmallestInventoryTradeLink()` - Returns the trade link of the account
with the least items in its inventory.
npm package: @sulusolutions/sparkwall-sdk
Description: TypeScript SDK library for using the Sparkwall API
Latest version: 0.1.1

# Sparkwall API TypeScript SDK

This library helps using the sparkwall-api component of Sparkwall programmatically, enabling you to
create and manage your plans, wallets and other things without using the dashboard.

## Usage

To use the library, simple import it from your code, and specify your API key, for example:

```typescript
import { Sparkwall } from '@sulusolutions/sparkwall-sdk-ts';

const apiKey = '[YOUR API KEY]';

const sparkwallApiClient = new Sparkwall({
  BASE: 'https://sparkwall-api.sulu.sh/api',
  TOKEN: apiKey,
});

const getRequests = async () => await sparkwallApiClient.requests.getRequests({
  page: 0,
  pageSize: 10,
});
```

This package uses axios under the hood to send requests.

## Build and Publish

To build a new version of the library, follow these steps:

- `npm run generate` to re-generate the client code
- bump the version number
- publish to npm the new version