@rlajous/sdk-threat 1.0.0

package/dist/types/resources/addresses.d.ts

@@ -0,0 +1,131 @@
+import { HttpClient, Chain } from '@rlajous/sdk-core';
+import { AddressRiskResponse, SanctionedResponse, PoisoningResponse, AddressAnalysisOptions, SanctionsOptions, PoisoningOptions } from '../types';
+/**
+ * Resource for address risk analysis
+ *
+ * Provides comprehensive security analysis for blockchain addresses including:
+ * - Overall risk scoring
+ * - Risk categorization and tagging
+ * - Sanctions screening
+ * - Address poisoning detection
+ * - Fund flow analysis
+ *
+ * @example
+ * ```typescript
+ * // Analyze an address
+ * const risk = await client.addresses.analyze('0x...', { chain: Chain.ETH });
+ *
+ * // Check sanctions
+ * const sanctioned = await client.addresses.checkSanctioned('0x...', { chain: Chain.ETH });
+ *
+ * // With default chain configured, chain can be omitted
+ * const client = new ThreatClient({ apiKey: '...', defaultChain: Chain.ETH });
+ * const risk = await client.addresses.analyze('0x...'); // Uses ETH
+ * ```
+ */
+export declare class AddressesResource {
+    private readonly httpClient;
+    private readonly defaultChain?;
+    constructor(httpClient: HttpClient, defaultChain?: Chain | undefined);
+    /**
+     * Resolve the chain to use for a request
+     * @throws ValidationError if no chain is specified and no default is set
+     */
+    private resolveChain;
+    /**
+     * Validate address format for the given chain
+     * @throws ValidationError if address format is invalid for the chain
+     */
+    private validateAddress;
+    /**
+     * Analyze an address for security risks
+     *
+     * Returns comprehensive risk analysis including:
+     * - Overall risk score (0-100)
+     * - Risk tags and categories
+     * - Detailed analysis data (optional)
+     * - Deployer risk for contracts (optional)
+     *
+     * @param address - Address to analyze
+     * @param options - Analysis options (chain is optional if defaultChain is set)
+     * @returns Address risk analysis result
+     *
+     * @example
+     * ```typescript
+     * // Basic analysis
+     * const risk = await client.addresses.analyze('0x742d35Cc...', {
+     *   chain: Chain.ETH,
+     * });
+     * console.log(`Risk score: ${risk.overallRisk}`);
+     *
+     * // With default chain, options can be omitted
+     * const risk = await client.addresses.analyze('0x742d35Cc...');
+     *
+     * // With specific modules
+     * const risk = await client.addresses.analyze('0x...', {
+     *   chain: Chain.ETH,
+     *   modules: [RiskModule.SANCTIONS_COMPLIANCE, RiskModule.FUND_FLOW_SCREENING],
+     * });
+     *
+     * // With detailed response and deployer risk
+     * const risk = await client.addresses.analyze('0x...', {
+     *   chain: Chain.ETH,
+     *   detailed: true,
+     *   deployerRisk: true,
+     * });
+     * ```
+     */
+    analyze(address: string, options?: AddressAnalysisOptions): Promise<AddressRiskResponse>;
+    /**
+     * Check if an address is sanctioned
+     *
+     * Screens the address against known sanctions lists including OFAC.
+     *
+     * @param address - Address to check
+     * @param options - Request options (chain is optional if defaultChain is set)
+     * @returns Sanctions check result
+     *
+     * @example
+     * ```typescript
+     * const result = await client.addresses.checkSanctioned('0x...', {
+     *   chain: Chain.ETH,
+     * });
+     *
+     * // With default chain configured
+     * const result = await client.addresses.checkSanctioned('0x...');
+     *
+     * if (result.is_sanctioned) {
+     *   console.error('Address is sanctioned!');
+     *   console.log('Details:', result.sanction_details);
+     * }
+     * ```
+     */
+    checkSanctioned(address: string, options?: SanctionsOptions): Promise<SanctionedResponse>;
+    /**
+     * Check for address poisoning attacks
+     *
+     * Detects if an address has been targeted by address poisoning
+     * (dust attack) attempts.
+     *
+     * @param address - Address to check
+     * @param options - Request options (chain is optional if defaultChain is set)
+     * @returns Poisoning detection result
+     *
+     * @example
+     * ```typescript
+     * const result = await client.addresses.checkPoisoning('0x...', {
+     *   chain: Chain.ETH,
+     * });
+     *
+     * // With default chain configured
+     * const result = await client.addresses.checkPoisoning('0x...');
+     *
+     * if (result.is_poisoned) {
+     *   console.warn('Address poisoning detected!');
+     *   console.log('Similar addresses:', result.poisoning_details?.similar_addresses);
+     * }
+     * ```
+     */
+    checkPoisoning(address: string, options?: PoisoningOptions): Promise<PoisoningResponse>;
+}
+//# sourceMappingURL=addresses.d.ts.map

