CS2 Inspect Library

A comprehensive TypeScript library for encoding and decoding Counter-Strike 2 inspect URLs with full protobuf support, Steam client integration, validation, and error handling.

Table of Contents

• Features
• Installation
• Quick Start
• Documentation
• API Reference
• Configuration
• Error Handling
• CLI Usage
• Steam Client Integration
• Examples
• Testing
• Contributing
• License

Features

• Performance Optimized - Static methods for maximum performance without instance creation
• Complete Protobuf Support - Full implementation of CEconItemPreviewDataBlock message
• Direct Protobuf Access - Direct decodeMaskedData() for fastest possible decoding
• Steam Client Integration - Support for unmasked URLs via Steam's Game Coordinator
• Dual URL Support - Handle both masked (protobuf) and unmasked (community market/inventory) URLs
• Input Validation - Comprehensive validation with detailed error messages
• Error Handling - Robust error handling with custom error types
• TypeScript Support - Full TypeScript support with comprehensive type definitions
• CLI Tool - Command-line interface with Steam client support
• Unit Tests - Comprehensive test coverage including Steam client functionality
• WeaponPaint Enum - Comprehensive enum with 1,800+ CS2 skin definitions and weapon-specific naming
• Latest CS2 Fields - Support for all CS2 fields including highlight_reel, style, variations, upgrade_level
• BigInt Support - Proper handling of 64-bit integers
• Signed Integer Support - Correct handling of signed int32 fields like entindex
• Rate Limiting - Built-in rate limiting for Steam API calls
• Queue Management - Automatic queue management for Steam inspection requests

Installation

npm install cs2-inspect-lib

For global CLI usage:

npm install -g cs2-inspect-lib

Quick Start

Performance-First Approach

import {
  // Fastest - Static methods (no instance creation)
  decodeMaskedData,
  analyzeUrl,
  requiresSteamClient,
  // Fast - Convenience functions
  createInspectUrl,
  inspectItem,
  // Standard - Instance methods
  CS2Inspect,
  WeaponType,
  WeaponPaint,
  ItemRarity
} from 'cs2-inspect-lib';

// FASTEST - Direct hex data decoding
const hexData = "001807A8B4C5D6E7F8..."; // Raw protobuf hex
const item = decodeMaskedData(hexData); // Instant decoding

// FAST - Static URL analysis (no instance needed)
const analyzed = analyzeUrl(url);
console.log(analyzed.url_type); // 'masked' or 'unmasked'
console.log(analyzed.hex_data); // Hex data if available

// Quick Steam client requirement check
const needsSteam = requiresSteamClient(url);

Basic Usage

import { CS2Inspect, WeaponType, WeaponPaint, ItemRarity } from 'cs2-inspect-lib';

const cs2 = new CS2Inspect();

// Create an inspect URL
const item = {
  defindex: WeaponType.AK_47,
  paintindex: WeaponPaint.AK_47_FIRE_SERPENT, // Clear weapon + skin naming
  paintseed: 661,
  paintwear: 0.15,
  rarity: ItemRarity.COVERT,
  stickers: [
    {
      slot: 0,
      sticker_id: 1,
      wear: 0.1,
      highlight_reel: 1
    }
  ],
  style: 5,
  upgrade_level: 3
};

const url = cs2.createInspectUrl(item);
console.log(url);

// Universal inspection (works with any URL type)
const decoded = await cs2.inspectItem(url);
console.log(decoded);

Optimized Convenience Functions

import {
  createInspectUrl,
  inspectItem,
  decodeMaskedUrl,
  analyzeUrl
} from 'cs2-inspect-lib';

// Create URL
const url = createInspectUrl(item);

// Universal inspection (auto-detects URL type)
const decoded = await inspectItem(url);

// Fast masked-only decoding
const maskedItem = decodeMaskedUrl(maskedUrl);

// Quick URL analysis
const analysis = analyzeUrl(url);

With Validation

