CS2 Lib

https://ianlucas.github.io/cs2-lib
Admin
A TypeScript library for manipulating Counter-Strike 2 data, providing utility functions and classes...
Tokens:5,629
Snippets:60
Trust Score:8.3
Update:11 months ago
Show doc for...
Tokens:
Raw
### Install @ianlucas/cs2-lib npm package

Source: https://ianlucas.github.io/cs2-lib/index

Installation command for the @ianlucas/cs2-lib TypeScript library via npm package manager. This is the prerequisite step for using the library in a project.

```bash
npm install @ianlucas/cs2-lib
```

--------------------------------

### Initialize CS2Economy and retrieve item data in TypeScript

Source: https://ianlucas.github.io/cs2-lib/index

Initialize the CS2Economy module with items database and language settings, then retrieve a specific Counter-Strike 2 item by ID. This demonstrates basic setup and item lookup functionality.

```typescript
import { CS2Economy, CS2_ITEMS } from "@ianlucas/cs2-lib";
import { english } from "@ianlucas/cs2-lib/translations";

CS2Economy.use({
    items: CS2_ITEMS,
    language: english
});

const item = CS2Economy.getById(307);

item.name;
//=> "AWP | Dragon Lore"
```

--------------------------------

### Get Available Maps in CS2Veto (TypeScript)

Source: https://ianlucas.github.io/cs2-lib/classes/CS2Veto

Retrieves a list of all map names that are currently available in the veto process. This is useful for displaying options to users or for internal logic.

```typescript
getMaps(): string[];
```

--------------------------------

### Get Current Veto State (TypeScript)

Source: https://ianlucas.github.io/cs2-lib/classes/CS2Veto

Fetches the current state of all maps within the veto process, including their status (e.g., picked, banned, available). This provides a comprehensive view of the veto.

```typescript
getState(): CS2VetoMap[];
```

--------------------------------

### Get CS2 Keychain Data

Source: https://ianlucas.github.io/cs2-lib/classes/CS2InventoryItem

Retrieves data for CS2 keychains. It returns an array where each element contains an ID and an object with item details (id, optional seed, x, y).

```typescript
someKeychains(): [number, { id: number; seed?: number; x?: number; y?: number }][]
```

--------------------------------

### Get CS2 Patch Data

Source: https://ianlucas.github.io/cs2-lib/classes/CS2InventoryItem

Retrieves data for CS2 patches. It returns a 2D array of numbers, likely representing patch IDs and quantities or related values.

```typescript
somePatches(): [number, number][]
```

--------------------------------

### Get CS2 Item Image URLs

Source: https://ianlucas.github.io/cs2-lib/classes/CS2EconomyItem

Retrieves image URLs for different aspects of CS2 items, such as collection images, general item images, model binaries, and special or texture images. These functions typically return a string representing the URL. The `getImage` function has an optional parameter for wear.

```typescript
getCollectionImage(): string
getImage(wear?: number): string
getModelBinary(): string
getSpecialsImage(): string
getTextureImage(): string
```

--------------------------------

### Get CS2 Item Numerical Properties

Source: https://ianlucas.github.io/cs2-lib/classes/CS2EconomyItem

Provides functions to retrieve numerical properties of CS2 items, specifically maximum and minimum seed and wear values. These functions return a number and do not take any parameters. They are useful for understanding the range of possible values for these item attributes.

```typescript
getMaximumSeed(): number
getMaximumWear(): number
getMinimumSeed(): number
getMinimumWear(): number
```

--------------------------------

### Get CS2 Sticker Data

Source: https://ianlucas.github.io/cs2-lib/classes/CS2InventoryItem

Retrieves data for CS2 stickers. It returns an array containing an item ID and an object with sticker details including id, optional rotation, wear, x, and y coordinates.

```typescript
someStickers(): [
number,
{
id: number;
rotation?: number;
wear?: number;
x?: number;
y?: number;
},
][]
```

--------------------------------

### Get Current Team in CS2Veto (TypeScript)

Source: https://ianlucas.github.io/cs2-lib/classes/CS2Veto

Returns the identifier of the current team whose turn it is in the veto process. Typically represented by a number.