package/dist/types/resources/addresses.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addresses.d.ts","sourceRoot":"","sources":["../../../src/resources/addresses.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EAKV,KAAK,EACN,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,mBAAmB,EACnB,kBAAkB,EAClB,iBAAiB,EACjB,sBAAsB,EACtB,gBAAgB,EAChB,gBAAgB,EACjB,MAAM,UAAU,CAAC;AAElB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,iBAAiB;IAE1B,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAC;gBADb,UAAU,EAAE,UAAU,EACtB,YAAY,CAAC,EAAE,KAAK,YAAA;IAGvC;;;OAGG;IACH,OAAO,CAAC,YAAY;IAUpB;;;OAGG;IACH,OAAO,CAAC,eAAe;IASvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IACG,OAAO,CACX,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,sBAA2B,GACnC,OAAO,CAAC,mBAAmB,CAAC;IAgC/B;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACG,eAAe,CACnB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,gBAAqB,GAC7B,OAAO,CAAC,kBAAkB,CAAC;IAkB9B;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACG,cAAc,CAClB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,gBAAqB,GAC7B,OAAO,CAAC,iBAAiB,CAAC;CAiB9B"}

package/dist/types/resources/contracts.d.ts

@@ -0,0 +1,156 @@
+import { HttpClient, Chain } from '@rlajous/sdk-core';
+import { ContractRiskResponse, ContractSourceCodeResponse, TokenTaxResponse, SolidityAnalysisRequest, SolidityAnalysisResponse, ContractAnalysisOptions, SourceCodeOptions, TaxOptions } from '../types';
+/**
+ * Resource for smart contract security analysis
+ *
+ * Provides comprehensive contract analysis including:
+ * - Static and dynamic code analysis
+ * - Vulnerability detection
+ * - Source code verification
+ * - Tax/fee detection
+ * - Deployer risk analysis
+ *
+ * @example
+ * ```typescript
+ * // Analyze a contract
+ * const risk = await client.contracts.analyze('0x...', { chain: Chain.ETH });
+ *
+ * // Get source code
+ * const source = await client.contracts.getSourceCode('0x...', { chain: Chain.ETH });
+ *
+ * // With default chain configured, chain can be omitted
+ * const client = new ThreatClient({ apiKey: '...', defaultChain: Chain.ETH });
+ * const risk = await client.contracts.analyze('0x...'); // Uses ETH
+ * ```
+ */
+export declare class ContractsResource {
+    private readonly httpClient;
+    private readonly defaultChain?;
+    constructor(httpClient: HttpClient, defaultChain?: Chain | undefined);
+    /**
+     * Resolve the chain to use for a request
+     * @throws ValidationError if no chain is specified and no default is set
+     */
+    private resolveChain;
+    /**
+     * Analyze a smart contract for security risks
+     *
+     * Returns comprehensive analysis including:
+     * - Risk score and categorization
+     * - Vulnerability detection
+     * - Source code analysis (if verified)
+     * - Similar contracts
+     * - Deployer risk (optional)
+     *
+     * @param address - Contract address
+     * @param options - Analysis options (chain is optional if defaultChain is set)
+     * @returns Contract risk analysis result
+     *
+     * @example
+     * ```typescript
+     * const result = await client.contracts.analyze('0xContract...', {
+     *   chain: Chain.ETH,
+     * });
+     *
+     * // With default chain, options can be omitted
+     * const result = await client.contracts.analyze('0xContract...');
+     *
+     * console.log(`Risk score: ${result.score}`);
+     * console.log(`Tags: ${result.tags.map(t => t.name).join(', ')}`);
+     *
+     * // Check for vulnerabilities
+     * if (result.source_code_analysis && 'vulnerabilities' in result.source_code_analysis) {
+     *   for (const vuln of result.source_code_analysis.vulnerabilities) {
+     *     console.warn(`${vuln.severity}: ${vuln.title}`);
+     *   }
+     * }
+     * ```
+     */
+    analyze(address: string, options?: ContractAnalysisOptions): Promise<ContractRiskResponse>;
+    /**
+     * Get contract source code
+     *
+     * Returns source code and metadata for verified contracts.
+     *
+     * @param address - Contract address
+     * @param options - Request options (chain is optional if defaultChain is set)
+     * @returns Contract source code and metadata
+     *
+     * @example
+     * ```typescript
+     * const source = await client.contracts.getSourceCode('0x...', {
+     *   chain: Chain.ETH,
+     * });
+     *
+     * // With default chain configured
+     * const source = await client.contracts.getSourceCode('0x...');
+     *
+     * if (source.is_verified) {
+     *   console.log(`Contract: ${source.contract_name}`);
+     *   console.log(`Compiler: ${source.compiler_version}`);
+     * } else {
+     *   console.log('Contract source not verified');
+     * }
+     * ```
+     */
+    getSourceCode(address: string, options?: SourceCodeOptions): Promise<ContractSourceCodeResponse>;
+    /**
+     * Get token buy/sell taxes
+     *
+     * Analyzes token contracts for buy and sell taxes.
+     *
+     * @param address - Token contract address
+     * @param options - Request options (chain is optional if defaultChain is set)
+     * @returns Tax information
+     *
+     * @example
+     * ```typescript
+     * const taxes = await client.contracts.getTaxes('0x...', {
+     *   chain: Chain.ETH,
+     * });
+     *
+     * // With default chain configured
+     * const taxes = await client.contracts.getTaxes('0x...');
+     *
+     * if (taxes.buyTaxPercentage !== null || taxes.sellTaxPercentage !== null) {
+     *   console.log(`Buy tax: ${taxes.buyTaxPercentage}%`);
+     *   console.log(`Sell tax: ${taxes.sellTaxPercentage}%`);
+     * }
+     * ```
+     */
+    getTaxes(address: string, options?: TaxOptions): Promise<TokenTaxResponse>;
+    /**
+     * Analyze Solidity source code
+     *
+     * Analyzes raw Solidity source code for vulnerabilities
+     * without requiring deployment.
+     *
+     * @param request - Analysis request with source code
+     * @returns Analysis results
+     *
+     * @example
+     * ```typescript
+     * const result = await client.contracts.analyzeSolidity({
+     *   source_code: `
+     *     pragma solidity ^0.8.0;
+     *     contract MyToken {
+     *       // ...
+     *     }
+     *   `,
+     *   compiler_version: '0.8.19',
+     * });
+     *
+     * if (result.success && result.results) {
+     *   console.log(`Security score: ${result.results.security_score}`);
+     *   for (const vuln of result.results.vulnerabilities) {
+     *     console.warn(`${vuln.severity}: ${vuln.title}`);
+     *   }
+     * }
+     * ```
+     */
+    analyzeSolidity(request: SolidityAnalysisRequest, options?: {
+        timeout?: number;
+        signal?: AbortSignal;
+    }): Promise<SolidityAnalysisResponse>;
+}
+//# sourceMappingURL=contracts.d.ts.map

