@carddb/core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,840 @@
+/**
+ * Core types for CardDB JavaScript clients
+ */
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+type ResourceType = 'publishers' | 'games' | 'datasets' | 'records' | 'decks';
+interface Logger {
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+}
+interface Cache {
+    get<T>(key: string): T | null | Promise<T | null>;
+    set<T>(key: string, value: T, ttl?: number): void | Promise<void>;
+    delete(key: string): void | Promise<void>;
+    clear?(): void | Promise<void>;
+}
+interface CardDBConfig {
+    /** API key for authentication (increases rate limits) */
+    apiKey?: string;
+    /** GraphQL endpoint URL (defaults to production) */
+    endpoint?: string;
+    /** Request timeout in milliseconds */
+    timeout?: number;
+    /** Connection open timeout in milliseconds */
+    openTimeout?: number;
+    /** Default publisher slug for queries */
+    defaultPublisher?: string;
+    /** Default game key for queries */
+    defaultGame?: string;
+    /** Allowed publisher slugs (undefined = all allowed) */
+    allowedPublishers?: string[];
+    /** Map of publisher slug to allowed game keys */
+    allowedGames?: Record<string, string[]>;
+    /** Logger instance for debug output */
+    logger?: Logger;
+    /** Log level threshold */
+    logLevel?: LogLevel;
+    /** Whether to automatically retry on rate limit errors */
+    retryOnRateLimit?: boolean;
+    /** Maximum number of retries on rate limit */
+    maxRetries?: number;
+    /** Whether to automatically retry on network errors (connection, timeout) */
+    retryOnNetworkError?: boolean;
+    /** Maximum number of retries for network errors */
+    maxNetworkRetries?: number;
+    /** Base delay in milliseconds for exponential backoff (default: 1000) */
+    retryBaseDelay?: number;
+    /** Maximum delay in milliseconds for exponential backoff (default: 30000) */
+    retryMaxDelay?: number;
+    /** Cache instance (must implement Cache interface) */
+    cache?: Cache;
+    /** Default cache TTL in seconds */
+    cacheTtl?: number;
+    /** Per-resource cache TTLs in seconds */
+    cacheTtls?: Partial<Record<ResourceType, number>>;
+}
+interface PageInfo {
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    startCursor: string | null;
+    endCursor: string | null;
+}
+interface Edge<T> {
+    cursor: string;
+    node: T;
+}
+interface Connection<T> {
+    totalCount: number;
+    pageInfo: PageInfo;
+    edges: Edge<T>[];
+}
+interface FileInfo {
+    id: string;
+    url: string;
+}
+type PublisherStatus = 'ACTIVE' | 'DEACTIVATED';
+interface Publisher {
+    id: string;
+    name: string;
+    slug: string;
+    status: PublisherStatus;
+    description: string | null;
+    website: string | null;
+    logoFile: FileInfo | null;
+    bannerFile: FileInfo | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface PublisherRef {
+    id: string;
+    name: string;
+    slug: string;
+}
+interface Game {
+    id: string;
+    publisherId: string;
+    key: string;
+    name: string;
+    description: string | null;
+    website: string | null;
+    visibility: string;
+    isArchived: boolean;
+    publisher: PublisherRef | null;
+    logoFile: FileInfo | null;
+    coverFile: FileInfo | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface GameRef {
+    id: string;
+    key: string;
+    name: string;
+}
+interface Dataset {
+    id: string;
+    publisherId: string;
+    gameId: string;
+    key: string;
+    name: string;
+    description: string | null;
+    purpose: 'DATA' | 'RULES';
+    visibility: string;
+    isArchived: boolean;
+    publisher: PublisherRef | null;
+    game: GameRef | null;
+    schema: DatasetSchema | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface DatasetRef {
+    id: string;
+    key: string;
+    name: string;
+    gameId: string;
+    publisherId: string;
+}
+interface DatasetRecord {
+    id: string;
+    datasetId: string;
+    data: Record<string, unknown>;
+    dataset: DatasetRef | null;
+    resolvedLinks?: ResolvedLink[];
+    createdAt: string;
+    updatedAt: string;
+}
+type DeckVisibility = 'PRIVATE' | 'UNLISTED' | 'PUBLIC';
+interface Deck {
+    id: string;
+    accountId: string;
+    apiApplicationId: string | null;
+    gameId: string;
+    game: Game;
+    title: string;
+    description: string | null;
+    formatKey: string | null;
+    visibility: DeckVisibility;
+    externalRef: string | null;
+    sourceUrl: string | null;
+    metadata: Record<string, unknown>;
+    entries: DeckEntry[];
+    createdAt: string;
+    updatedAt: string;
+}
+interface DeckEntry {
+    id: string;
+    datasetId: string;
+    recordId: string | null;
+    identifier: string;
+    quantity: number;
+    section: string;
+    sortOrder: number;
+    annotations: Record<string, unknown>;
+    record: DatasetRecord | null;
+}
+interface DeckEntryInput {
+    datasetKey: string;
+    identifier: string;
+    quantity: number;
+    section?: string;
+    sortOrder?: number;
+    annotations?: Record<string, unknown>;
+}
+interface DeckCreateInput {
+    publisherSlug: string;
+    gameKey: string;
+    title: string;
+    description?: string;
+    formatKey?: string;
+    visibility?: DeckVisibility;
+    externalRef?: string;
+    sourceUrl?: string;
+    metadata?: Record<string, unknown>;
+    entries: DeckEntryInput[];
+}
+interface DeckUpdateInput {
+    title?: string;
+    description?: string;
+    formatKey?: string;
+    visibility?: DeckVisibility;
+    externalRef?: string;
+    sourceUrl?: string;
+    metadata?: Record<string, unknown>;
+    entries?: DeckEntryInput[];
+}
+interface HydrateDeckEntryInput {
+    identifier: string;
+    quantity: number;
+    section?: string;
+    sortOrder?: number;
+    annotations?: Record<string, unknown>;
+}
+interface HydratedDeckEntry extends HydrateDeckEntryInput {
+    record: DatasetRecord | null;
+}
+interface ResolvedRecord {
+    id: string;
+    datasetId: string;
+    data: Record<string, unknown>;
+}
+interface ResolvedLink {
+    field: string;
+    linkFieldKey: string;
+    values: string[];
+    records: (ResolvedRecord | null)[];
+}
+type FieldType = 'STRING' | 'INTEGER' | 'FLOAT' | 'BOOLEAN' | 'DATE' | 'DATETIME' | 'URL' | 'IMAGE' | 'LINK' | 'ARRAY' | 'HASH';
+interface FieldInfo {
+    key: string;
+    label: string | null;
+    description: string | null;
+    type: FieldType;
+    isRequired: boolean;
+    filterable: boolean;
+    searchable: boolean;
+    isIdentifier: boolean;
+    itemType: FieldType | null;
+    displayFormat: string | null;
+    allowedValues: string[] | null;
+    nestedFields: FieldInfo[] | null;
+}
+interface LinkFieldInfo {
+    key: string;
+    label: string | null;
+    targetDatasetKey: string;
+    targetDatasetName: string | null;
+    targetDatasetId: string;
+}
+interface DatasetSchema {
+    fields: FieldInfo[];
+    filterableFields: string[];
+    searchableFields: string[];
+    linkFields: LinkFieldInfo[];
+}
+interface APIApplication {
+    id: string;
+    name: string;
+    description: string | null;
+    environment: string;
+    apiKeyPrefix: string;
+    allowedOrigins: string[] | null;
+    allowedIps: string[] | null;
+    createdAt: string;
+    updatedAt: string;
+    lastUsedAt: string | null;
+}
+interface APIAccount {
+    id: string;
+    displayName: string;
+    createdAt: string;
+}
+interface APIKeyInfo {
+    application: APIApplication;
+    account: APIAccount;
+}
+type FilterOperatorValue = {
+    eq: unknown;
+} | {
+    neq: unknown;
+} | {
+    gt: number;
+} | {
+    gte: number;
+} | {
+    lt: number;
+} | {
+    lte: number;
+} | {
+    in: unknown[];
+} | {
+    nin: unknown[];
+} | {
+    contains: unknown;
+} | {
+    like: string;
+} | {
+    ilike: string;
+} | {
+    is_null: boolean;
+};
+type FilterValue = unknown | FilterOperatorValue;
+interface FilterCondition {
+    [field: string]: FilterValue | FilterCondition | FilterCondition[];
+}
+type FilterInput = FilterCondition | ((builder: FilterBuilderInterface) => void);
+interface FilterBuilderInterface {
+    where(field: string, value: FilterValue): this;
+    where(conditions: Record<string, FilterValue>): this;
+    any(callback: (builder: FilterBuilderInterface) => void): this;
+    whereLink(field: string, conditions: Record<string, FilterValue>): this;
+    whereAny(field: string, conditions: Record<string, FilterValue>): this;
+    build(): FilterCondition;
+}
+interface RateLimitInfo {
+    limit: number | null;
+    remaining: number | null;
+    reset: number | null;
+}
+
+/**
+ * Error classes for CardDB clients
+ */
+interface GraphQLErrorInfo {
+    message: string;
+    path?: string[];
+    extensions?: Record<string, unknown>;
+}
+/**
+ * Base error class for all CardDB errors
+ */
+declare class CardDBError extends Error {
+    /** The full response body if available */
+    readonly response?: unknown;
+    constructor(message: string, response?: unknown);
+}
+/**
+ * Raised when authentication fails (invalid API key or token)
+ */
+declare class AuthenticationError extends CardDBError {
+    constructor(message?: string, response?: unknown);
+}
+/**
+ * Raised when rate limits are exceeded
+ */
+declare class RateLimitError extends CardDBError {
+    /** Seconds until rate limit resets */
+    readonly retryAfter: number | null;
+    /** Maximum requests allowed */
+    readonly limit: number | null;
+    /** Remaining requests in window */
+    readonly remaining: number | null;
+    /** Time when the rate limit resets */
+    readonly resetAt: Date | null;
+    constructor(message?: string, options?: {
+        retryAfter?: number | null;
+        limit?: number | null;
+        remaining?: number | null;
+        resetAt?: Date | null;
+        response?: unknown;
+    });
+}
+/**
+ * Raised when a requested resource is not found
+ */
+declare class NotFoundError extends CardDBError {
+    constructor(message?: string, response?: unknown);
+}
+/**
+ * Raised when request validation fails
+ */
+declare class ValidationError extends CardDBError {
+    /** List of validation errors */
+    readonly errors: GraphQLErrorInfo[];
+    constructor(message?: string, options?: {
+        errors?: GraphQLErrorInfo[];
+        response?: unknown;
+    });
+}
+/**
+ * Raised when accessing a restricted publisher or game
+ */
+declare class RestrictedError extends CardDBError {
+    constructor(message: string, response?: unknown);
+}
+/**
+ * Raised for GraphQL-level errors
+ */
+declare class GraphQLError extends CardDBError {
+    /** List of GraphQL errors */
+    readonly errors: GraphQLErrorInfo[];
+    constructor(message?: string, options?: {
+        errors?: GraphQLErrorInfo[];
+        response?: unknown;
+    });
+}
+/**
+ * Raised for network/connection issues
+ */
+declare class ConnectionError extends CardDBError {
+    constructor(message?: string, response?: unknown);
+}
+/**
+ * Raised when request times out
+ */
+declare class TimeoutError extends ConnectionError {
+    constructor(message?: string, response?: unknown);
+}
+/**
+ * Raised when the server returns an unexpected response
+ */
+declare class ServerError extends CardDBError {
+    /** HTTP status code */
+    readonly status: number | null;
+    constructor(message?: string, options?: {
+        status?: number | null;
+        response?: unknown;
+    });
+}
+/**
+ * Information about a failed link resolution
+ */
+interface LinkResolutionFailure {
+    /** The link field key that failed */
+    field: string;
+    /** The value that couldn't be resolved */
+    value: string | null;
+    /** The reason for the failure */
+    reason: 'not_found' | 'invalid' | 'permission_denied' | 'unknown';
+    /** Optional error message from the server */
+    message?: string;
+}
+/**
+ * Raised when link resolution fails for one or more links
+ *
+ * This is a warning-level error that contains the partial results along with
+ * information about which links failed to resolve. The application can choose
+ * to handle this gracefully or treat it as a fatal error.
+ */
+declare class LinkResolutionError extends CardDBError {
+    /** List of link resolution failures */
+    readonly failures: LinkResolutionFailure[];
+    /** Partial results that were successfully resolved */
+    readonly partialResults?: unknown;
+    constructor(message?: string, options?: {
+        failures?: LinkResolutionFailure[];
+        partialResults?: unknown;
+        response?: unknown;
+    });
+    /**
+     * Get failures for a specific field
+     */
+    getFailuresForField(field: string): LinkResolutionFailure[];
+    /**
+     * Check if a specific field had resolution failures
+     */
+    hasFailuresForField(field: string): boolean;
+}
+
+/**
+ * Filter operator helper functions
+ *
+ * These functions create operator objects that can be used in filters.
+ *
+ * @example
+ * // With filter builder
+ * filter: (f) => f
+ *   .where('hp', gte(100))
+ *   .where('types', contains('Pokemon'))
+ *
+ * @example
+ * // With object literal
+ * filter: {
+ *   hp: gte(100),
+ *   types: contains('Pokemon')
+ * }
+ */
+
+/** Equality operator */
+declare function eq(value: unknown): FilterOperatorValue;
+/** Not equal operator */
+declare function neq(value: unknown): FilterOperatorValue;
+/** Greater than operator */
+declare function gt(value: number): FilterOperatorValue;
+/** Greater than or equal operator */
+declare function gte(value: number): FilterOperatorValue;
+/** Less than operator */
+declare function lt(value: number): FilterOperatorValue;
+/** Less than or equal operator */
+declare function lte(value: number): FilterOperatorValue;
+/** Value in array operator */
+declare function within(values: unknown[]): FilterOperatorValue;
+/** Value not in array operator */
+declare function notWithin(values: unknown[]): FilterOperatorValue;
+/** Array contains value operator */
+declare function contains(value: unknown): FilterOperatorValue;
+/** Case-sensitive pattern match (SQL LIKE) */
+declare function like(pattern: string): FilterOperatorValue;
+/** Case-insensitive pattern match (SQL ILIKE) */
+declare function ilike(pattern: string): FilterOperatorValue;
+/** Is null operator */
+declare function isNull(): FilterOperatorValue;
+/** Is not null operator */
+declare function isNotNull(): FilterOperatorValue;
+
+/**
+ * Filter builder for constructing complex filter queries
+ *
+ * Supports both builder pattern and object literal styles:
+ *
+ * @example Builder pattern
+ * filter: (f) => f
+ *   .where('hp', gte(100))
+ *   .where('types', contains('Pokemon'))
+ *   .any(or => or
+ *     .where('rarity', 'rare')
+ *     .where('rarity', 'mythic')
+ *   )
+ *
+ * @example Object literal
+ * filter: {
+ *   hp: { gte: 100 },
+ *   types: { contains: 'Pokemon' },
+ *   $or: [
+ *     { rarity: 'rare' },
+ *     { rarity: 'mythic' }
+ *   ]
+ * }
+ */
+
+declare class FilterBuilder {
+    private conditions;
+    private orGroups;
+    /**
+     * Add a condition to the filter
+     *
+     * @example Single field
+     * .where('name', 'Pikachu')
+     * .where('hp', gte(100))
+     *
+     * @example Multiple fields (object)
+     * .where({ name: 'Pikachu', hp: gte(100) })
+     */
+    where(field: string, value: FilterValue): this;
+    where(conditions: Record<string, FilterValue>): this;
+    /**
+     * Add an OR group (any of the conditions must match)
+     *
+     * @example
+     * .where('type', 'creature')
+     * .any(or => or
+     *   .where('color', 'red')
+     *   .where('color', 'blue')
+     * )
+     */
+    any(callback: (builder: FilterBuilder) => void): this;
+    /**
+     * Add a link filter condition (filter on linked records)
+     *
+     * @example
+     * .whereLink('set_id', { code: 'DMU' })
+     * .whereLink('set_id', { name: ilike('%dominaria%') })
+     */
+    whereLink(field: string, conditions: Record<string, FilterValue>): this;
+    /**
+     * Add an array element filter (for ARRAY of HASH fields)
+     * Matches if any element in the array matches all conditions
+     *
+     * @example
+     * .whereAny('attacks', { damage: gte(50) })
+     * .whereAny('attacks', { name: ilike('%thunder%') })
+     */
+    whereAny(field: string, conditions: Record<string, FilterValue>): this;
+    /**
+     * Get the conditions array (used internally for OR groups)
+     */
+    getConditions(): FilterCondition[];
+    /**
+     * Build the final filter object
+     */
+    build(): FilterCondition;
+}
+/**
+ * Resolve a filter input to a filter condition object
+ *
+ * Handles both builder functions and object literals
+ */
+declare function resolveFilter(input: FilterInput | undefined): FilterCondition | undefined;
+
+/**
+ * GraphQL query builder for CardDB API
+ */
+
+interface SearchPublishersParams {
+    search?: string;
+    first?: number;
+    after?: string;
+}
+interface SearchGamesParams {
+    publisherSlug?: string;
+    search?: string;
+    first?: number;
+    after?: string;
+}
+interface SearchDatasetsParams {
+    publisherSlug?: string;
+    gameKey?: string;
+    search?: string;
+    purpose?: 'DATA' | 'RULES';
+    first?: number;
+    after?: string;
+}
+interface SearchRecordsParams {
+    publisherSlug: string;
+    gameKey: string;
+    datasetKey: string;
+    filter?: FilterCondition;
+    search?: string;
+    orderBy?: string;
+    resolveLinks?: string[];
+    first?: number;
+    after?: string;
+    validateSchema?: boolean;
+}
+interface ListDecksParams {
+    first?: number;
+    after?: string;
+}
+declare const QueryBuilder: {
+    searchPublishers(params?: SearchPublishersParams): {
+        query: string;
+        variables: Record<string, unknown>;
+    };
+    fetchPublisherById(): {
+        query: string;
+    };
+    fetchPublisherBySlug(): {
+        query: string;
+    };
+    fetchPublishers(): {
+        query: string;
+    };
+    searchGames(params?: SearchGamesParams): {
+        query: string;
+        variables: Record<string, unknown>;
+    };
+    fetchGameById(): {
+        query: string;
+    };
+    fetchGameByKeys(): {
+        query: string;
+    };
+    fetchGames(): {
+        query: string;
+    };
+    searchDatasets(params?: SearchDatasetsParams): {
+        query: string;
+        variables: Record<string, unknown>;
+    };
+    fetchDatasetById(): {
+        query: string;
+    };
+    fetchDatasetByKeys(): {
+        query: string;
+    };
+    fetchDatasets(): {
+        query: string;
+    };
+    searchRecords(params: SearchRecordsParams): {
+        query: string;
+        variables: Record<string, unknown>;
+    };
+    fetchRecordById(): {
+        query: string;
+    };
+    fetchRecordByIdentifier(): {
+        query: string;
+    };
+    fetchRecordsByIdentifier(): {
+        query: string;
+    };
+    fetchRecords(): {
+        query: string;
+    };
+    listMyDecks(params?: ListDecksParams): {
+        query: string;
+        variables: Record<string, unknown>;
+    };
+    fetchDeckById(): {
+        query: string;
+    };
+    fetchDeckByExternalRef(): {
+        query: string;
+    };
+    createDeck(): {
+        query: string;
+    };
+    updateDeck(): {
+        query: string;
+    };
+    deleteDeck(): {
+        query: string;
+    };
+    deckCreateVariables(input: DeckCreateInput): Record<string, unknown>;
+    deckUpdateVariables(id: string, input: DeckUpdateInput): Record<string, unknown>;
+    fetchMe(): {
+        query: string;
+    };
+};
+
+/**
+ * Collection class for paginated results with async iteration support
+ */
+
+type NextPageLoader<T> = (cursor: string) => Promise<Collection<T>>;
+/**
+ * Represents a paginated collection of results from the API.
+ * Implements AsyncIterable for easy iteration through all pages.
+ */
+declare class Collection<T> implements AsyncIterable<T> {
+    /** Total count of matching records across all pages */
+    readonly totalCount: number;
+    /** Pagination info */
+    readonly pageInfo: PageInfo;
+    /** Items in the current page */
+    readonly items: T[];
+    /** Function to load the next page */
+    private nextPageLoader?;
+    constructor(data: Connection<T>, options?: {
+        nextPageLoader?: NextPageLoader<T>;
+        itemTransformer?: (node: T) => T;
+    });
+    /** Check if there are more pages */
+    get hasNextPage(): boolean;
+    /** Check if there are previous pages */
+    get hasPreviousPage(): boolean;
+    /** Get the cursor for the next page */
+    get endCursor(): string | null;
+    /** Get the cursor for the previous page */
+    get startCursor(): string | null;
+    /** Number of items in the current page */
+    get length(): number;
+    /** Check if the current page is empty */
+    get isEmpty(): boolean;
+    /** Get the first item */
+    get first(): T | undefined;
+    /** Get the last item */
+    get last(): T | undefined;
+    /**
+     * Fetch the next page of results
+     *
+     * @returns The next page collection, or null if no more pages
+     * @throws Error if no next page loader is configured
+     */
+    nextPage(): Promise<Collection<T> | null>;
+    /**
+     * Async iterator that automatically paginates through all results
+     *
+     * @example
+     * for await (const record of collection) {
+     *   console.log(record.name)
+     * }
+     *
+     * @example
+     * const allRecords = []
+     * for await (const record of collection) {
+     *   allRecords.push(record)
+     * }
+     */
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+    /**
+     * Iterate through all results, calling a callback for each item
+     * Similar to Array.forEach but async and auto-paginating
+     *
+     * @example
+     * await collection.forEach(async (record) => {
+     *   await processRecord(record)
+     * })
+     */
+    forEach(callback: (item: T, index: number) => void | Promise<void>): Promise<void>;
+    /**
+     * Map over all results, returning a new array
+     * Auto-paginates through all pages
+     *
+     * @example
+     * const names = await collection.map(record => record.name)
+     */
+    map<U>(callback: (item: T, index: number) => U | Promise<U>): Promise<U[]>;
+    /**
+     * Filter results, returning items that match the predicate
+     * Auto-paginates through all pages
+     *
+     * @example
+     * const rareCards = await collection.filter(card => card.rarity === 'rare')
+     */
+    filter(predicate: (item: T, index: number) => boolean | Promise<boolean>): Promise<T[]>;
+    /**
+     * Find the first item matching a predicate
+     * Stops iterating once found
+     *
+     * @example
+     * const pikachu = await collection.find(card => card.name === 'Pikachu')
+     */
+    find(predicate: (item: T, index: number) => boolean | Promise<boolean>): Promise<T | undefined>;
+    /**
+     * Take the first n items
+     * Stops fetching pages once n items are collected
+     *
+     * @example
+     * const first100 = await collection.take(100)
+     */
+    take(n: number): Promise<T[]>;
+    /**
+     * Collect all items into an array
+     * Auto-paginates through all pages
+     *
+     * @example
+     * const allRecords = await collection.toArray()
+     */
+    toArray(): Promise<T[]>;
+    /**
+     * Iterate in batches (similar to Rails find_in_batches)
+     *
+     * @example
+     * for await (const batch of collection.batches()) {
+     *   await processBatch(batch)
+     * }
+     */
+    batches(): AsyncGenerator<T[]>;
+    /**
+     * Iterate one item at a time with batched fetching (similar to Rails find_each)
+     *
+     * @example
+     * for await (const item of collection.each()) {
+     *   await processItem(item)
+     * }
+     */
+    each(): AsyncIterable<T>;
+}
+
+export { type APIAccount, type APIApplication, type APIKeyInfo, AuthenticationError, type Cache, type CardDBConfig, CardDBError, Collection, type Connection, ConnectionError, type Dataset, type DatasetRecord, type DatasetRef, type DatasetSchema, type Deck, type DeckCreateInput, type DeckEntry, type DeckEntryInput, type DeckUpdateInput, type DeckVisibility, type Edge, type FieldInfo, type FieldType, type FileInfo, FilterBuilder, type FilterBuilderInterface, type FilterCondition, type FilterInput, type FilterOperatorValue, type FilterValue, type Game, type GameRef, GraphQLError, type GraphQLErrorInfo, type HydrateDeckEntryInput, type HydratedDeckEntry, type LinkFieldInfo, LinkResolutionError, type LinkResolutionFailure, type ListDecksParams, type LogLevel, type Logger, type NextPageLoader, NotFoundError, type PageInfo, type Publisher, type PublisherRef, type PublisherStatus, QueryBuilder, RateLimitError, type RateLimitInfo, type ResolvedLink, type ResourceType, RestrictedError, type SearchDatasetsParams, type SearchGamesParams, type SearchPublishersParams, type SearchRecordsParams, ServerError, TimeoutError, ValidationError, contains, eq, gt, gte, ilike, isNotNull, isNull, like, lt, lte, neq, notWithin, resolveFilter, within };