```typescript
getCurrentTeam(): number;
```

--------------------------------

### Get Current Action in CS2Veto (TypeScript)

Source: https://ianlucas.github.io/cs2-lib/classes/CS2Veto

Retrieves the current action being performed in the veto process. This could be picking, banning, or another defined action. Returns the action value or undefined if no action is active.

```typescript
getCurrentAction(): CS2VetoActionValues | undefined;
```

--------------------------------

### Check CS2 Item Type and Properties

Source: https://ianlucas.github.io/cs2-lib/classes/CS2EconomyItem

A comprehensive set of boolean functions to determine the type or specific properties of a CS2 item. These functions return `true` or `false` and are essential for filtering and identifying items within the CS2 economy. Examples include checking if an item is a weapon, a sticker, a container, or has specific attributes like StatTrak or a nametag.

```typescript
hasKeychains(): boolean
hasNametag(): boolean
hasPatches(): boolean
hasSeed(): boolean
hasStatTrak(): boolean
hasStickers(): boolean
hasWear(): boolean
isAgent(): boolean
isC4(): boolean
isCollectible(): boolean
isContainer(): boolean
isContract(): boolean
isEquipment(): boolean
isGloves(): boolean
isGraffiti(): boolean
isGraffitiBox(): boolean
isHeavy(): boolean
isInContainers(): boolean
isInDisplay(): boolean
isInEquipments(): boolean
isInGraphicArts(): boolean
isInMidTiers(): boolean
isInMisc(): boolean
isInRifles(): boolean
isKey(): boolean
isKeychain(): boolean
isMachinegun(): boolean
isMelee(): boolean
isMusicKit(): boolean
isNameTag(): boolean
isPaintable(): boolean
isPatch(): boolean
isPistol(): boolean
isRifle(): boolean
isSMG(): boolean
isSniperRifle(): boolean
isSouvenirCase(): boolean
isStatTrakSwapTool(): boolean
isSticker(): boolean
isStickerCapsule(): boolean
isStorageUnit(): boolean
isStub(): boolean
isTool(): boolean
isWeapon(): boolean
isWeaponCase(): boolean
```

--------------------------------

### Manage CS2 Inventory Items

Source: https://ianlucas.github.io/cs2-lib/classes/CS2EconomyInstance

Allows setting the wear level and retrieving information about CS2 economy items. Returns a boolean indicating success.

```APIDOC
## POST /api/cs2/inventory/item

### Description
Sets the wear level for a specified CS2 economy item and returns a boolean indicating success. Can also be used to retrieve item properties.

### Method
POST

### Endpoint
/api/cs2/inventory/item

### Parameters
#### Query Parameters
- **wear** (number) - Optional - The desired wear level for the item (e.g., 0.0 to 1.0).

#### Request Body
- **item** (CS2EconomyItem) - Required - The CS2 economy item to manage. This object should contain details necessary to identify the item.

### Request Example
```json
{
  "item": {
    "assetId": "1234567890",
    "classId": "11111",
    "instanceId": "22222"
  },
  "wear": 0.15
}
```

### Response
#### Success Response (200)
- **boolean** (boolean) - True if the operation was successful, false otherwise.

#### Response Example
```json
{
  "success": true
}
```
```

--------------------------------

### Initialize CS2Veto Class (TypeScript)

Source: https://ianlucas.github.io/cs2-lib/classes/CS2Veto

Constructs a new CS2Veto instance. Requires a veto type, an array of maps, and optionally an array of veto actions. The type and actions define the veto process rules, while maps represent the available maps for selection.

```typescript
new CS2Veto(
  type: CS2VetoTypeValues,
  maps: CS2Map[],
  actions?: CS2VetoActionValues[]
): CS2Veto;
```

--------------------------------

### Choose a Map in CS2Veto (TypeScript)

Source: https://ianlucas.github.io/cs2-lib/classes/CS2Veto

Allows a player or the system to choose a map from the available list. Optionally, a specific map name can be provided. Returns a boolean indicating success or failure.

```typescript
choose(mapname?: string): boolean;
```

--------------------------------

### Configure custom assets base URL for CS2Economy in TypeScript

Source: https://ianlucas.github.io/cs2-lib/index