import { CS2Inspect, validateItem } from 'cs2-inspect-lib';

// Validate an item before encoding
const validation = validateItem(item);
if (!validation.valid) {
  console.error('Validation errors:', validation.errors);
  if (validation.warnings) {
    console.warn('Warnings:', validation.warnings);
  }
}

// Configure validation settings
const cs2 = new CS2Inspect({
  validateInput: true,
  maxCustomNameLength: 50,
  enableLogging: true
});

Documentation

📖 Full API Documentation

The complete API documentation is available online, including:

• Detailed class and method documentation
• Type definitions and interfaces
• Usage examples and best practices
• Advanced configuration options

API Reference

Performance Tiers

Fastest - Static Methods (No Instance Creation)

import {
  decodeMaskedData,
  analyzeUrl,
  requiresSteamClient,
  isValidUrl,
  normalizeUrl,
  validateUrl,
  validateItem
} from 'cs2-inspect-lib';

// Direct protobuf decoding - FASTEST possible method
decodeMaskedData(hexData: string, config?: CS2InspectConfig): EconItem

// URL analysis without instance creation
analyzeUrl(url: string, config?: CS2InspectConfig): AnalyzedInspectURL
requiresSteamClient(url: string, config?: CS2InspectConfig): boolean
isValidUrl(url: string, config?: CS2InspectConfig): boolean
normalizeUrl(url: string, config?: CS2InspectConfig): string

// Validation without instance creation
validateUrl(url: string): ValidationResult
validateItem(item: any): ValidationResult

Fast - Convenience Functions

import {
  createInspectUrl,
  inspectItem,
  decodeMaskedUrl
} from 'cs2-inspect-lib';

// Universal functions with automatic Steam client handling
createInspectUrl(item: EconItem, config?: CS2InspectConfig): string
inspectItem(url: string, config?: CS2InspectConfig): Promise<EconItem | SteamInspectResult>
decodeMaskedUrl(url: string, config?: CS2InspectConfig): EconItem

Standard - Instance Methods

CS2Inspect

Main API class for encoding and decoding inspect URLs.

const cs2 = new CS2Inspect(config?: CS2InspectConfig);

// Core Methods
cs2.createInspectUrl(item: EconItem): string
cs2.decodeMaskedUrl(url: string): EconItem          // NEW: Clear naming
cs2.inspectItem(url: string): Promise<EconItem | SteamInspectResult>  // NEW: Universal method
cs2.analyzeUrl(url: string): AnalyzedInspectURL
cs2.validateItem(item: any): ValidationResult
cs2.validateUrl(url: string): ValidationResult
cs2.normalizeUrl(url: string): string

// Deprecated (still work, but use new methods above)
cs2.decodeInspectUrl(url: string): EconItem         // Use decodeMaskedUrl()
cs2.decodeInspectUrlAsync(url: string): Promise<EconItem | SteamInspectResult>  // Use inspectItem()
cs2.isValidUrl(url: string): boolean                // Use analyzeUrl() + try/catch

// Steam Client Methods
cs2.initializeSteamClient(): Promise<void>
cs2.isSteamClientReady(): boolean
cs2.getSteamClientStats(): SteamClientStats
cs2.requiresSteamClient(url: string): boolean
cs2.connectToServer(serverAddress: string): Promise<void>
cs2.disconnectSteamClient(): Promise<void>

// Configuration
cs2.updateConfig(newConfig: Partial<CS2InspectConfig>): void
cs2.getConfig(): Required<CS2InspectConfig>

Method Selection Guide

Use decodeMaskedData() when:

• You have raw hex protobuf data
• You want maximum performance
• You're processing many items in batch
• You don't need URL parsing overhead

import { decodeMaskedData } from 'cs2-inspect-lib';
const item = decodeMaskedData('001807A8B4C5D6E7F8...');

Use static methods when:

• You want to avoid instance creation overhead
• You're doing simple operations (analysis, validation)
• You're building high-performance applications