package/dist/types/resources/contracts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contracts.d.ts","sourceRoot":"","sources":["../../../src/resources/contracts.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EAKV,KAAK,EACN,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,oBAAoB,EACpB,0BAA0B,EAC1B,gBAAgB,EAChB,uBAAuB,EACvB,wBAAwB,EACxB,uBAAuB,EACvB,iBAAiB,EACjB,UAAU,EACX,MAAM,UAAU,CAAC;AAElB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,iBAAiB;IAE1B,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAC;gBADb,UAAU,EAAE,UAAU,EACtB,YAAY,CAAC,EAAE,KAAK,YAAA;IAGvC;;;OAGG;IACH,OAAO,CAAC,YAAY;IAUpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACG,OAAO,CACX,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,uBAA4B,GACpC,OAAO,CAAC,oBAAoB,CAAC;IA6BhC;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACG,aAAa,CACjB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,iBAAsB,GAC9B,OAAO,CAAC,0BAA0B,CAAC;IAyBtC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACG,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,UAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAyBpF;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACG,eAAe,CACnB,OAAO,EAAE,uBAAuB,EAChC,OAAO,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,GACnD,OAAO,CAAC,wBAAwB,CAAC;CAYrC"}

package/dist/types/resources/index.d.ts

@@ -0,0 +1,8 @@
+export { AddressesResource } from './addresses';
+export { ContractsResource } from './contracts';
+export { UrlResource } from './url';
+export { WalletsResource } from './wallets';
+export { LedgerResource } from './ledger';
+export { AccountTraceResource } from './account-trace';
+export { UsageResource } from './usage';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/resources/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/resources/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAAE,WAAW,EAAE,MAAM,OAAO,CAAC;AACpC,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAC5C,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC"}