Configure the CS2Economy module to use a custom CDN or self-hosted assets URL instead of the default cdn.cstrike.app. Useful for self-hosting asset images and reducing external dependencies.

```typescript
CS2Economy.use({
    assetsBaseUrl: "https://your-website.com/assets",
    items: CS2_ITEMS,
    language: english
});
```

--------------------------------

### CS2InventorySpec Property - economy

Source: https://ianlucas.github.io/cs2-lib/interfaces/CS2InventorySpec

The economy property of type CS2EconomyInstance represents the economy configuration instance used by the inventory. This property references the economic rules and settings for item valuation and trading.

```typescript
economy: CS2EconomyInstance
```

--------------------------------

### Define CS2BaseInventoryItem Interface

Source: https://ianlucas.github.io/cs2-lib/interfaces/CS2BaseInventoryItem

Defines the structure for a base inventory item in Counter-Strike 2. This interface includes optional and required properties such as container ID, equipped status, item ID, name tags, stickers, and wear.

```typescript
interface CS2BaseInventoryItem {
containerId?: number;
equipped?: boolean;
equippedCT?: boolean;
equippedT?: boolean;
id: number;
keychains?: Record<
string,
{ id: number; seed?: number; x?: number; y?: number },
>;
nameTag?: string;
patches?: Record<string, number>;
seed?: number;
statTrak?: number;
stickers?: Record<
string,
{ id: number; rotation?: number; wear?: number; x?: number; y?: number },
>;
storage?: Record<number, CS2BaseInventoryItem>;
updatedAt?: number;
wear?: number;
}
```

--------------------------------

### Group and List CS2 Economy Items

Source: https://ianlucas.github.io/cs2-lib/classes/CS2EconomyItem

Functions for organizing and retrieving lists of CS2 economy items. `groupContents` returns a record mapping strings to arrays of `CS2EconomyItem`, effectively grouping items by some key. `listContents` returns an array of `CS2EconomyItem`, with an optional parameter to hide special items.

```typescript
groupContents(): Record<string, CS2EconomyItem[]>
listContents(hideSpecials?: boolean): CS2EconomyItem[]
```

--------------------------------

### Complete CS2Veto Process (TypeScript)

Source: https://ianlucas.github.io/cs2-lib/classes/CS2Veto

Indicates that the veto process is complete. Returns a boolean to signify the completion status.

```typescript
done(): boolean;
```

--------------------------------

### CS2InventorySpec Property - maxItems

Source: https://ianlucas.github.io/cs2-lib/interfaces/CS2InventorySpec

The maxItems property of type number specifies the maximum number of items allowed in the inventory. This defines the capacity limit for the entire inventory system.

```typescript
maxItems: number
```

--------------------------------

### Define CS2InventorySpec Interface in TypeScript

Source: https://ianlucas.github.io/cs2-lib/interfaces/CS2InventorySpec

Declares the CS2InventorySpec interface with four required properties: data (CS2InventoryData), economy (CS2EconomyInstance), maxItems (number), and storageUnitMaxItems (number). This interface extends CS2InventoryOptions and provides the specification for configuring a CS2 inventory system.

```typescript
interface CS2InventorySpec {
  data: CS2InventoryData;
  economy: CS2EconomyInstance;
  maxItems: number;
  storageUnitMaxItems: number;
}
```

--------------------------------

### CS2InventorySpec Property - storageUnitMaxItems

Source: https://ianlucas.github.io/cs2-lib/interfaces/CS2InventorySpec

The storageUnitMaxItems property of type number specifies the maximum number of items allowed per storage unit. This defines the capacity limit for individual storage compartments within the inventory.

```typescript
storageUnitMaxItems: number
```

--------------------------------

### Define CS2Item Interface

Source: https://ianlucas.github.io/cs2-lib/interfaces/CS2Item

This TypeScript interface defines the structure for a Counter-Strike 2 item. It includes properties such as id, type, name, rarity, and wear levels, along with optional properties for images, models, and collection details. This interface is crucial for managing and representing item data within applications interacting with CS2 assets.