import { analyzeUrl, requiresSteamClient } from 'cs2-inspect-lib';
const analysis = analyzeUrl(url);
const needsSteam = requiresSteamClient(url);

Use inspectItem() when:

• You're not sure what URL type you'll receive
• You want one method that handles everything
• You're building user-facing applications

import { inspectItem } from 'cs2-inspect-lib';
const item = await inspectItem(anyUrl); // Works with masked or unmasked

Use instance methods when:

• You need complex workflows
• You're managing Steam client state
• You need custom configuration per instance

const cs2 = new CS2Inspect({ enableLogging: true });
await cs2.initializeSteamClient();
const item = await cs2.inspectItem(url);

Core Types

WeaponPaint

Comprehensive enum with 1800+ weapon paint indices generated from CS2 skins database:

enum WeaponPaint {
  VANILLA = 0,
  
  // AK-47 Skins (weapon-specific naming)
  AK_47_FIRE_SERPENT = 180,
  AK_47_REDLINE = 282,
  AK_47_VULCAN = 300,
  AK_47_CASE_HARDENED = 44,
  AK_47_WASTELAND_REBEL = 380,
  
  // AWP Skins
  AWP_DRAGON_LORE = 344,
  AWP_MEDUSA = 425,
  AWP_LIGHTNING_STRIKE = 179,
  AWP_ASIIMOV = 279,
  AWP_HYPER_BEAST = 446,
  
  // M4A4 Skins
  M4A4_HOWL = 309,
  M4A4_ASIIMOV = 255,
  M4A4_DRAGON_KING = 360,
  M4A4_DESOLATE_SPACE = 584,
  
  // Knife Skins (weapon-specific variants)
  KARAMBIT_DOPPLER = 417,
  KARAMBIT_MARBLE_FADE = 413,
  KARAMBIT_TIGER_TOOTH = 409,
  BAYONET_DOPPLER = 417,
  BAYONET_MARBLE_FADE = 413,
  
  // Glove Skins
  SPORT_GLOVES_PANDORAS_BOX = 10037,
  SPECIALIST_GLOVES_CRIMSON_KIMONO = 10033,
  
  // ... 1800+ total paint definitions covering all CS2 skins
}

Utility Functions:

// Get paint name from index
getPaintName(paintIndex: number): string | undefined

// Get paint index from name
getPaintIndex(paintName: string): number | undefined

// Type guard
isWeaponPaint(value: any): value is WeaponPaint

// Get all available paints
getAllPaintNames(): string[]
getAllPaintIndices(): number[]

EconItem

Complete item data structure matching CS2's CEconItemPreviewDataBlock:

interface EconItem {
  // Required fields
  defindex: number | WeaponType;
  paintindex: number | WeaponPaint;
  paintseed: number;
  paintwear: number;
  
  // Optional fields
  accountid?: number;
  itemid?: number | bigint;
  rarity?: ItemRarity | number;
  quality?: number;
  killeaterscoretype?: number;
  killeatervalue?: number;
  customname?: string;
  inventory?: number;
  origin?: number;
  questid?: number;
  dropreason?: number;
  musicindex?: number;
  entindex?: number;
  petindex?: number;
  
  // Array fields
  stickers?: Sticker[];
  keychains?: Sticker[];
  variations?: Sticker[];
  
  // CS2 specific fields
  style?: number;
  upgrade_level?: number;
}

Sticker

Sticker/keychain/variation data structure:

interface Sticker {
  slot: number;
  sticker_id: number;
  wear?: number;
  scale?: number;
  rotation?: number;
  tint_id?: number;
  offset_x?: number;
  offset_y?: number;
  offset_z?: number;
  pattern?: number;
  highlight_reel?: number;
}

Configuration

interface CS2InspectConfig {
  validateInput?: boolean; // Default: true
  maxUrlLength?: number; // Default: 2048
  maxCustomNameLength?: number; // Default: 100
  enableLogging?: boolean; // Default: false
  steamClient?: SteamClientConfig;
}