package/dist/types/resources/ledger.d.ts

@@ -0,0 +1,107 @@
+import { HttpClient } from '@rlajous/sdk-core';
+import { LedgerFamily, LedgerScanRequest, LedgerEIP712Request, LedgerScanResponse, LedgerScanOptions } from '../types';
+/**
+ * Resource for hardware wallet transaction scanning
+ *
+ * Provides security analysis for transactions before signing on
+ * hardware wallets (Ledger devices).
+ *
+ * @example
+ * ```typescript
+ * // Scan a transaction before signing
+ * const result = await client.ledger.scanTransaction('ethereum', {
+ *   tx: { from: '0x...', raw: '0x...' },
+ *   chain: 1,
+ * });
+ *
+ * if (!result.is_safe) {
+ *   console.error('Transaction may be risky!');
+ * }
+ * ```
+ */
+export declare class LedgerResource {
+    private readonly httpClient;
+    constructor(httpClient: HttpClient);
+    /**
+     * Scan a transaction before signing
+     *
+     * Analyzes a transaction for security risks before signing
+     * on a hardware wallet.
+     *
+     * @param family - Ledger device family (ethereum, solana, bitcoin)
+     * @param request - Transaction scan request
+     * @param options - Request options
+     * @returns Security analysis result
+     *
+     * @example
+     * ```typescript
+     * const result = await client.ledger.scanTransaction('ethereum', {
+     *   tx: {
+     *     from: '0xYourWallet...',
+     *     raw: '0xEncodedTransaction...',
+     *   },
+     *   chain: 1, // Ethereum mainnet
+     * });
+     *
+     * if (!result.is_safe) {
+     *   console.error(`Risk level: ${result.risk_level}`);
+     *   for (const risk of result.risks) {
+     *     console.warn(`${risk.level}: ${risk.description}`);
+     *   }
+     * }
+     *
+     * // Check decoded data
+     * if (result.decoded?.function_name) {
+     *   console.log(`Function: ${result.decoded.function_name}`);
+     * }
+     * ```
+     */
+    scanTransaction(family: LedgerFamily, request: LedgerScanRequest, options?: LedgerScanOptions): Promise<LedgerScanResponse>;
+    /**
+     * Scan EIP-712 typed data before signing
+     *
+     * Analyzes EIP-712 structured data for security risks
+     * before signing on a hardware wallet.
+     *
+     * @param family - Ledger device family
+     * @param request - EIP-712 scan request
+     * @param options - Request options
+     * @returns Security analysis result
+     *
+     * @example
+     * ```typescript
+     * const result = await client.ledger.scanEip712('ethereum', {
+     *   signer: '0xYourWallet...',
+     *   typedData: {
+     *     domain: {
+     *       name: 'MyDApp',
+     *       version: '1',
+     *       chainId: 1,
+     *       verifyingContract: '0x...',
+     *     },
+     *     message: {
+     *       // Message content
+     *     },
+     *     primaryType: 'Order',
+     *     types: {
+     *       EIP712Domain: [
+     *         { name: 'name', type: 'string' },
+     *         // ...
+     *       ],
+     *       Order: [
+     *         { name: 'maker', type: 'address' },
+     *         // ...
+     *       ],
+     *     },
+     *   },
+     *   chain: 1,
+     * });
+     *
+     * if (!result.is_safe) {
+     *   console.error('EIP-712 data may be risky!');
+     * }
+     * ```
+     */
+    scanEip712(family: LedgerFamily, request: LedgerEIP712Request, options?: LedgerScanOptions): Promise<LedgerScanResponse>;
+}
+//# sourceMappingURL=ledger.d.ts.map