```typescript
interface CS2Item {
  altName?: string;
  base?: boolean;
  baseId?: number;
  category?: string;
  collection?: string;
  collectionImage?: string;
  containerType?: CS2ContainerTypeValues;
  contents?: number[];
  def?: number;
  free?: boolean;
  id: number;
  image?: string;
  index?: number;
  keys?: number[];
  legacy?: boolean;
  model?: string;
  modelBinary?: string;
  rarity?: CS2RarityColorValues;
  specials?: number[];
  specialsImage?: string;
  statTrakless?: boolean;
  statTrakOnly?: boolean;
  teams?: CS2ItemTeamValues;
  textureImage?: string;
  tint?: number;
  type: CS2ItemTypeValues;
  voFallback?: boolean;
  voFemale?: boolean;
  voPrefix?: string;
  wearMax?: number;
  wearMin?: number;
}
```

--------------------------------

### Check CS2 Item Type (isMusicKit)

Source: https://ianlucas.github.io/cs2-lib/classes/CS2InventoryItem

Checks if a CS2 item is a Music Kit. This function returns a boolean and requires no arguments.

```typescript
isMusicKit(): boolean
```

--------------------------------

### Unlock CS2 Container

Source: https://ianlucas.github.io/cs2-lib/classes/CS2EconomyItem

Simulates the unlocking of a CS2 container, returning a `CS2UnlockedItem`. It accepts an optional `options` object which can include a `computeOdds` function. This function allows for custom logic in calculating the probability of receiving different rarity items when opening the container.

```typescript
unlockContainer(options?: {
  computeOdds?: (
    rarities: (
      | "common"
      | "uncommon"
      | "rare"
      | "mythical"
      | "legendary"
      | "ancient"
      | "immortal"
      | "special"
    )[],
  ) => number[] | undefined;
}): CS2UnlockedItem
```

--------------------------------

### CS2RaritySoundName Constants

Source: https://ianlucas.github.io/cs2-lib/variables/CS2RaritySoundName

Defines the CS2RaritySoundName object, mapping hexadecimal color codes to their respective CS:GO rarity names. This is used for identifying item rarities based on color.

```TypeScript
declare const CS2RaritySoundName: {
  "#4b69ff": "rare";
  "#5e98d9": "uncommon";
  "#8847ff": "mythical";
  "#b0c3d9": "common";
  "#d32ce6": "legendary";
  "#ded6cc": "common";
  "#e4ae39": "ancient";
  "#eb4b4b": "ancient";
};

// Example of type declaration for a specific rarity:
// declare const rare: Readonly<"rare">;
```

--------------------------------

### List CS2 Economy Item Contents

Source: https://ianlucas.github.io/cs2-lib/classes/CS2InventoryItem

Lists the contents of a CS2 economy item, optionally hiding special items. It returns an array of CS2EconomyItem objects. The `hideSpecials` parameter is an optional boolean defaulting to false.

```typescript
listContents(hideSpecials?: boolean): CS2EconomyItem[]
```

--------------------------------

### Check CS2 Item Type (isTool)

Source: https://ianlucas.github.io/cs2-lib/classes/CS2InventoryItem

Verifies if a CS2 item is a tool. Returns a boolean and takes no arguments.

```typescript
isTool(): boolean
```

--------------------------------

### CS2InventorySpec Property - data

Source: https://ianlucas.github.io/cs2-lib/interfaces/CS2InventorySpec

The data property of type CS2InventoryData contains the inventory data structure and content. This property holds all the actual inventory information for a CS2 inventory instance.

```typescript
data: CS2InventoryData
```

--------------------------------

### Check CS2 Item Type (isSouvenirCase)

Source: https://ianlucas.github.io/cs2-lib/classes/CS2InventoryItem

Determines if a CS2 item is a Souvenir Case. Returns a boolean, with no dependencies.

```typescript
isSouvenirCase(): boolean
```

--------------------------------

### Check CS2 Item Type (isStorageUnit)

Source: https://ianlucas.github.io/cs2-lib/classes/CS2InventoryItem

Determines if a CS2 item is a storage unit. Returns a boolean, with no dependencies.

```typescript
isStorageUnit(): boolean
```

--------------------------------

### Check CS2 Item Type (isWeaponCase)