interface SteamClientConfig {
  enabled?: boolean; // Default: false
  username?: string;
  password?: string;
  apiKey?: string; // Optional
  rateLimitDelay?: number; // Default: 1500ms
  maxQueueSize?: number; // Default: 100
  requestTimeout?: number; // Default: 10000ms
  queueTimeout?: number; // Default: 30000ms
  serverAddress?: string; // Optional
}

Error Handling

The library provides comprehensive error handling with custom error types:

import {
  CS2InspectError,
  ValidationError,
  EncodingError,
  DecodingError,
  SteamConnectionError,
  SteamAuthenticationError,
  SteamTimeoutError,
  SteamQueueFullError,
  SteamNotReadyError,
  SteamInspectionError
} from 'cs2-inspect-lib';

try {
  const url = cs2.createInspectUrl(item);
} catch (error) {
  if (error instanceof ValidationError) {
    console.error('Validation failed:', error.message);
    console.error('Context:', error.context);
  } else if (error instanceof EncodingError) {
    console.error('Encoding failed:', error.message);
  }
}

CLI Usage

The library includes a powerful command-line tool:

# Decode a masked inspect URL (protobuf data)
cs2inspect decode "steam://rungame/730/76561202255233023/+csgo_econ_action_preview%20..."

# Decode an unmasked URL (requires Steam credentials)
cs2inspect decode "steam://rungame/730/76561202255233023/+csgo_econ_action_preview%20S76561198123456789A987654321D456789123" \
  --enable-steam --steam-username your_username --steam-password your_password

# Create an inspect URL
cs2inspect encode --weapon AK_47 --paint 44 --seed 661 --float 0.15

# Validate an inspect URL
cs2inspect validate "steam://rungame/730/76561202255233023/+csgo_econ_action_preview%20..."

# Get URL information
cs2inspect info "steam://rungame/730/76561202255233023/+csgo_econ_action_preview%20..."

For complete CLI documentation, run:

cs2inspect --help

Steam Client Integration

The library supports two types of inspect URLs with optimized detection:

URL Type Detection (Static Method)

import { analyzeUrl, requiresSteamClient } from 'cs2-inspect-lib';

// Fast static analysis - no instance creation
const analysis = analyzeUrl(url);
console.log(analysis.url_type); // 'masked' or 'unmasked'

// Quick Steam client requirement check
const needsSteam = requiresSteamClient(url); // Optimized static method

Masked URLs (Protobuf Data)

These contain encoded item data and can be decoded instantly offline:

steam://rungame/730/76561202255233023/+csgo_econ_action_preview%20001807A8...

import { decodeMaskedData, decodeMaskedUrl } from 'cs2-inspect-lib';

// FASTEST - Direct hex data decoding
const item1 = decodeMaskedData('001807A8B4C5D6E7F8...');

// Fast - URL parsing + decoding
const item2 = decodeMaskedUrl(maskedUrl);

Unmasked URLs (Community Market/Inventory Links)

These reference items in Steam's database and require Steam client authentication:

Market Listing:

steam://rungame/730/76561202255233023/+csgo_econ_action_preview%20M123456789A987654321D456789123

Inventory Item:

steam://rungame/730/76561202255233023/+csgo_econ_action_preview%20S76561198123456789A987654321D456789123

Universal Inspection (Recommended)

import { inspectItem } from 'cs2-inspect-lib';

// Works with ANY URL type - automatically detects and handles
const item = await inspectItem(anyUrl); // Masked or unmasked

Steam Client Configuration

import { CS2Inspect } from 'cs2-inspect-lib';

// Configure with Steam client support
const cs2 = new CS2Inspect({
  steamClient: {
    enabled: true,
    username: 'your_steam_username',
    password: 'your_steam_password',
    rateLimitDelay: 1500, // ms between requests
    maxQueueSize: 100,
    requestTimeout: 30000, // 30 second timeout
    enableLogging: false
  }
});

