@carddb/client 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,780 @@
+import * as _carddb_core from '@carddb/core';
+import { Logger, LogLevel, Cache, ResourceType, CardDBConfig, RateLimitInfo, GraphQLErrorInfo, Collection, Publisher, Game, Dataset, Deck, DeckCreateInput, DeckUpdateInput, HydrateDeckEntryInput, HydratedDeckEntry, FilterInput, DatasetRecord, APIKeyInfo } from '@carddb/core';
+export * from '@carddb/core';
+
+/**
+ * Configuration management for CardDB client
+ */
+
+declare const DEFAULT_ENDPOINT = "https://carddb.xtda.org/query";
+declare const DEFAULT_TIMEOUT = 30000;
+declare const DEFAULT_OPEN_TIMEOUT = 10000;
+declare const DEFAULT_CACHE_TTL = 300;
+declare const DEFAULT_MAX_RETRIES = 3;
+declare const DEFAULT_MAX_NETWORK_RETRIES = 2;
+declare const DEFAULT_RETRY_BASE_DELAY = 1000;
+declare const DEFAULT_RETRY_MAX_DELAY = 30000;
+declare class Configuration {
+    apiKey?: string;
+    endpoint: string;
+    timeout: number;
+    openTimeout: number;
+    defaultPublisher?: string;
+    defaultGame?: string;
+    allowedPublishers?: string[];
+    allowedGames?: Record<string, string[]>;
+    logger?: Logger;
+    logLevel: LogLevel;
+    retryOnRateLimit: boolean;
+    maxRetries: number;
+    retryOnNetworkError: boolean;
+    maxNetworkRetries: number;
+    retryBaseDelay: number;
+    retryMaxDelay: number;
+    cache?: Cache;
+    cacheTtl: number;
+    cacheTtls: Partial<Record<ResourceType, number>>;
+    constructor(config?: CardDBConfig);
+    /**
+     * Calculate delay for exponential backoff
+     * @param attempt - The attempt number (0-indexed)
+     * @returns Delay in milliseconds with jitter
+     */
+    calculateRetryDelay(attempt: number): number;
+    /**
+     * Get the cache TTL for a specific resource type
+     */
+    cacheTtlFor(resource: ResourceType): number;
+    /**
+     * Resolve publisher slug, using default if not provided
+     */
+    resolvePublisher(publisherSlug?: string): string | undefined;
+    /**
+     * Resolve game key, using default if not provided
+     */
+    resolveGame(gameKey?: string): string | undefined;
+    /**
+     * Validate that a publisher is allowed by the configuration
+     */
+    validatePublisher(publisherSlug: string): void;
+    /**
+     * Validate that a game is allowed by the configuration
+     */
+    validateGame(publisherSlug: string, gameKey: string): void;
+    /**
+     * Validate both publisher and game access
+     */
+    validateAccess(publisherSlug?: string, gameKey?: string): void;
+    /**
+     * Check if a log level should be logged
+     */
+    shouldLog(level: LogLevel): boolean;
+    /**
+     * Create a copy of this configuration with overrides
+     */
+    merge(overrides: Partial<CardDBConfig>): Configuration;
+}
+
+/**
+ * HTTP connection wrapper for GraphQL requests
+ */
+
+interface GraphQLResponse {
+    data?: Record<string, unknown>;
+    errors?: GraphQLErrorInfo[];
+}
+declare function getRateLimitInfo(): RateLimitInfo | null;
+declare class Connection {
+    private config;
+    constructor(config: Configuration);
+    /**
+     * Execute a GraphQL query
+     */
+    execute(query: string, variables?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /**
+     * Check if an error is a retryable network error
+     */
+    private isRetryableNetworkError;
+    private fetch;
+    private handleResponse;
+    private handleSuccessResponse;
+    private handleGraphQLErrors;
+    private handleRateLimitResponse;
+    private handleClientError;
+    private parseBody;
+    private extractRateLimitInfo;
+    private extractOperationName;
+    private sleep;
+    private logRequest;
+    private logResponse;
+    private logRateLimitRetry;
+    private logNetworkRetry;
+    private logError;
+}
+
+/**
+ * Base resource class with common functionality
+ */
+
+declare abstract class BaseResource {
+    protected connection: Connection;
+    protected config: Configuration;
+    constructor(connection: Connection, config: Configuration);
+    /**
+     * Resolve publisher slug, using default if not provided
+     */
+    protected resolvePublisher(publisherSlug?: string): string;
+    /**
+     * Resolve game key, using default if not provided
+     */
+    protected resolveGame(gameKey?: string): string;
+    /**
+     * Validate access to publisher/game
+     */
+    protected validateAccess(publisherSlug?: string, gameKey?: string): void;
+    /**
+     * Execute a query with optional caching
+     */
+    protected withCache<T>(key: string, resource: ResourceType, options: {
+        cache?: boolean;
+    }, fn: () => Promise<T>): Promise<T>;
+    /**
+     * Generate a cache key
+     */
+    protected cacheKey(resource: string, method: string, params: Record<string, unknown>): string;
+}
+
+/**
+ * Publishers resource for CardDB API
+ */
+
+interface SearchPublishersOptions {
+    /** Search term to filter publishers by name */
+    search?: string;
+    /** Maximum number of results per page (default: 20, max: 100) */
+    first?: number;
+    /** Cursor for pagination */
+    after?: string;
+    /** Whether to use cache (defaults to client config) */
+    cache?: boolean;
+}
+interface GetPublisherOptions {
+    /** Whether to use cache (defaults to client config) */
+    cache?: boolean;
+}
+declare class PublishersResource extends BaseResource {
+    constructor(connection: Connection, config: Configuration);
+    /**
+     * Search for publishers
+     *
+     * @example
+     * const publishers = await client.publishers.search({ search: 'pokemon' })
+     * for await (const publisher of publishers) {
+     *   console.log(publisher.name)
+     * }
+     */
+    search(options?: SearchPublishersOptions): Promise<Collection<Publisher>>;
+    /**
+     * Get a single publisher by slug or ID
+     *
+     * @example
+     * const publisher = await client.publishers.get('pokemon')
+     * const publisher = await client.publishers.get('550e8400-e29b-41d4-a716-446655440000')
+     */
+    get(slugOrId: string, options?: GetPublisherOptions): Promise<Publisher | null>;
+    /**
+     * Get multiple publishers by slug
+     *
+     * @example
+     * const publishers = await client.publishers.getMany(['pokemon', 'wizards'])
+     */
+    getMany(slugs: string[], options?: GetPublisherOptions): Promise<Publisher[]>;
+    /**
+     * Check if a string is a valid UUID
+     */
+    private isUUID;
+}
+
+/**
+ * Games resource for CardDB API
+ */
+
+interface SearchGamesOptions {
+    /** Publisher slug to filter games */
+    publisherSlug?: string;
+    /** Search term to filter games by name */
+    search?: string;
+    /** Maximum number of results per page (default: 20, max: 100) */
+    first?: number;
+    /** Cursor for pagination */
+    after?: string;
+    /** Whether to use cache (defaults to client config) */
+    cache?: boolean;
+}
+interface GetGameOptions {
+    /** Whether to use cache (defaults to client config) */
+    cache?: boolean;
+}
+declare class GamesResource extends BaseResource {
+    constructor(connection: Connection, config: Configuration);
+    /**
+     * Search for games
+     *
+     * @example
+     * // Search all games
+     * const games = await client.games.search({ search: 'trading card' })
+     *
+     * // Search games from a specific publisher
+     * const games = await client.games.search({ publisherSlug: 'pokemon' })
+     */
+    search(options?: SearchGamesOptions): Promise<Collection<Game>>;
+    /**
+     * Get a single game by ID
+     *
+     * @example
+     * const game = await client.games.get('550e8400-e29b-41d4-a716-446655440000')
+     */
+    get(id: string, options?: GetGameOptions): Promise<Game | null>;
+    /**
+     * Get a single game by publisher slug and game key
+     *
+     * @example
+     * const game = await client.games.get('pokemon', 'tcg')
+     */
+    get(publisherSlug: string, gameKey: string, options?: GetGameOptions): Promise<Game | null>;
+    /**
+     * Get multiple games by ID
+     *
+     * @example
+     * const games = await client.games.getMany(['id1', 'id2', 'id3'])
+     */
+    getMany(ids: string[], options?: GetGameOptions): Promise<Game[]>;
+}
+
+/**
+ * Datasets resource for CardDB API
+ */
+
+interface SearchDatasetsOptions {
+    /** Publisher slug to filter datasets */
+    publisherSlug?: string;
+    /** Game key to filter datasets (requires publisherSlug) */
+    gameKey?: string;
+    /** Search term to filter datasets by name */
+    search?: string;
+    /** Dataset purpose to filter by */
+    purpose?: 'DATA' | 'RULES';
+    /** Maximum number of results per page (default: 20, max: 100) */
+    first?: number;
+    /** Cursor for pagination */
+    after?: string;
+    /** Whether to use cache (defaults to client config) */
+    cache?: boolean;
+}
+interface GetDatasetOptions {
+    /** Whether to use cache (defaults to client config) */
+    cache?: boolean;
+}
+declare class DatasetsResource extends BaseResource {
+    constructor(connection: Connection, config: Configuration);
+    /**
+     * Search for datasets
+     *
+     * @example
+     * // Search all datasets
+     * const datasets = await client.datasets.search({ search: 'cards' })
+     *
+     * // Search datasets from a specific publisher and game
+     * const datasets = await client.datasets.search({
+     *   publisherSlug: 'pokemon',
+     *   gameKey: 'tcg'
+     * })
+     */
+    search(options?: SearchDatasetsOptions): Promise<Collection<Dataset>>;
+    /**
+     * Get a single dataset by ID (includes schema)
+     *
+     * @example
+     * const dataset = await client.datasets.get('550e8400-e29b-41d4-a716-446655440000')
+     */
+    get(id: string, options?: GetDatasetOptions): Promise<Dataset | null>;
+    /**
+     * Get a single dataset by publisher slug, game key, and dataset key (includes schema)
+     *
+     * @example
+     * const dataset = await client.datasets.get('pokemon', 'tcg', 'cards')
+     */
+    get(publisherSlug: string, gameKey: string, datasetKey: string, options?: GetDatasetOptions): Promise<Dataset | null>;
+    /**
+     * Get multiple datasets by ID
+     *
+     * @example
+     * const datasets = await client.datasets.getMany(['id1', 'id2', 'id3'])
+     */
+    getMany(ids: string[], options?: GetDatasetOptions): Promise<Dataset[]>;
+}
+
+/**
+ * Decks resource for CardDB API
+ */
+
+interface ListDecksOptions {
+    /** Maximum number of results per page */
+    first?: number;
+    /** Cursor for pagination */
+    after?: string;
+    /** Whether to use cache (defaults to client config) */
+    cache?: boolean;
+}
+interface FetchDeckOptions {
+    /** Whether to use cache (defaults to client config) */
+    cache?: boolean;
+}
+type FetchDeckByExternalRefOptions = FetchDeckOptions;
+interface HydrateDeckEntriesOptions {
+    /** Publisher slug (uses default if configured) */
+    publisherSlug?: string;
+    /** Game key (uses default if configured) */
+    gameKey?: string;
+    /** Dataset key containing the deck entries */
+    datasetKey: string;
+    /** Field key used to map returned records to input identifiers */
+    identifierField?: string;
+    /** Deck entries to hydrate */
+    entries: HydrateDeckEntryInput[];
+    /** Whether to use cache (defaults to client config) */
+    cache?: boolean;
+}
+declare class DecksResource extends BaseResource {
+    constructor(connection: Connection, config: Configuration);
+    /**
+     * Fetch a hosted deck by CardDB UUID.
+     */
+    fetch(id: string, options?: FetchDeckOptions): Promise<Deck | null>;
+    /**
+     * Fetch a hosted deck by external reference for the current API application.
+     */
+    fetchByExternalRef(externalRef: string, options?: FetchDeckByExternalRefOptions): Promise<Deck | null>;
+    /**
+     * List decks owned by the current account or API application.
+     */
+    listMine(options?: ListDecksOptions): Promise<Collection<Deck>>;
+    /**
+     * Create a hosted deck.
+     */
+    create(input: DeckCreateInput): Promise<Deck>;
+    /**
+     * Update a hosted deck.
+     */
+    update(id: string, input: DeckUpdateInput): Promise<Deck>;
+    /**
+     * Delete a hosted deck.
+     */
+    delete(id: string): Promise<boolean>;
+    /**
+     * Hydrate third-party-owned deck entries without storing them in CardDB.
+     */
+    hydrateEntries(options: HydrateDeckEntriesOptions): Promise<HydratedDeckEntry[]>;
+}
+
+/**
+ * Records resource for CardDB API
+ */
+
+interface SearchRecordsOptions {
+    /** Publisher slug (uses default if configured) */
+    publisherSlug?: string;
+    /** Game key (uses default if configured) */
+    gameKey?: string;
+    /** Dataset key (required) */
+    datasetKey: string;
+    /**
+     * Filter conditions - can be an object or a builder function
+     *
+     * @example Object literal
+     * filter: { hp: { gte: 100 }, type: 'Pokemon' }
+     *
+     * @example Builder function
+     * filter: f => f
+     *   .where('hp', gte(100))
+     *   .where('type', 'Pokemon')
+     *   .any(or => or
+     *     .where('rarity', 'rare')
+     *     .where('rarity', 'mythic')
+     *   )
+     */
+    filter?: FilterInput;
+    /** Full-text search across searchable fields */
+    search?: string;
+    /**
+     * Order by field with direction
+     * @example 'name:asc', 'hp:desc', 'createdAt:desc'
+     */
+    orderBy?: string;
+    /**
+     * Link fields to resolve (returns linked record data)
+     * @example ['set_id', 'artist_id']
+     */
+    resolveLinks?: string[];
+    /** Maximum number of results per page (default: 20, max: 100) */
+    first?: number;
+    /** Cursor for pagination */
+    after?: string;
+    /** Whether to validate filter against schema (default: true) */
+    validateSchema?: boolean;
+    /** Whether to use cache (defaults to client config) */
+    cache?: boolean;
+}
+interface GetRecordOptions {
+    /** Whether to use cache (defaults to client config) */
+    cache?: boolean;
+}
+interface GetRecordByIdentifierOptions {
+    /** Publisher slug (uses default if configured) */
+    publisherSlug?: string;
+    /** Game key (uses default if configured) */
+    gameKey?: string;
+    /** Dataset key (required) */
+    datasetKey: string;
+    /** The identifier value to look up */
+    identifier: string;
+    /** Whether to use cache (defaults to client config) */
+    cache?: boolean;
+}
+interface GetRecordsByIdentifierOptions {
+    /** Publisher slug (uses default if configured) */
+    publisherSlug?: string;
+    /** Game key (uses default if configured) */
+    gameKey?: string;
+    /** Dataset key (required) */
+    datasetKey: string;
+    /** Identifier values to look up */
+    identifiers: string[];
+    /** Whether to use cache (defaults to client config) */
+    cache?: boolean;
+}
+declare class RecordsResource extends BaseResource {
+    constructor(connection: Connection, config: Configuration);
+    /**
+     * Search for records in a dataset with filtering, search, and pagination
+     *
+     * @example Basic search
+     * const records = await client.records.search({
+     *   publisherSlug: 'pokemon',
+     *   gameKey: 'tcg',
+     *   datasetKey: 'cards',
+     * })
+     *
+     * @example With defaults configured
+     * // If client has defaultPublisher: 'pokemon', defaultGame: 'tcg'
+     * const records = await client.records.search({ datasetKey: 'cards' })
+     *
+     * @example With filtering (object literal)
+     * const records = await client.records.search({
+     *   datasetKey: 'cards',
+     *   filter: {
+     *     hp: { gte: 100 },
+     *     types: { contains: 'Fire' }
+     *   }
+     * })
+     *
+     * @example With filtering (builder function)
+     * const records = await client.records.search({
+     *   datasetKey: 'cards',
+     *   filter: f => f
+     *     .where('hp', gte(100))
+     *     .where('types', contains('Fire'))
+     *     .any(or => or
+     *       .where('rarity', 'Rare')
+     *       .where('rarity', 'Rare Holo')
+     *     )
+     * })
+     *
+     * @example With link resolution
+     * const records = await client.records.search({
+     *   datasetKey: 'cards',
+     *   resolveLinks: ['set_id'],
+     *   filter: f => f.whereLink('set_id', { code: 'BASE' })
+     * })
+     *
+     * @example Iterate through all results
+     * const records = await client.records.search({ datasetKey: 'cards' })
+     * for await (const record of records) {
+     *   console.log(record.data.name)
+     * }
+     */
+    search(options: SearchRecordsOptions): Promise<Collection<DatasetRecord>>;
+    /**
+     * Get a single record by ID
+     *
+     * @example
+     * const record = await client.records.get('550e8400-e29b-41d4-a716-446655440000')
+     */
+    get(id: string, options?: GetRecordOptions): Promise<DatasetRecord | null>;
+    /**
+     * Get a record by its identifier field value
+     *
+     * The identifier field is defined in the dataset schema (the field marked as isIdentifier)
+     *
+     * @example
+     * const record = await client.records.getByIdentifier({
+     *   publisherSlug: 'pokemon',
+     *   gameKey: 'tcg',
+     *   datasetKey: 'cards',
+     *   identifier: 'base1-4'
+     * })
+     *
+     * @example With defaults configured
+     * const record = await client.records.getByIdentifier({
+     *   datasetKey: 'cards',
+     *   identifier: 'base1-4'
+     * })
+     */
+    getByIdentifier(options: GetRecordByIdentifierOptions): Promise<DatasetRecord | null>;
+    /**
+     * Get multiple records by their identifier field values
+     *
+     * Missing identifiers are omitted from the result.
+     *
+     * @example
+     * const records = await client.records.getManyByIdentifier({
+     *   publisherSlug: 'pokemon',
+     *   gameKey: 'tcg',
+     *   datasetKey: 'cards',
+     *   identifiers: ['base1-4', 'base1-5']
+     * })
+     *
+     * @example With defaults configured
+     * const records = await client.records.getManyByIdentifier({
+     *   datasetKey: 'cards',
+     *   identifiers: ['base1-4', 'base1-5']
+     * })
+     */
+    getManyByIdentifier(options: GetRecordsByIdentifierOptions): Promise<DatasetRecord[]>;
+    /**
+     * Get multiple records by ID
+     *
+     * @example
+     * const records = await client.records.getMany(['id1', 'id2', 'id3'])
+     */
+    getMany(ids: string[], options?: GetRecordOptions): Promise<DatasetRecord[]>;
+}
+
+/**
+ * Rules resource for CardDB API
+ */
+
+interface ListRuleDatasetsOptions {
+    /** Publisher slug (uses default if configured) */
+    publisherSlug?: string;
+    /** Game key (uses default if configured) */
+    gameKey?: string;
+    /** Search term to filter rule datasets by name */
+    search?: string;
+    /** Maximum number of results per page (default: 20, max: 100) */
+    first?: number;
+    /** Cursor for pagination */
+    after?: string;
+    /** Whether to use cache (defaults to client config) */
+    cache?: boolean;
+}
+interface ListRulesOptions {
+    /** Publisher slug (uses default if configured) */
+    publisherSlug?: string;
+    /** Game key (uses default if configured) */
+    gameKey?: string;
+    /** Rules dataset key (defaults to "rules") */
+    datasetKey?: string;
+    /** Filter conditions */
+    filter?: FilterInput;
+    /** Full-text search across searchable fields */
+    search?: string;
+    /** Order by field with direction, e.g. "name:asc" */
+    orderBy?: string;
+    /** Link fields to resolve */
+    resolveLinks?: string[];
+    /** Maximum number of results per page (default: 20, max: 100) */
+    first?: number;
+    /** Cursor for pagination */
+    after?: string;
+    /** Whether to validate filter against schema (default: true) */
+    validateSchema?: boolean;
+    /** Whether to use cache (defaults to client config) */
+    cache?: boolean;
+}
+interface ListFormatsOptions extends Omit<ListRulesOptions, 'datasetKey'> {
+    /** Formats dataset key (defaults to "formats") */
+    datasetKey?: string;
+}
+declare class RulesResource extends BaseResource {
+    constructor(connection: Connection, config: Configuration);
+    /**
+     * List rule-related datasets for a game.
+     *
+     * @example
+     * const datasets = await client.rules.datasets({ publisherSlug: 'wotc', gameKey: 'magic' })
+     */
+    datasets(options?: ListRuleDatasetsOptions): Promise<Collection<Dataset>>;
+    /**
+     * List rules from the game's rules dataset.
+     *
+     * @example
+     * const rules = await client.rules.list({ first: 100 })
+     */
+    list(options?: ListRulesOptions): Promise<Collection<DatasetRecord>>;
+    /**
+     * List deck/game formats from the game's formats dataset.
+     *
+     * @example
+     * const formats = await client.rules.formats({ first: 100 })
+     * const names = formats.items.map(format => format.data.name)
+     */
+    formats(options?: ListFormatsOptions): Promise<Collection<DatasetRecord>>;
+    private searchRuleRecords;
+}
+
+/**
+ * CardDB API Client
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { CardDBClient } from '@carddb/node'
+ *
+ * const client = new CardDBClient({
+ *   apiKey: 'carddb_xxx...'
+ * })
+ *
+ * // Search for publishers
+ * const publishers = await client.publishers.search()
+ *
+ * // Get records with filtering
+ * const cards = await client.records.search({
+ *   publisherSlug: 'pokemon',
+ *   gameKey: 'tcg',
+ *   datasetKey: 'cards',
+ *   filter: { hp: { gte: 100 } }
+ * })
+ * ```
+ *
+ * @example With defaults configured
+ * ```typescript
+ * const client = new CardDBClient({
+ *   apiKey: 'carddb_xxx...',
+ *   defaultPublisher: 'pokemon',
+ *   defaultGame: 'tcg'
+ * })
+ *
+ * // Now you can omit publisherSlug and gameKey
+ * const cards = await client.records.search({
+ *   datasetKey: 'cards'
+ * })
+ * ```
+ *
+ * @example With caching
+ * ```typescript
+ * import { CardDBClient, MemoryCache } from '@carddb/node'
+ *
+ * const client = new CardDBClient({
+ *   apiKey: 'carddb_xxx...',
+ *   cache: new MemoryCache(),
+ *   cacheTtl: 300 // 5 minutes
+ * })
+ * ```
+ */
+declare class CardDBClient {
+    private config;
+    private connection;
+    /** Publishers resource for searching and fetching publishers */
+    readonly publishers: PublishersResource;
+    /** Games resource for searching and fetching games */
+    readonly games: GamesResource;
+    /** Datasets resource for searching and fetching datasets */
+    readonly datasets: DatasetsResource;
+    /** Records resource for searching and fetching records */
+    readonly records: RecordsResource;
+    /** Decks resource for hosted decks and external deck hydration */
+    readonly decks: DecksResource;
+    /** Rules resource for game rules and deck formats */
+    readonly rules: RulesResource;
+    /**
+     * Create a new CardDB client
+     *
+     * @param config - Client configuration options
+     */
+    constructor(config?: CardDBConfig);
+    /**
+     * Get information about the current API key
+     *
+     * Returns null if no API key is configured or the key is invalid.
+     *
+     * @example
+     * const info = await client.me()
+     * if (info) {
+     *   console.log(`Logged in as: ${info.account.displayName}`)
+     *   console.log(`Application: ${info.application.name}`)
+     * }
+     */
+    me(): Promise<APIKeyInfo | null>;
+    /**
+     * Get rate limit information from the last request
+     *
+     * @example
+     * await client.publishers.search()
+     * const rateLimit = client.getRateLimitInfo()
+     * console.log(`Remaining: ${rateLimit?.remaining}/${rateLimit?.limit}`)
+     */
+    getRateLimitInfo(): _carddb_core.RateLimitInfo | null;
+    /**
+     * Create a new client with configuration overrides
+     *
+     * Useful for creating scoped clients with different defaults.
+     *
+     * @example
+     * const pokemonClient = client.withConfig({
+     *   defaultPublisher: 'pokemon',
+     *   defaultGame: 'tcg'
+     * })
+     *
+     * // Now all queries use these defaults
+     * const cards = await pokemonClient.records.search({ datasetKey: 'cards' })
+     */
+    withConfig(overrides: Partial<CardDBConfig>): CardDBClient;
+}
+
+/**
+ * User-Agent string generation for analytics tracking
+ *
+ * Format: CardDB-SDK/js/{version} ({runtime}/{runtime_version})
+ * Examples:
+ *   - CardDB-SDK/js/0.1.0 (node/20.10.0)
+ *   - CardDB-SDK/js/0.1.0 (bun/1.0.0)
+ *   - CardDB-SDK/js/0.1.0 (chrome/120.0.0.0)
+ *   - CardDB-SDK/js/0.1.0 (firefox/121.0)
+ */
+/**
+ * Generate the User-Agent string for CardDB SDK
+ */
+declare function getUserAgent(): string;
+/**
+ * Get the SDK version
+ */
+declare function getSDKVersion(): string;
+
+/**
+ * Cache utilities for CardDB client
+ */
+
+/**
+ * Generate a cache key from components
+ */
+declare function cacheKey(resource: string, method: string, params: Record<string, unknown>): string;
+/**
+ * Read from cache (handles both sync and async caches)
+ */
+declare function readCache<T>(cache: Cache, key: string): Promise<T | null>;
+/**
+ * Write to cache (handles both sync and async caches)
+ */
+declare function writeCache<T>(cache: Cache, key: string, value: T, ttl: number): Promise<void>;
+
+export { BaseResource, CardDBClient, Configuration, Connection, DEFAULT_CACHE_TTL, DEFAULT_ENDPOINT, DEFAULT_MAX_NETWORK_RETRIES, DEFAULT_MAX_RETRIES, DEFAULT_OPEN_TIMEOUT, DEFAULT_RETRY_BASE_DELAY, DEFAULT_RETRY_MAX_DELAY, DEFAULT_TIMEOUT, DatasetsResource, DecksResource, type FetchDeckByExternalRefOptions, type FetchDeckOptions, GamesResource, type GetDatasetOptions, type GetGameOptions, type GetPublisherOptions, type GetRecordByIdentifierOptions, type GetRecordOptions, type GetRecordsByIdentifierOptions, type GraphQLResponse, type HydrateDeckEntriesOptions, type ListDecksOptions, type ListFormatsOptions, type ListRuleDatasetsOptions, type ListRulesOptions, PublishersResource, RecordsResource, RulesResource, type SearchDatasetsOptions, type SearchGamesOptions, type SearchPublishersOptions, type SearchRecordsOptions, cacheKey, getRateLimitInfo, getSDKVersion, getUserAgent, readCache, writeCache };