package/dist/types/resources/ledger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ledger.d.ts","sourceRoot":"","sources":["../../../src/resources/ledger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAgB,MAAM,mBAAmB,CAAC;AAC7D,OAAO,EACL,YAAY,EACZ,iBAAiB,EACjB,mBAAmB,EACnB,kBAAkB,EAClB,iBAAiB,EAClB,MAAM,UAAU,CAAC;AAElB;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,cAAc;IACb,OAAO,CAAC,QAAQ,CAAC,UAAU;gBAAV,UAAU,EAAE,UAAU;IAEnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACG,eAAe,CACnB,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,iBAAiB,EAC1B,OAAO,CAAC,EAAE,iBAAiB,GAC1B,OAAO,CAAC,kBAAkB,CAAC;IAa9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4CG;IACG,UAAU,CACd,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,mBAAmB,EAC5B,OAAO,CAAC,EAAE,iBAAiB,GAC1B,OAAO,CAAC,kBAAkB,CAAC;CAY/B"}

package/dist/types/resources/url.d.ts

@@ -0,0 +1,69 @@
+import { HttpClient } from '@rlajous/sdk-core';
+import { UrlRiskResponse, UrlAddResponse, UrlCheckOptions } from '../types';
+/**
+ * Resource for URL safety analysis
+ *
+ * Provides URL risk assessment to identify phishing sites,
+ * malicious domains, and other web-based threats.
+ *
+ * @example
+ * ```typescript
+ * const result = await client.url.check('https://suspicious-site.com');
+ * if (result.prediction === 'malicious') {
+ *   console.warn('URL is malicious!');
+ * }
+ * ```
+ */
+export declare class UrlResource {
+    private readonly httpClient;
+    constructor(httpClient: HttpClient);
+    /**
+     * Check if a URL is safe
+     *
+     * Analyzes a URL for phishing, malware, and other threats.
+     *
+     * @param url - URL to check
+     * @param options - Request options
+     * @returns URL safety analysis result
+     *
+     * @example
+     * ```typescript
+     * const result = await client.url.check('https://example.com');
+     *
+     * if (result.prediction === 'malicious') {
+     *   console.error('URL is potentially dangerous!');
+     *   console.log('Details:', result.details);
+     * } else if (result.prediction === 'benign') {
+     *   console.log('URL appears safe');
+     * }
+     *
+     * // Check blacklist/whitelist status
+     * if (result.blacklist === 'true') {
+     *   console.error('URL is blacklisted');
+     * }
+     * if (result.whitelist === 'true') {
+     *   console.log('URL is whitelisted');
+     * }
+     * ```
+     */
+    check(url: string, options?: UrlCheckOptions): Promise<UrlRiskResponse>;
+    /**
+     * Add a URL to the database
+     *
+     * Report a URL to be analyzed and added to the threat database.
+     *
+     * @param url - URL to add
+     * @param options - Request options
+     * @returns Addition result
+     *
+     * @example
+     * ```typescript
+     * const result = await client.url.add('https://phishing-site.com');
+     * if (result.success) {
+     *   console.log('URL reported successfully');
+     * }
+     * ```
+     */
+    add(url: string, options?: UrlCheckOptions): Promise<UrlAddResponse>;
+}
+//# sourceMappingURL=url.d.ts.map

package/dist/types/resources/url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"url.d.ts","sourceRoot":"","sources":["../../../src/resources/url.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAgB,MAAM,mBAAmB,CAAC;AAC7D,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAE5E;;;;;;;;;;;;;GAaG;AACH,qBAAa,WAAW;IACV,OAAO,CAAC,QAAQ,CAAC,UAAU;gBAAV,UAAU,EAAE,UAAU;IAEnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACG,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC;IAa7E;;;;;;;;;;;;;;;;OAgBG;IACG,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC;CAY3E"}

package/dist/types/resources/usage.d.ts