// Initialize Steam client
await cs2.initializeSteamClient();

// Universal inspection - works with any URL type
const item = await cs2.inspectItem(anyUrl);

// Get Steam client status
const stats = cs2.getSteamClientStats();
console.log('Steam client status:', stats.status);
console.log('Queue length:', stats.queueLength);

Environment Variables

For security, you can use environment variables instead of hardcoding credentials:

export STEAM_USERNAME=your_username
export STEAM_PASSWORD=your_password

const cs2 = new CS2Inspect({
  steamClient: {
    enabled: true,
    username: process.env.STEAM_USERNAME,
    password: process.env.STEAM_PASSWORD
  }
});

Examples

Performance-Optimized Examples

Maximum Performance - Direct Hex Decoding

import { decodeMaskedData } from 'cs2-inspect-lib';

// FASTEST - Direct protobuf decoding from hex data
const hexData = "001807A8B4C5D6E7F8..."; // Raw protobuf hex
const item = decodeMaskedData(hexData); // Instant decoding, zero overhead

console.log(`Weapon: ${item.defindex}, Paint: ${item.paintindex}`);

Fast Static Analysis

import { analyzeUrl, requiresSteamClient, isValidUrl } from 'cs2-inspect-lib';

// Fast URL analysis without instance creation
const analysis = analyzeUrl(url);
console.log(`URL Type: ${analysis.url_type}`); // 'masked' or 'unmasked'
console.log(`Has Hex Data: ${!!analysis.hex_data}`);

// Quick checks
const needsSteam = requiresSteamClient(url); // Fast static check
const isValid = isValidUrl(url); // Fast validation

Universal Inspection (Recommended)

import { inspectItem, createInspectUrl } from 'cs2-inspect-lib';

// Create URL
const item = {
  defindex: WeaponType.AK_47,
  paintindex: WeaponPaint.AK_47_FIRE_SERPENT,
  paintseed: 661,
  paintwear: 0.15,
  rarity: ItemRarity.COVERT
};

const url = createInspectUrl(item);

// Universal inspection - works with any URL type
const decoded = await inspectItem(url); // Auto-detects masked/unmasked
console.log(decoded);

Using WeaponPaint Enum

import { CS2Inspect, WeaponType, WeaponPaint, ItemRarity, getPaintName } from 'cs2-inspect-lib';

const cs2 = new CS2Inspect();

// Create items using comprehensive WeaponPaint enum with clear weapon + skin naming
const akFireSerpent = {
  defindex: WeaponType.AK_47,
  paintindex: WeaponPaint.AK_47_FIRE_SERPENT, // Much clearer than using 180
  paintseed: 661,
  paintwear: 0.15,
  rarity: ItemRarity.COVERT
};

const awpDragonLore = {
  defindex: WeaponType.AWP,
  paintindex: WeaponPaint.AWP_DRAGON_LORE, // Much clearer than using 344
  paintseed: 420,
  paintwear: 0.07,
  rarity: ItemRarity.COVERT
};

// Create inspect URLs
const akUrl = cs2.createInspectUrl(akFireSerpent);
const awpUrl = cs2.createInspectUrl(awpDragonLore);

// Fast masked URL decoding
const decoded = cs2.decodeMaskedUrl(akUrl); // New clear method name
console.log(`Paint: ${getPaintName(decoded.paintindex as number)}`);
```### Complete Item with All Fields

```typescript
const complexItem: EconItem = {
  accountid: 123456789,
  itemid: BigInt('9876543210'),
  defindex: WeaponType.AWP,
  paintindex: WeaponPaint.AWP_DRAGON_LORE, // Clear weapon + skin naming
  rarity: ItemRarity.COVERT,
  quality: 4,
  paintwear: 0.15,
  paintseed: 420,
  killeaterscoretype: 1,
  killeatervalue: 1337,
  customname: 'Dragon Lore',
  stickers: [
    {
      slot: 0,
      sticker_id: 5032,
      wear: 0.15,
      scale: 1.2,
      rotation: 45.0,
      tint_id: 1,
      offset_x: 0.1,
      offset_y: -0.1,
      offset_z: 0.05,
      pattern: 10,
      highlight_reel: 1
    }
  ],
  keychains: [
    {
      slot: 0,
      sticker_id: 20,
      pattern: 148,
      highlight_reel: 2
    }
  ],
  style: 7,
  variations: [
    {
      slot: 0,
      sticker_id: 100,
      pattern: 50,
      highlight_reel: 3
    }
  ],
  upgrade_level: 10,
  entindex: -1
};