Source: https://ianlucas.github.io/cs2-lib/classes/CS2InventoryItem

Determines if a CS2 item is a weapon case. Returns a boolean, with no dependencies.

```typescript
isWeaponCase(): boolean
```

--------------------------------

### Perform Random Map Selection in CS2Veto (TypeScript)

Source: https://ianlucas.github.io/cs2-lib/classes/CS2Veto

Executes a random map selection or action within the veto process. Returns a boolean indicating whether the random action was successful.

```typescript
random(): boolean;
```

--------------------------------

### CS2ItemTranslation Interface Definition (TypeScript)

Source: https://ianlucas.github.io/cs2-lib/interfaces/CS2ItemTranslation

Defines the structure for item translation data in CS2. It includes optional fields for categorization and descriptive text, and a mandatory name field.

```typescript
interface CS2ItemTranslation {
  category?: string;
  collectionDesc?: string;
  collectionName?: string;
  desc?: string;
  name: string;
  tournamentDesc?: string;
}
```

--------------------------------

### Unlock CS2 Container

Source: https://ianlucas.github.io/cs2-lib/classes/CS2InventoryItem

Unlocks a CS2 container, returning the item received. It accepts an optional options object that can include a function to compute odds based on rarity levels.

```typescript
unlockContainer(
options?: {
computeOdds?: (
rarities: (
| "common"
| "uncommon"
| "rare"
| "mythical"
| "legendary"
| "ancient"
| "immortal"
| "special"
)[],
) => number[]
| undefined;
}): CS2UnlockedItem
```

--------------------------------

### Check CS2 Item Type (isSticker)

Source: https://ianlucas.github.io/cs2-lib/classes/CS2InventoryItem

Verifies if a CS2 item is a sticker. Returns a boolean and takes no arguments.

```typescript
isSticker(): boolean
```

--------------------------------

### CS2ItemType Constants Declaration (TypeScript)

Source: https://ianlucas.github.io/cs2-lib/variables/CS2ItemType

Defines the CS2ItemType object, which is a collection of constants representing different item types in CS:GO 2. Each key maps to a string value representing the item's category. This object serves as a lookup for item types.

```typescript
const CS2ItemType = {
  Agent: "agent";
  Collectible: "collectible";
  Container: "case";
  Gloves: "glove";
  Graffiti: "graffiti";
  Key: "key";
  Keychain: "keychain";
  Melee: "melee";
  MusicKit: "musickit";
  Patch: "patch";
  Sticker: "sticker";
  Stub: "stub";
  Tool: "tool";
  Weapon: "weapon";
} as const;
```

--------------------------------

### Check CS2 Item Type (isPaintable)

Source: https://ianlucas.github.io/cs2-lib/classes/CS2InventoryItem

Verifies if a CS2 item is paintable. Returns a boolean and takes no arguments.

```typescript
isPaintable(): boolean
```

--------------------------------

### Check CS2 Item Type (isStickerCapsule)

Source: https://ianlucas.github.io/cs2-lib/classes/CS2InventoryItem

Checks if a CS2 item is a sticker capsule. This function returns a boolean and has no parameters.

```typescript
isStickerCapsule(): boolean
```

--------------------------------

### Check CS2 Item Type (isStatTrakSwapTool)

Source: https://ianlucas.github.io/cs2-lib/classes/CS2InventoryItem

Checks if a CS2 item is a StatTrak Swap Tool. This function returns a boolean and requires no arguments.

```typescript
isStatTrakSwapTool(): boolean
```

--------------------------------

### Check CS2 Item Type (isSMG)

Source: https://ianlucas.github.io/cs2-lib/classes/CS2InventoryItem

Verifies if a CS2 item is an SMG (Submachine Gun). Returns a boolean and takes no arguments.

```typescript
isSMG(): boolean
```

--------------------------------

### Check CS2 Item Type (isWeapon)

Source: https://ianlucas.github.io/cs2-lib/classes/CS2InventoryItem

Checks if a CS2 item is a weapon. This function returns a boolean and has no parameters.

```typescript
isWeapon(): boolean
```

--------------------------------

### Check CS2 Item Type (isPatch)

Source: https://ianlucas.github.io/cs2-lib/classes/CS2InventoryItem