@@ -0,0 +1,99 @@
+import { HttpClient } from '@rlajous/sdk-core';
+import { UsageData, CurrentUsageResponse, UsagePlansResponse, UsageOptions } from '../types';
+/**
+ * Resource for API usage and quota management
+ *
+ * Provides access to API usage statistics, current quota,
+ * and available plans.
+ *
+ * @example
+ * ```typescript
+ * const current = await client.usage.getCurrent();
+ * console.log(`Used: ${current.calls_used}/${current.calls_limit}`);
+ * ```
+ */
+export declare class UsageResource {
+    private readonly httpClient;
+    constructor(httpClient: HttpClient);
+    /**
+     * Get historical usage data
+     *
+     * Returns API usage statistics for a time period.
+     *
+     * @param options - Request options with date range
+     * @returns Historical usage data
+     *
+     * @example
+     * ```typescript
+     * const usage = await client.usage.getUsage({
+     *   start_date: '2024-01-01',
+     *   end_date: '2024-01-31',
+     * });
+     *
+     * console.log(`Total calls: ${usage.total_calls}`);
+     * console.log(`Period calls: ${usage.period_calls}`);
+     *
+     * // Usage by endpoint
+     * if (usage.by_endpoint) {
+     *   for (const [endpoint, count] of Object.entries(usage.by_endpoint)) {
+     *     console.log(`${endpoint}: ${count} calls`);
+     *   }
+     * }
+     * ```
+     */
+    getUsage(options?: UsageOptions): Promise<UsageData>;
+    /**
+     * Get current usage status
+     *
+     * Returns current period usage and remaining quota.
+     *
+     * @param options - Request options
+     * @returns Current usage status
+     *
+     * @example
+     * ```typescript
+     * const current = await client.usage.getCurrent();
+     *
+     * console.log(`Plan: ${current.plan}`);
+     * console.log(`Used: ${current.calls_used}/${current.calls_limit}`);
+     * console.log(`Remaining: ${current.calls_remaining}`);
+     * console.log(`Usage: ${current.usage_percentage}%`);
+     * console.log(`Resets: ${current.reset_date}`);
+     *
+     * if (current.usage_percentage > 80) {
+     *   console.warn('Approaching usage limit!');
+     * }
+     * ```
+     */
+    getCurrent(options?: {
+        timeout?: number;
+        signal?: AbortSignal;
+    }): Promise<CurrentUsageResponse>;
+    /**
+     * Get available usage plans
+     *
+     * Returns list of available plans and their features.
+     *
+     * @param options - Request options
+     * @returns Available plans
+     *
+     * @example
+     * ```typescript
+     * const plans = await client.usage.getPlans();
+     *
+     * console.log(`Current plan: ${plans.current_plan}`);
+     *
+     * for (const plan of plans.plans) {
+     *   console.log(`${plan.name}:`);
+     *   console.log(`  Monthly limit: ${plan.monthly_limit}`);
+     *   console.log(`  Rate limit: ${plan.rate_limit}/sec`);
+     *   console.log(`  Features: ${plan.features.join(', ')}`);
+     * }
+     * ```
+     */
+    getPlans(options?: {
+        timeout?: number;
+        signal?: AbortSignal;
+    }): Promise<UsagePlansResponse>;
+}
+//# sourceMappingURL=usage.d.ts.map

package/dist/types/resources/usage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usage.d.ts","sourceRoot":"","sources":["../../../src/resources/usage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAgB,MAAM,mBAAmB,CAAC;AAC7D,OAAO,EAAE,SAAS,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAE7F;;;;;;;;;;;GAWG;AACH,qBAAa,aAAa;IACZ,OAAO,CAAC,QAAQ,CAAC,UAAU;gBAAV,UAAU,EAAE,UAAU;IAEnD;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACG,QAAQ,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,SAAS,CAAC;IAqB1D;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACG,UAAU,CAAC,OAAO,CAAC,EAAE;QACzB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,MAAM,CAAC,EAAE,WAAW,CAAC;KACtB,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAYjC;;;;;;;;;;;;;;;;;;;;;OAqBG;IACG,QAAQ,CAAC,OAAO,CAAC,EAAE;QACvB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,MAAM,CAAC,EAAE,WAAW,CAAC;KACtB,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAWhC"}