const url = createInspectUrl(complexItem);
const decoded = decodeInspectUrl(url);

Error Handling Example

import { CS2Inspect, ValidationError, DecodingError } from 'cs2-inspect-lib';

const cs2 = new CS2Inspect({ validateInput: true });

try {
  const item = {
    defindex: -1, // Invalid
    paintindex: 44,
    paintseed: 661,
    paintwear: 1.5 // Invalid
  };
  
  const url = cs2.createInspectUrl(item);
} catch (error) {
  if (error instanceof ValidationError) {
    console.error('Validation errors:');
    error.context?.errors?.forEach(err => console.error(`  - ${err}`));
    
    if (error.context?.warnings) {
      console.warn('Warnings:');
      error.context.warnings.forEach(warn => console.warn(`  - ${warn}`));
    }
  }
}

Running Test Examples

The library includes comprehensive test examples:

# Run all tests
npm run example

# Run individual tests
npx ts-node examples/basic-usage.ts basic     # Basic item creation
npx ts-node examples/basic-usage.ts complex   # Complex items with stickers
npx ts-node examples/basic-usage.ts steam     # Steam client integration
npx ts-node examples/basic-usage.ts debug "real_url_here"  # Debug mode

Testing

# Run tests
npm test

# Run tests with coverage
npm run test:coverage

# Run tests in watch mode
npm run test:watch

Development

# Clone the repository
git clone https://github.com/sak0a/cs2-inspect-lib.git
cd cs2-inspect-lib

# Install dependencies
npm install

# Build the project
npm run build

# Generate documentation
npm run docs

# Run in development mode
npm run dev

# Lint code
npm run lint
npm run lint:fix

Contributing

Contributions are welcome! Please read our contributing guidelines and submit pull requests to our repository.

Development Setup

1. Fork the repository
2. Clone your fork: git clone https://github.com/sak0a/cs2-inspect-lib.git
3. Install dependencies: npm install
4. Create a feature branch: git checkout -b feature/your-feature-name
5. Make your changes and add tests
6. Run tests: npm test
7. Build the project: npm run build
8. Submit a pull request

Troubleshooting

Steam Client Issues

Connection Timeouts:

# Enable debug mode to see where the process stops
npx ts-node examples/basic-usage.ts debug "your_real_url_here"

Authentication Failures:

• Verify Steam credentials are correct
• Check if Steam Guard is enabled on your account
• Ensure your account owns CS2

Invalid URL Errors:

• Ensure you're using real URLs from Steam Community Market or CS2 inventory
• Example URLs in documentation are placeholders and will timeout

Debug Mode

Enable comprehensive logging to troubleshoot issues:

const cs2 = new CS2Inspect({
  enableLogging: true,
  steamClient: {
    enabled: true,
    username: 'your_username',
    password: 'your_password',
    enableLogging: true, // Steam client debug logging
    requestTimeout: 60000 // Extended timeout for debugging
  }
});

Performance Benefits & Migration

Performance Improvements

The library now offers 3 performance tiers:

1. Static Methods - Up to 90% faster for simple operations
2. Convenience Functions - 50% faster with automatic optimizations
3. Instance Methods - Standard performance with full feature set

Benchmarks