Checks if a CS2 item is a patch. This function returns a boolean and has no parameters.

```typescript
isPatch(): boolean
```

--------------------------------

### Check CS2 Item Type (isStub)

Source: https://ianlucas.github.io/cs2-lib/classes/CS2InventoryItem

Checks if a CS2 item is a stub. This function returns a boolean and requires no arguments.

```typescript
isStub(): boolean
```

--------------------------------

### CS2RarityColorName Type Declaration (TypeScript)

Source: https://ianlucas.github.io/cs2-lib/variables/CS2RarityColorName

Provides the TypeScript type declaration for the CS2RarityColorName constant. It specifies that the keys are readonly hexadecimal color strings and the values are readonly rarity name strings. This ensures type safety when working with the constant.

```typescript
declare const CS2RarityColorName: Readonly<Record<string, Readonly<string>>>;

// Specifically for the defined values:
type CS2RarityColorName = {
  readonly "#4b69ff": "rare";
  readonly "#5e98d9": "uncommon";
  readonly "#8847ff": "mythical";
  readonly "#b0c3d9": "common";
  readonly "#d32ce6": "legendary";
  readonly "#ded6cc": "common";
  readonly "#e4ae39": "immortal";
  readonly "#eb4b4b": "ancient";
};
```

--------------------------------

### Check CS2 Item Type (isPistol)

Source: https://ianlucas.github.io/cs2-lib/classes/CS2InventoryItem

Determines if a CS2 item is a pistol. Returns a boolean, with no dependencies.

```typescript
isPistol(): boolean
```

--------------------------------

### CS2RarityColorOrder Constant Definition (TypeScript)

Source: https://ianlucas.github.io/cs2-lib/variables/CS2RarityColorOrder

Defines the CS2RarityColorOrder constant, which is a mapping of hexadecimal color strings to numerical rarity levels. This constant is used to establish a specific order for displaying rarity colors.

```typescript
const CS2RarityColorOrder: Readonly<Record<string, number>> = {
  "#4b69ff": 3,
  "#5e98d9": 2,
  "#8847ff": 4,
  "#b0c3d9": 1,
  "#d32ce6": 5,
  "#ded6cc": 1,
  "#e4ae39": 7,
  "#eb4b4b": 6
};

// Type declaration examples:
// CS2RarityColorOrder["#4b69ff"]; // Type: 3 (Readonly)
// CS2RarityColorOrder["#5e98d9"]; // Type: 2 (Readonly)
// CS2RarityColorOrder["#8847ff"]; // Type: 4 (Readonly)
// CS2RarityColorOrder["#b0c3d9"]; // Type: 1 (Readonly)
// CS2RarityColorOrder["#d32ce6"]; // Type: 5 (Readonly)
// CS2RarityColorOrder["#ded6cc"]; // Type: 1 (Readonly)
// CS2RarityColorOrder["#e4ae39"]; // Type: 7 (Readonly)
// CS2RarityColorOrder["#eb4b4b"]; // Type: 6 (Readonly)
```

--------------------------------

### Define CS2UnlockedItem TypeScript Interface

Source: https://ianlucas.github.io/cs2-lib/interfaces/CS2UnlockedItem

TypeScript interface defining the structure of an unlocked CS2 item. Contains required properties for item identification (id, rarity, special) and an attributes object with container reference and optional cosmetic properties. Used for representing item state in Counter-Strike 2 inventory systems.

```typescript
interface CS2UnlockedItem {
  attributes: {
    containerId: number;
    seed: number | undefined;
    statTrak: number | undefined;
    wear: number | undefined;
  };
  id: number;
  rarity: CS2RaritySoundNameValues;
  special: boolean;
}
```

--------------------------------

### CS2UnlockedItem Attributes Object Structure

Source: https://ianlucas.github.io/cs2-lib/interfaces/CS2UnlockedItem

Defines the nested attributes object within CS2UnlockedItem containing container reference and optional cosmetic item properties. The containerId links to a specific container, while seed, statTrak, and wear are optional numeric values for item customization and tracking.

```typescript
attributes: {
  containerId: number;
  seed: number | undefined;
  statTrak: number | undefined;
  wear: number | undefined;
}
```

--------------------------------

### Check CS2 Item Type (isSniperRifle)

Source: https://ianlucas.github.io/cs2-lib/classes/CS2InventoryItem

Checks if a CS2 item is a sniper rifle. This function returns a boolean and has no parameters.

```typescript
isSniperRifle(): boolean
```

--------------------------------

### CS2RarityColorName Constant Definition (JavaScript)

Source: https://ianlucas.github.io/cs2-lib/variables/CS2RarityColorName

Defines the CS2RarityColorName constant, which is an object mapping hexadecimal color strings to their corresponding CS2 rarity names. This object is intended to be read-only. It provides a direct lookup for rarity names based on their associated color codes.

```javascript
const CS2RarityColorName = {
  "#4b69ff": "rare",
  "#5e98d9": "uncommon",
  "#8847ff": "mythical",
  "#b0c3d9": "common",
  "#d32ce6": "legendary",
  "#ded6cc": "common",
  "#e4ae39": "immortal",
  "#eb4b4b": "ancient"
};
```

--------------------------------

### Check CS2 Item Type (isNameTag)

Source: https://ianlucas.github.io/cs2-lib/classes/CS2InventoryItem

Determines if a CS2 item is a Name Tag. This is a simple boolean check with no input requirements.

```typescript
isNameTag(): boolean
```

--------------------------------

### Check CS2 Item Type (isMelee)

Source: https://ianlucas.github.io/cs2-lib/classes/CS2InventoryItem

Checks if a CS2 item is a melee weapon. This function typically returns a boolean value and has no parameters or dependencies.

```typescript
isMelee(): boolean
```

--------------------------------

### Check CS2 Item Type (isRifle)

Source: https://ianlucas.github.io/cs2-lib/classes/CS2InventoryItem

Checks if a CS2 item is a rifle. This function returns a boolean and requires no arguments.

```typescript
isRifle(): boolean
```

--------------------------------

### CS2RarityColor Constant Definition (TypeScript)

Source: https://ianlucas.github.io/cs2-lib/variables/CS2RarityColor

Defines a constant object CS2RarityColor containing hexadecimal color codes for various CS2 item rarities. This is a readonly object, ensuring its properties cannot be modified after initialization.

```typescript
const CS2RarityColor: Readonly<Record<string, string>> = {
  Ancient: "#eb4b4b",
  Common: "#b0c3d9",
  Default: "#ded6cc",
  Immortal: "#e4ae39",
  Legendary: "#d32ce6",
  Mythical: "#8847ff",
  Rare: "#4b69ff",
  Uncommon: "#5e98d9"
};
```

--------------------------------

### CS2ItemType Readonly Type Declaration (TypeScript)

Source: https://ianlucas.github.io/cs2-lib/variables/CS2ItemType

Declares a readonly type for each CS2ItemType constant. This ensures that once an item type is assigned, it cannot be modified, providing type safety and immutability for item categorization within the application.

```typescript
type ReadonlyAgent = "agent";
type ReadonlyCollectible = "collectible";
type ReadonlyContainer = "case";
type ReadonlyGloves = "glove";
type ReadonlyGraffiti = "graffiti";
type ReadonlyKey = "key";
type ReadonlyKeychain = "keychain";
type ReadonlyMelee = "melee";
type ReadonlyMusicKit = "musickit";
type ReadonlyPatch = "patch";
type ReadonlySticker = "sticker";
type ReadonlyStub = "stub";
type ReadonlyTool = "tool";
type ReadonlyWeapon = "weapon";
```

--------------------------------

### Define CS2Rarity constant in TypeScript

Source: https://ianlucas.github.io/cs2-lib/variables/CS2Rarity

Declares a readonly constant object containing seven rarity levels for CS2 items. Each property is a readonly string literal representing a specific rarity tier. This constant is typically used for type-safe rarity comparisons and item classification in CS2 applications.

```typescript
const CS2Rarity = {
  Ancient: "ancient",
  Common: "common",
  Immortal: "immortal",
  Legendary: "legendary",
  Mythical: "mythical",
  Rare: "rare",
  Uncommon: "uncommon"
} as const;
```
Tokens:
Raw