| Operation | Old Method | New Method | Performance Gain | |-----------|------------|------------|------------------| | URL Analysis | new CS2Inspect().analyzeUrl() | analyzeUrl() | ~90% faster | | Steam Check | new CS2Inspect().requiresSteamClient() | requiresSteamClient() | ~85% faster | | Hex Decoding | new CS2Inspect().decodeInspectUrl() | decodeMaskedData() | ~95% faster | | Validation | new CS2Inspect().isValidUrl() | isValidUrl() | ~80% faster |

Migration Guide

Old Code → New Optimized Code

// OLD - Creates unnecessary instances
const cs2 = new CS2Inspect();
const analysis = cs2.analyzeUrl(url);
const needsSteam = cs2.requiresSteamClient(url);
const isValid = cs2.isValidUrl(url);

// NEW - Optimized static methods
import { analyzeUrl, requiresSteamClient, isValidUrl } from 'cs2-inspect-lib';
const analysis = analyzeUrl(url);        // 90% faster
const needsSteam = requiresSteamClient(url); // 85% faster
const isValid = isValidUrl(url);         // 80% faster

// OLD - Confusing method names
const item1 = cs2.decodeInspectUrl(url);      // Only works with masked
const item2 = await cs2.decodeInspectUrlAsync(url); // Works with both

// NEW - Clear method names
const item1 = cs2.decodeMaskedUrl(url);       // Clear: masked only
const item2 = await cs2.inspectItem(url);     // Clear: universal method

Changelog

v3.1.0 (Latest) - Performance & Clarity Update

• Performance Optimizations: Added static methods for up to 90% performance improvement
• Direct Protobuf Access: decodeMaskedData() for fastest possible decoding
• Clear Method Names: decodeMaskedUrl() and inspectItem() for better clarity
• Static Functions: analyzeUrl(), requiresSteamClient(), isValidUrl() without instance creation
• Method Selection Guide: Clear guidance on when to use each method for optimal performance
• Enhanced Documentation: Comprehensive performance tiers and migration guide
• Backward Compatible: All old methods still work with deprecation notices

v3.0.6

• Updated README.md

v3.0.5

• WeaponPaint Enum: Comprehensive enum with 1,800+ CS2 skin definitions generated from skins.json
• Smart Naming: Weapon-specific paint naming (e.g., AK_47_FIRE_SERPENT, AWP_DRAGON_LORE, KARAMBIT_DOPPLER)
• Type Safety: Updated EconItem.paintindex to accept WeaponPaint | number for full TypeScript support
• Utility Functions: Added getPaintName(), getPaintIndex(), isWeaponPaint(), getAllPaintNames(), getAllPaintIndices()
• Comprehensive Coverage: All weapon categories including rifles, pistols, knives, gloves, and SMGs
• Auto-Generation: Script to regenerate enum from updated skins.json data
• Full Testing: 16 comprehensive tests covering all WeaponPaint functionality
• Professional Documentation: Updated README with WeaponPaint examples and API reference
• Backward Compatible: Maintains compatibility with numeric paint indices

v3.0.4

• Enhanced documentation and professional README
• Improved error handling and validation
• Updated TypeScript definitions
• Performance optimizations

v2.1.0

• Steam Client Integration: Full support for unmasked URLs
• Debug Mode: Comprehensive logging for troubleshooting
• Enhanced Test Suite: Individual test functions with debug capabilities
• Connection Reuse: Intelligent Steam client connection management
• Extended CLI: Steam client commands and debug options

v2.0.0

• Complete rewrite with enhanced error handling
• Added support for all new CS2 protobuf fields
• Comprehensive input validation
• CLI tool with full feature set
• 100% TypeScript with full type definitions

License

MIT License - see LICENSE file for details.

Support

If you encounter any issues or have questions:

1. Check the documentation
2. Search existing issues
3. Create a new issue with detailed information

Acknowledgments

• Original Python implementation inspiration
• CS2 community for protobuf research and documentation
• Steam API documentation and community reverse engineering efforts