discogs-typescript 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,2573 @@
+/** A long-lived access token. Does not expire unless the user revokes access. */
+export declare interface AccessToken {
+    oauthToken: string;
+    oauthTokenSecret: string;
+}
+
+/**
+ * Body accepted when adding an order message. At least one of `message` or `status` must be
+ * supplied; supplying both prepends
+ * `"Seller changed status from Old Status to New Status"` to the message.
+ */
+export declare interface AddOrderMessageParams {
+    message?: string;
+    status?: OrderStatus;
+}
+
+/** Response of {@link MarketplaceResource.addOrderMessage}. */
+export declare interface AddOrderMessageResponse {
+    /** Narrower than {@link OrderTextMessage.from} — only these two fields are returned. */
+    from: {
+        username: string;
+        resource_url: string;
+    };
+    message: string;
+    order: {
+        id: string;
+        resource_url: string;
+    };
+    timestamp: string;
+    subject: string;
+}
+
+/** Response of {@link CollectionResource.addReleaseToFolder}. */
+export declare interface AddToCollectionResponse {
+    instance_id: number;
+    resource_url: string;
+}
+
+/**
+ * An artist — a person or group credited on releases.
+ *
+ * @see https://www.discogs.com/developers/#page:database,header:database-artist
+ */
+export declare interface Artist {
+    id: number;
+    name: string;
+    resource_url: string;
+    uri: string;
+    releases_url: string;
+    profile: string;
+    data_quality: DataQuality;
+    namevariations?: string[];
+    urls?: string[];
+    images?: Image_2[];
+    members?: ArtistMember[];
+    /** @remarks Undocumented; returned by the live API for artists with aliases. */
+    aliases?: ArtistMember[];
+    /** @remarks Undocumented; returned by the live API for artists who are group members. */
+    groups?: ArtistMember[];
+    /** @remarks Undocumented; returned by the live API. */
+    realname?: string;
+}
+
+/** An artist credit as embedded in releases, masters and tracklists. */
+export declare interface ArtistCredit {
+    id: number;
+    name: string;
+    /** Artist name variation used on this particular release; empty when the canonical name is used. */
+    anv: string;
+    /** Text joining this credit to the next one, e.g. `"&"` or `","`. */
+    join: string;
+    /** Credited role, e.g. `"Design"`, `"Written-By, Producer"`. Empty for main artists. */
+    role: string;
+    /** Tracks this credit applies to; empty when it applies to the whole release. */
+    tracks: string;
+    resource_url: string;
+    /** @remarks Undocumented; returned by the live API on some resources. */
+    thumbnail_url?: string;
+}
+
+/** A master release in an artist's discography. */
+export declare interface ArtistMasterRelease extends ArtistReleaseBase {
+    type: 'master';
+    main_release: number;
+}
+
+/** A member of a band, as listed on an {@link Artist}. */
+export declare interface ArtistMember {
+    id: number;
+    name: string;
+    active: boolean;
+    resource_url: string;
+    /** @remarks Undocumented; returned by the live API. */
+    thumbnail_url?: string;
+}
+
+/**
+ * An entry in an artist's discography — either a master or an individual release,
+ * discriminated by the `type` field.
+ */
+export declare type ArtistRelease = ArtistMasterRelease | ArtistSingleRelease;
+
+/** Fields shared by both variants of {@link ArtistRelease}. */
+declare interface ArtistReleaseBase {
+    id: number;
+    title: string;
+    artist: string;
+    /** Credited role, e.g. `"Main"`, `"Appearance"`, `"TrackAppearance"`. */
+    role: string;
+    resource_url: string;
+    thumb: string;
+    year: number;
+}
+
+/** Sort keys accepted by {@link DatabaseResource.getArtistReleases}. */
+export declare type ArtistReleaseSort = 'year' | 'title' | 'format';
+
+/** Response of {@link DatabaseResource.getArtistReleases}. */
+export declare type ArtistReleasesResponse = Paginated<'releases', ArtistRelease>;
+
+/** A single release in an artist's discography. */
+export declare interface ArtistSingleRelease extends ArtistReleaseBase {
+    type: 'release';
+    status: SubmissionStatus;
+    format: string;
+    label: string;
+    /** @remarks Undocumented; returned by the live API. */
+    stats?: MasterVersionStats;
+}
+
+/**
+ * Any credential shape accepted by the client's `auth` option, or a hand-rolled
+ * {@link AuthStrategy}.
+ */
+export declare type AuthOption = TokenCredentials | ConsumerCredentials | OAuthCredentials | AuthStrategy;
+
+/**
+ * The authentication strategy contract.
+ *
+ * @module
+ */
+/** The parts of an outgoing request a strategy may inspect and mutate. */
+export declare interface AuthorizableRequest {
+    /** Uppercase HTTP method, e.g. `"GET"`. */
+    method: string;
+    /** Fully resolved request URL, including the query string. */
+    url: URL;
+    /** Mutable headers — strategies add their `Authorization` header here. */
+    headers: Headers;
+}
+
+/**
+ * A pluggable authentication scheme.
+ *
+ * Implementations mutate `headers` in place. `authorize` may be asynchronous because
+ * HMAC-SHA1 signing goes through the Web Crypto API.
+ */
+export declare interface AuthStrategy {
+    authorize(request: AuthorizableRequest): void | Promise<void>;
+}
+
+/** Condensed release metadata embedded in collection and wantlist items. */
+export declare interface BasicInformation {
+    id: number;
+    title: string;
+    year: number;
+    resource_url: string;
+    thumb: string;
+    /** @remarks Present on most, but not all, collection and wantlist responses. */
+    cover_image?: string;
+    artists: ArtistCredit[];
+    labels: LabelCredit[];
+    formats: Format[];
+    genres?: string[];
+    styles?: string[];
+    /** @remarks Undocumented; returned by the live API. */
+    master_id?: number;
+    /** @remarks Undocumented; returned by the live API. */
+    master_url?: string | null;
+}
+
+/** Body accepted by {@link CollectionResource.changeInstance}. */
+export declare interface ChangeInstanceParams {
+    /** New rating, 0–5. */
+    rating?: number;
+    /** Target folder id — supply this to move the instance to a different folder. */
+    folder_id?: number;
+}
+
+/** A custom notes field of type `dropdown`, whose value must be one of `options`. */
+export declare interface CollectionDropdownField {
+    id: number;
+    name: string;
+    position: number;
+    type: 'dropdown';
+    public: boolean;
+    options: string[];
+}
+
+/**
+ * A user-defined collection notes field, discriminated by `type`.
+ *
+ * These fields can only be created and deleted through the Discogs website; the API can list
+ * them and change their values on an instance.
+ */
+export declare type CollectionField = CollectionDropdownField | CollectionTextareaField;
+
+/** Response of {@link CollectionResource.getFields}. */
+export declare interface CollectionFieldsResponse {
+    fields: CollectionField[];
+}
+
+/** A collection folder. */
+export declare interface CollectionFolder {
+    id: number;
+    name: string;
+    /** Number of release instances in the folder. */
+    count: number;
+    resource_url: string;
+}
+
+/** Response of {@link CollectionResource.getFolders}. */
+export declare interface CollectionFoldersResponse {
+    folders: CollectionFolder[];
+}
+
+/**
+ * One copy of a release in a collection folder.
+ *
+ * @remarks `notes` here is an array of field values — on wantlist items, by contrast, `notes`
+ * is a plain string.
+ */
+export declare interface CollectionItem {
+    /** The release id. */
+    id: number;
+    /** Identifies this particular copy, since a user may own several. */
+    instance_id: number;
+    folder_id: number;
+    /** 0–5, where `0` means unrated. */
+    rating: number;
+    date_added: string;
+    basic_information: BasicInformation;
+    /** Only public fields are returned unless authenticated as the collection owner. */
+    notes?: CollectionNote[];
+}
+
+/** Response of {@link CollectionResource.getItemsByFolder} and `getItemsByRelease`. */
+export declare type CollectionItemsResponse = Paginated<'releases', CollectionItem>;
+
+/** The value of one custom notes field on a collection instance. */
+export declare interface CollectionNote {
+    field_id: number;
+    value: string;
+}
+
+/**
+ * User collection endpoints.
+ *
+ * A collection is arranged into folders. Folder `0` is the permanent "All" folder (releases
+ * cannot be added to it) and folder `1` is "Uncategorized". Since a user may own several
+ * copies of the same release, each copy in a folder is an *instance* with its own
+ * `instance_id`.
+ *
+ * Reachable as `client.collection`.
+ */
+export declare class CollectionResource {
+    #private;
+    constructor(client: DiscogsClient);
+    /**
+     * Lists a user's collection folders.
+     *
+     * Without authentication as the owner, only folder `0` ("All") is visible, and only if the
+     * collection is public.
+     *
+     * @see https://www.discogs.com/developers/#page:user-collection,header:user-collection-collection
+     */
+    getFolders(username: string): Promise<CollectionFoldersResponse>;
+    /**
+     * Creates a new folder. Requires authentication as the collection owner.
+     *
+     * @see https://www.discogs.com/developers/#page:user-collection,header:user-collection-collection-post
+     */
+    createFolder(username: string, name: string): Promise<CollectionFolder>;
+    /**
+     * Gets a single folder. Requires authentication as the owner unless `folderId` is `0`.
+     *
+     * @see https://www.discogs.com/developers/#page:user-collection,header:user-collection-collection-folder
+     */
+    getFolder(username: string, folderId: number): Promise<CollectionFolder>;
+    /**
+     * Renames a folder. Requires authentication as the owner.
+     *
+     * Folders `0` ("All") and `1` ("Uncategorized") cannot be renamed.
+     *
+     * @see https://www.discogs.com/developers/#page:user-collection,header:user-collection-collection-folder-post
+     */
+    editFolder(username: string, folderId: number, name: string): Promise<CollectionFolder>;
+    /**
+     * Deletes a folder. Requires authentication as the owner, and the folder must be empty.
+     *
+     * @see https://www.discogs.com/developers/#page:user-collection,header:user-collection-collection-folder-delete
+     */
+    deleteFolder(username: string, folderId: number): Promise<void>;
+    /**
+     * Finds every instance of a given release across a user's collection folders.
+     *
+     * @param releaseId - Must be non-zero.
+     *
+     * @see https://www.discogs.com/developers/#page:user-collection,header:user-collection-collection-items-by-release
+     */
+    getItemsByRelease(username: string, releaseId: number, params?: PaginationParams): Promise<CollectionItemsResponse>;
+    /**
+     * Lists the releases in a collection folder.
+     *
+     * Requires authentication as the owner when `folderId` is not `0` or the collection is
+     * private. Without it, only public notes fields are returned.
+     *
+     * @see https://www.discogs.com/developers/#page:user-collection,header:user-collection-collection-items-by-folder
+     */
+    getItemsByFolder(username: string, folderId: number, params?: GetCollectionItemsParams): Promise<CollectionItemsResponse>;
+    /**
+     * Adds a release to a folder. Requires authentication as the owner.
+     *
+     * @param folderId - Must be non-zero; pass `1` for "Uncategorized".
+     *
+     * @see https://www.discogs.com/developers/#page:user-collection,header:user-collection-add-to-collection-folder
+     */
+    addReleaseToFolder(username: string, folderId: number, releaseId: number): Promise<AddToCollectionResponse>;
+    /**
+     * Changes an instance's rating and/or moves it to a different folder. Requires
+     * authentication as the owner.
+     *
+     * Note the two folder ids: `folderId` identifies the folder the instance currently lives in,
+     * while `params.folder_id` is the folder to move it to.
+     *
+     * @see https://www.discogs.com/developers/#page:user-collection,header:user-collection-change-rating-of-release
+     */
+    changeInstance(username: string, folderId: number, releaseId: number, instanceId: number, params: ChangeInstanceParams): Promise<void>;
+    /**
+     * Removes an instance from a collection folder. Requires authentication as the owner.
+     *
+     * To move it to "Uncategorized" instead of deleting it, use
+     * {@link CollectionResource.changeInstance}.
+     *
+     * @see https://www.discogs.com/developers/#page:user-collection,header:user-collection-delete-instance-from-folder
+     */
+    deleteInstance(username: string, folderId: number, releaseId: number, instanceId: number): Promise<void>;
+    /**
+     * Lists a user's custom collection notes fields.
+     *
+     * These can only be created and deleted through the Discogs website. Without authentication
+     * as the owner, only fields with `public: true` are returned.
+     *
+     * @see https://www.discogs.com/developers/#page:user-collection,header:user-collection-list-custom-fields
+     */
+    getFields(username: string): Promise<CollectionFieldsResponse>;
+    /**
+     * Sets the value of a custom notes field on a collection instance.
+     *
+     * @param value - For a `dropdown` field this must be one of the field's `options`. Sent as a
+     * query-string parameter, which is what this endpoint expects.
+     *
+     * @see https://www.discogs.com/developers/#page:user-collection,header:user-collection-edit-fields-instance
+     */
+    editFieldInstance(username: string, folderId: number, releaseId: number, instanceId: number, fieldId: number, value: string): Promise<void>;
+    /**
+     * Gets the minimum, median and maximum value of a collection, as currency-formatted strings.
+     * Requires authentication as the collection owner.
+     *
+     * @see https://www.discogs.com/developers/#page:user-collection,header:user-collection-collection-value
+     */
+    getValue(username: string): Promise<CollectionValue>;
+}
+
+/** Sort keys accepted by {@link CollectionResource.getItemsByFolder}. */
+export declare type CollectionSort = 'label' | 'artist' | 'title' | 'catno' | 'format' | 'rating' | 'added' | 'year';
+
+/** A custom notes field of type `textarea`, which accepts free text. */
+export declare interface CollectionTextareaField {
+    id: number;
+    name: string;
+    position: number;
+    type: 'textarea';
+    public: boolean;
+    /** Height of the input on the website, in lines. */
+    lines: number;
+}
+
+/**
+ * The estimated value of a collection.
+ *
+ * All three values are currency-formatted strings (e.g. `"$250.00"`), not numbers.
+ */
+export declare interface CollectionValue {
+    minimum: string;
+    median: string;
+    maximum: string;
+}
+
+/** Aggregate community rating for a release. */
+export declare interface CommunityRating {
+    average: number;
+    count: number;
+}
+
+/** Aggregate community rating for a release. */
+export declare interface CommunityReleaseRating {
+    release_id: number;
+    rating: CommunityRating;
+}
+
+/** A company credit (pressing plant, copyright holder, distributor, …). */
+export declare interface CompanyCredit {
+    id: number;
+    name: string;
+    catno: string;
+    entity_type: string;
+    entity_type_name: string;
+    resource_url: string;
+    /** @remarks Undocumented; returned by the live API on some resources. */
+    thumbnail_url?: string;
+}
+
+/** Options for the conditional-request variants of the status endpoints. */
+export declare interface ConditionalRequestOptions {
+    /**
+     * Sets `If-Modified-Since`. When the export has not changed since this time Discogs answers
+     * `304 Not Modified` and the method resolves to `null`.
+     */
+    ifModifiedSince?: string | Date;
+}
+
+/**
+ * Credentials for a consumer key/secret pair.
+ *
+ * These raise your rate limit and unlock image URLs, but do not authenticate you as any
+ * particular user.
+ */
+export declare interface ConsumerCredentials {
+    consumerKey: string;
+    consumerSecret: string;
+}
+
+/** Sort keys accepted by {@link UserResource.getContributions}. */
+export declare type ContributionSort = 'label' | 'artist' | 'title' | 'catno' | 'format' | 'rating' | 'year' | 'added';
+
+/** Response of {@link UserResource.getContributions}. */
+export declare type ContributionsResponse = Paginated<'contributions', Release>;
+
+/** Result of requesting a new export. */
+export declare interface CreateExportResult {
+    /**
+     * Id of the newly created export, parsed out of the `Location` response header, or `null`
+     * if Discogs did not send one.
+     */
+    id: number | null;
+    /** The raw `Location` header, e.g. `https://api.discogs.com/inventory/export/599632`. */
+    location: string | null;
+}
+
+/**
+ * Body accepted when creating a listing.
+ *
+ * `weight` and `format_quantity` additionally accept the literal string `"auto"`, which asks
+ * Discogs to estimate the value.
+ */
+export declare interface CreateListingParams {
+    /** The release being listed. */
+    release_id: number;
+    condition: MediaCondition;
+    sleeve_condition?: SleeveCondition;
+    /** Price in the seller's currency. */
+    price: number;
+    /** Remarks displayed to buyers. */
+    comments?: string;
+    /** Defaults to `false`. */
+    allow_offers?: boolean;
+    /** Defaults to `"For Sale"`. */
+    status?: ListingStatus;
+    /** Seller-private reference, shown as "Private Comments" on the website. */
+    external_id?: string;
+    /** Seller-private physical storage location. */
+    location?: string;
+    /** Shipping weight in grams, or `"auto"` to let Discogs estimate it. */
+    weight?: number | 'auto';
+    /** How many items this counts as for shipping, or `"auto"`. */
+    format_quantity?: number | 'auto';
+}
+
+/** Response of {@link MarketplaceResource.createListing}. */
+export declare interface CreateListingResponse {
+    listing_id: number;
+    resource_url: string;
+}
+
+/** Result of submitting an inventory upload. */
+export declare interface CreateUploadResult {
+    /**
+     * Id of the newly created upload, parsed out of the `Location` response header, or `null`
+     * if Discogs did not send one.
+     */
+    id: number | null;
+    /** The raw `Location` header, e.g. `https://api.discogs.com/inventory/upload/599632`. */
+    location: string | null;
+}
+
+/**
+ * A CSV payload for an inventory upload.
+ *
+ * A string is wrapped in a `text/csv` {@link Blob} automatically; pass a `Blob` or `File`
+ * directly to control the filename and content type.
+ */
+export declare type CsvUpload = string | Blob;
+
+/** Every {@link Currency} value, in the order the Discogs docs list them. */
+export declare const CURRENCIES: readonly Currency[];
+
+/**
+ * Shared primitives that appear across many Discogs resources.
+ *
+ * @module
+ */
+/**
+ * Currency codes accepted by the `curr_abbr` parameter and returned in price objects.
+ *
+ * @see https://www.discogs.com/developers/#page:database,header:database-release
+ */
+export declare type Currency = 'USD' | 'GBP' | 'EUR' | 'CAD' | 'AUD' | 'JPY' | 'CHF' | 'MXN' | 'BRL' | 'NZD' | 'SEK' | 'ZAR';
+
+/**
+ * Database endpoints.
+ *
+ * Reachable as `client.database`.
+ */
+export declare class DatabaseResource {
+    #private;
+    constructor(client: DiscogsClient);
+    /**
+     * Gets a release.
+     *
+     * @param releaseId - The release id.
+     * @param params - Optional currency for the embedded marketplace data.
+     *
+     * @see https://www.discogs.com/developers/#page:database,header:database-release
+     */
+    getRelease(releaseId: number, params?: GetReleaseParams): Promise<Release>;
+    /**
+     * Gets a particular user's rating of a release.
+     *
+     * @see https://www.discogs.com/developers/#page:database,header:database-release-rating-by-user
+     */
+    getReleaseRating(releaseId: number, username: string): Promise<ReleaseRating>;
+    /**
+     * Sets a user's rating of a release. Requires authentication as that user.
+     *
+     * @param rating - The new rating, between 1 and 5.
+     *
+     * @see https://www.discogs.com/developers/#page:database,header:database-release-rating-by-user
+     */
+    updateReleaseRating(releaseId: number, username: string, rating: number): Promise<ReleaseRating>;
+    /**
+     * Deletes a user's rating of a release. Requires authentication as that user.
+     *
+     * @see https://www.discogs.com/developers/#page:database,header:database-release-rating-by-user
+     */
+    deleteReleaseRating(releaseId: number, username: string): Promise<void>;
+    /**
+     * Gets the community's average rating and rating count for a release.
+     *
+     * @see https://www.discogs.com/developers/#page:database,header:database-community-release-rating
+     */
+    getCommunityReleaseRating(releaseId: number): Promise<CommunityReleaseRating>;
+    /**
+     * Gets the "have" and "want" counts for a release.
+     *
+     * @see https://www.discogs.com/developers/#page:database,header:database-release-stats
+     */
+    getReleaseStats(releaseId: number): Promise<ReleaseStats>;
+    /**
+     * Gets a master release.
+     *
+     * @see https://www.discogs.com/developers/#page:database,header:database-master-release
+     */
+    getMaster(masterId: number): Promise<Master>;
+    /**
+     * Lists all releases that are versions of a master release.
+     *
+     * @see https://www.discogs.com/developers/#page:database,header:database-master-release-versions
+     */
+    getMasterVersions(masterId: number, params?: GetMasterVersionsParams): Promise<MasterVersionsResponse>;
+    /**
+     * Gets an artist.
+     *
+     * @see https://www.discogs.com/developers/#page:database,header:database-artist
+     */
+    getArtist(artistId: number): Promise<Artist>;
+    /**
+     * Lists the releases and masters associated with an artist.
+     *
+     * Entries are discriminated by their `type` field: `"master"` or `"release"`.
+     *
+     * @see https://www.discogs.com/developers/#page:database,header:database-artist-releases
+     */
+    getArtistReleases(artistId: number, params?: GetArtistReleasesParams): Promise<ArtistReleasesResponse>;
+    /**
+     * Gets a label.
+     *
+     * @see https://www.discogs.com/developers/#page:database,header:database-label
+     */
+    getLabel(labelId: number): Promise<Label>;
+    /**
+     * Lists the releases associated with a label.
+     *
+     * @see https://www.discogs.com/developers/#page:database,header:database-all-label-releases
+     */
+    getLabelReleases(labelId: number, params?: PaginationParams): Promise<LabelReleasesResponse>;
+    /**
+     * Searches the Discogs database.
+     *
+     * **Authentication (as any user) is required.** Unauthenticated searches fail with a 401.
+     *
+     * @example
+     * ```ts
+     * await client.database.search({ artist: 'nirvana', release_title: 'nevermind', per_page: 3 });
+     * ```
+     *
+     * @see https://www.discogs.com/developers/#page:database,header:database-search
+     */
+    search(params?: SearchParams): Promise<SearchResponse>;
+}
+
+/**
+ * Data-quality marker set by the Discogs community, e.g. `"Correct"`, `"Needs Vote"`,
+ * `"Complete and Correct"`. Not exhaustively enumerated by the API docs, so left as a string.
+ */
+export declare type DataQuality = string;
+
+/** Default base URL of the Discogs API. */
+export declare const DEFAULT_BASE_URL = "https://api.discogs.com";
+
+/** Default number of items Discogs returns per page. */
+export declare const DEFAULT_PER_PAGE = 50;
+
+/** Default base URL of the Discogs website, which hosts the authorize page. */
+export declare const DEFAULT_WEBSITE_URL = "https://www.discogs.com";
+
+/** 401 — the resource requires authentication, or the supplied credentials were rejected. */
+export declare class DiscogsAuthenticationError extends DiscogsError {
+}
+
+/**
+ * A client for the Discogs API v2.
+ *
+ * Endpoints are grouped into resources that mirror the sections of the Discogs documentation.
+ *
+ * @example
+ * ```ts
+ * const client = new DiscogsClient({
+ *   userAgent: 'MyApp/1.0 +https://example.com',
+ *   auth: { token: process.env.DISCOGS_TOKEN! },
+ * });
+ *
+ * const release = await client.database.getRelease(249504);
+ * const results = await client.database.search({ artist: 'nirvana', type: 'release' });
+ * ```
+ *
+ * @see https://www.discogs.com/developers/
+ */
+export declare class DiscogsClient {
+    #private;
+    /** Database: releases, masters, artists, labels and search. */
+    readonly database: DatabaseResource;
+    /** Marketplace: inventory, listings, orders, fees, price suggestions and stats. */
+    readonly marketplace: MarketplaceResource;
+    /** Inventory export: request and download CSV exports of your inventory. */
+    readonly inventoryExport: InventoryExportResource;
+    /** Inventory upload: bulk add, change and delete listings from a CSV. */
+    readonly inventoryUpload: InventoryUploadResource;
+    /** User identity: the authenticated user, profiles, submissions and contributions. */
+    readonly user: UserResource;
+    /** User collection: folders, items, custom fields and collection value. */
+    readonly collection: CollectionResource;
+    /** User wantlist. */
+    readonly wantlist: WantlistResource;
+    /** User lists. */
+    readonly lists: ListsResource;
+    constructor(config: DiscogsClientConfig);
+    /**
+     * Rate-limit state from the most recent response, or `null` if no response has carried the
+     * headers yet.
+     *
+     * Because this reflects only the latest response it is unreliable while requests overlap —
+     * use the `onResponse` config option when you need per-request accuracy.
+     */
+    get rateLimit(): RateLimit | null;
+    /**
+     * Sends an arbitrary request to the API, returning the parsed body together with the raw
+     * response and its rate-limit headers.
+     *
+     * Use this to reach anything the typed resources do not cover, or when you need response
+     * headers such as `Location` or `Last-Modified`.
+     *
+     * @example
+     * ```ts
+     * const { data, rateLimit } = await client.request<Release>({ path: '/releases/249504' });
+     * ```
+     */
+    request<T>(options: RequestOptions): Promise<DiscogsResponse<T>>;
+    /* Excluded from this release type: requestData */
+}
+
+/** Configuration for {@link DiscogsClient}. */
+export declare interface DiscogsClientConfig {
+    /**
+     * Identifies your application to Discogs. **Required** — Discogs returns an empty response
+     * to requests without a User-Agent, and rejects strings that impersonate a browser or a
+     * generic HTTP library.
+     *
+     * @example `'MyDiscogsClient/1.0 +https://mydiscogsclient.org'`
+     */
+    userAgent: string;
+    /**
+     * Credentials. Omit to make unauthenticated requests, which are limited to 25 requests per
+     * minute and receive no image URLs.
+     *
+     * - `{ token }` — a personal access token; authenticates as the token holder.
+     * - `{ consumerKey, consumerSecret }` — raises the rate limit and unlocks image URLs, but
+     *   authenticates as no one.
+     * - `{ consumerKey, consumerSecret, accessToken, accessTokenSecret }` — full OAuth 1.0a;
+     *   authenticates as the user who granted access. See {@link DiscogsOAuth}.
+     */
+    auth?: AuthOption;
+    /** Override the API base URL. Defaults to `https://api.discogs.com`. */
+    baseUrl?: string;
+    /**
+     * Which representation to request. Discogs offers `discogs` (raw markup in text fields),
+     * `html`, and `plaintext`. Defaults to `discogs`, which is also the server-side default.
+     */
+    mediaType?: MediaType;
+    /** Custom `fetch` implementation. Defaults to the global one. */
+    fetch?: typeof globalThis.fetch;
+    /**
+     * Called after every response, before the body is read.
+     *
+     * This is the reliable way to observe rate-limit state per request —
+     * {@link DiscogsClient.rateLimit} only holds the most recent value and is therefore racy
+     * when requests overlap.
+     */
+    onResponse?: (info: {
+        response: Response;
+        rateLimit: RateLimit | null;
+    }) => void;
+}
+
+/**
+ * Base class for every error the client throws for a failed API response.
+ *
+ * Use `instanceof DiscogsError` to catch all of them, or one of the subclasses below to
+ * handle a specific status.
+ */
+export declare class DiscogsError extends Error {
+    /** HTTP status code of the failing response. */
+    readonly status: number;
+    /** The raw response object. */
+    readonly response: Response;
+    /** Parsed response body, when it could be read. */
+    readonly body: unknown;
+    constructor(message: string, options: DiscogsErrorOptions);
+}
+
+/**
+ * The error payload Discogs returns for every non-2xx response.
+ *
+ * @example `{ "message": "Release not found." }`
+ */
+export declare interface DiscogsErrorBody {
+    message: string;
+}
+
+/** Options carried by every {@link DiscogsError}. */
+export declare interface DiscogsErrorOptions {
+    /** HTTP status code of the failing response. */
+    status: number;
+    /** The raw response, in case you need headers or want to re-read the body. */
+    response: Response;
+    /** Parsed response body, when it could be read. */
+    body?: unknown;
+}
+
+/** 405 — the HTTP verb is not supported for this resource (e.g. `PUT /artists/1`). */
+export declare class DiscogsMethodNotAllowedError extends DiscogsError {
+}
+
+/** 404 — the resource does not exist. */
+export declare class DiscogsNotFoundError extends DiscogsError {
+}
+
+/**
+ * Drives the three-legged OAuth 1.0a flow that yields an access token for a Discogs user.
+ *
+ * Once you have the access token, hand it to {@link DiscogsClient} as the `auth` option.
+ *
+ * @example
+ * ```ts
+ * const oauth = new DiscogsOAuth({
+ *   consumerKey: process.env.DISCOGS_CONSUMER_KEY!,
+ *   consumerSecret: process.env.DISCOGS_CONSUMER_SECRET!,
+ *   userAgent: 'MyApp/1.0 +https://example.com',
+ * });
+ *
+ * // 1. Get a temporary request token and send the user to Discogs.
+ * const request = await oauth.getRequestToken('https://example.com/callback');
+ * console.log(oauth.getAuthorizeUrl(request.oauthToken));
+ *
+ * // 2. Discogs redirects back with ?oauth_verifier=… — exchange it for an access token.
+ * const access = await oauth.getAccessToken({ ...request, verifier });
+ *
+ * // 3. Use it.
+ * const client = new DiscogsClient({
+ *   userAgent: 'MyApp/1.0 +https://example.com',
+ *   auth: {
+ *     consumerKey, consumerSecret,
+ *     accessToken: access.oauthToken,
+ *     accessTokenSecret: access.oauthTokenSecret,
+ *   },
+ * });
+ * ```
+ */
+export declare class DiscogsOAuth {
+    #private;
+    constructor(config: DiscogsOAuthConfig);
+    /**
+     * Step 1 — requests a temporary token from `GET /oauth/request_token`.
+     *
+     * @param callbackUrl - Where Discogs should send the user after they approve access. Pass
+     * `'oob'` (out of band) when you have no callback URL and want the user to type the
+     * verifier in manually.
+     */
+    getRequestToken(callbackUrl: string): Promise<RequestToken>;
+    /**
+     * Step 2 — the URL to send the user to so they can approve your application.
+     *
+     * @param requestToken - The `oauthToken` from {@link DiscogsOAuth.getRequestToken}.
+     */
+    getAuthorizeUrl(requestToken: string): string;
+    /**
+     * Step 3 — exchanges the approved request token for a long-lived access token via
+     * `POST /oauth/access_token`.
+     *
+     * Request tokens and verifiers expire 15 minutes after they are issued; an expired or
+     * malformed exchange fails with a 400.
+     */
+    getAccessToken(params: GetAccessTokenParams): Promise<AccessToken>;
+}
+
+/** Configuration for {@link DiscogsOAuth}. */
+export declare interface DiscogsOAuthConfig extends OAuthNonceOptions {
+    consumerKey: string;
+    consumerSecret: string;
+    /**
+     * Identifies your application to Discogs. Required — requests without a User-Agent receive
+     * an empty response.
+     *
+     * @example `'MyDiscogsClient/1.0 +https://mydiscogsclient.org'`
+     */
+    userAgent: string;
+    /** Defaults to `"PLAINTEXT"`, as recommended by the Discogs documentation. */
+    signatureMethod?: OAuthSignatureMethod;
+    /** Override the API base URL. Defaults to `https://api.discogs.com`. */
+    baseUrl?: string;
+    /** Override the website base URL used to build the authorize link. */
+    websiteUrl?: string;
+    /** Custom `fetch` implementation. Defaults to the global one. */
+    fetch?: typeof globalThis.fetch;
+}
+
+/** 403 — authenticated, but not allowed to access or modify this resource. */
+export declare class DiscogsPermissionError extends DiscogsError {
+}
+
+/**
+ * 429 — the rate limit was exceeded.
+ *
+ * Discogs allows 60 requests per minute when authenticated and 25 when not, measured as a
+ * moving average over a 60-second window per source IP. Inspect
+ * {@link DiscogsRateLimitError.rateLimit} to see where you stand.
+ */
+export declare class DiscogsRateLimitError extends DiscogsError {
+    /** Rate-limit headers from the rejected response, when present. */
+    readonly rateLimit: RateLimit | null;
+    constructor(message: string, options: DiscogsErrorOptions & {
+        rateLimit?: RateLimit | null;
+    });
+}
+
+/** A response with its parsed body and the metadata that came with it. */
+export declare interface DiscogsResponse<T> {
+    /** The parsed response body. `null` for `204 No Content` and `304 Not Modified`. */
+    data: T;
+    /** The raw response, for headers such as `Location` and `Last-Modified`. */
+    response: Response;
+    /** Rate-limit state from this response, or `null` when the headers were absent. */
+    rateLimit: RateLimit | null;
+}
+
+/**
+ * 5xx — Discogs failed to handle the request.
+ *
+ * For a 500 the `message` in the body is an error code you can quote to Discogs Support.
+ */
+export declare class DiscogsServerError extends DiscogsError {
+}
+
+/**
+ * 422 — the request was well-formed but semantically wrong: a missing or mistyped parameter,
+ * an invalid enum value, or a nonsensical action.
+ */
+export declare class DiscogsValidationError extends DiscogsError {
+}
+
+/**
+ * Body accepted when editing a listing.
+ *
+ * Listings whose status is not `For Sale`, `Draft` or `Expired` can only be deleted, not
+ * edited. A `Sold` listing cannot be re-listed — create a new listing instead.
+ */
+export declare type EditListingParams = CreateListingParams;
+
+/**
+ * Body accepted when editing an order.
+ *
+ * `status` and `shipping` are mutually exclusive: changing the shipping price invoices the
+ * buyer and forces the status to `Invoice Sent`, so Discogs rejects requests that set both.
+ * Shipping can only be changed while the order is not cancelled, `Payment Received` or
+ * `Shipped`.
+ */
+export declare interface EditOrderParams {
+    /** Must appear in the order's current {@link Order.next_status} list. */
+    status?: OrderStatus;
+    /** New shipping price. Sends an invoice and moves the order to `Invoice Sent`. */
+    shipping?: number;
+    /** Seller only — buyers receive a 403. */
+    tracking?: OrderTracking;
+}
+
+/** Body accepted by {@link UserResource.editProfile}. All fields are optional. */
+export declare interface EditProfileParams {
+    /** The user's real name. */
+    name?: string;
+    home_page?: string;
+    location?: string;
+    profile?: string;
+    curr_abbr?: Currency;
+}
+
+/** The permanent "All" folder, which lists every release in the collection. */
+export declare const FOLDER_ALL = 0;
+
+/** The permanent "Uncategorized" folder, the default destination for new additions. */
+export declare const FOLDER_UNCATEGORIZED = 1;
+
+/** A physical or digital format descriptor. */
+export declare interface Format {
+    name: string;
+    /** Quantity of this format, as a string (e.g. `"1"`, `"2"`). */
+    qty: string;
+    /** Free-form text qualifier, e.g. `"Digipak"`. */
+    text?: string;
+    descriptions?: string[];
+}
+
+/** Arguments for {@link DiscogsOAuth.getAccessToken}. */
+export declare interface GetAccessTokenParams {
+    /** The request token from {@link DiscogsOAuth.getRequestToken}. */
+    oauthToken: string;
+    /** The matching request token secret. */
+    oauthTokenSecret: string;
+    /**
+     * The verifier Discogs handed back after the user approved access — either from the
+     * `oauth_verifier` query parameter on your callback URL, or typed in by the user when no
+     * callback is registered.
+     */
+    verifier: string;
+}
+
+/** Query parameters for {@link DatabaseResource.getArtistReleases}. */
+export declare interface GetArtistReleasesParams extends PaginationParams {
+    sort?: ArtistReleaseSort;
+    sort_order?: SortOrder;
+}
+
+/** Query parameters for {@link CollectionResource.getItemsByFolder}. */
+export declare interface GetCollectionItemsParams extends PaginationParams {
+    sort?: CollectionSort;
+    sort_order?: SortOrder;
+}
+
+/** Query parameters for {@link UserResource.getContributions}. */
+export declare interface GetContributionsParams extends PaginationParams {
+    sort?: ContributionSort;
+    sort_order?: SortOrder;
+}
+
+/** Query parameters for {@link MarketplaceResource.getInventory}. */
+export declare interface GetInventoryParams extends PaginationParams {
+    /** Only return listings with this status. */
+    status?: ListingStatusFilter;
+    sort?: InventorySort;
+    sort_order?: SortOrder;
+}
+
+/** Query parameters for {@link MarketplaceResource.getListing}. */
+export declare interface GetListingParams {
+    /** Defaults to the authenticated user's currency. */
+    curr_abbr?: Currency;
+}
+
+/** Query parameters for {@link MarketplaceResource.getReleaseStats}. */
+export declare interface GetMarketplaceStatsParams {
+    /** Defaults to the authenticated user's buyer currency, or USD when unauthenticated. */
+    curr_abbr?: Currency;
+}
+
+/** Query parameters for {@link DatabaseResource.getMasterVersions}. */
+export declare interface GetMasterVersionsParams extends PaginationParams {
+    /** Filter by format, e.g. `"Vinyl"`. */
+    format?: string;
+    /** Filter by label, e.g. `"Scorpio Music"`. */
+    label?: string;
+    /** Filter by release year, e.g. `"1992"`. */
+    released?: string;
+    /** Filter by country, e.g. `"Belgium"`. */
+    country?: string;
+    sort?: MasterVersionSort;
+    sort_order?: SortOrder;
+}
+
+/** Query parameters for {@link DatabaseResource.getRelease}. */
+export declare interface GetReleaseParams {
+    /**
+     * Currency for marketplace data (`lowest_price`). Defaults to the authenticated user's
+     * currency, or USD when unauthenticated.
+     */
+    curr_abbr?: Currency;
+}
+
+/** HTTP verbs used by the Discogs API. */
+export declare type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE';
+
+/** A barcode, matrix number, rights-society code, or similar identifier. */
+export declare interface Identifier {
+    type: string;
+    value: string;
+    /** @remarks Optional; present when the submitter added a qualifier. */
+    description?: string;
+}
+
+/**
+ * Basic information about the authenticated user.
+ *
+ * @see https://www.discogs.com/developers/#page:user-identity,header:user-identity-identity
+ */
+export declare interface Identity {
+    id: number;
+    username: string;
+    resource_url: string;
+    /** The name of the application whose credentials made the request. */
+    consumer_name: string;
+}
+
+/**
+ * A user-contributed image.
+ *
+ * Image URLs are signed and only present when the request is authenticated (a consumer
+ * key/secret pair is sufficient). Never construct these URLs yourself — altering any part of
+ * them results in a 404.
+ */
+declare interface Image_2 {
+    type: 'primary' | 'secondary';
+    uri: string;
+    /** 150px thumbnail variant. */
+    uri150: string;
+    resource_url: string;
+    width: number;
+    height: number;
+}
+export { Image_2 as Image }
+
+/**
+ * A requested CSV export of your Marketplace inventory.
+ *
+ * @see https://www.discogs.com/developers/#page:inventory-export
+ */
+export declare interface InventoryExport {
+    id: number;
+    status: JobStatus;
+    /** Timestamp the export was requested, e.g. `"2018-09-27T12:50:39"`. */
+    created_ts: string;
+    /** Timestamp the export finished. `null` while the export is still running. */
+    finished_ts: string | null;
+    filename: string;
+    /** URL of this export's status resource. */
+    url: string;
+    /** URL to download the finished CSV. */
+    download_url: string;
+}
+
+/**
+ * Inventory export endpoints.
+ *
+ * Reachable as `client.inventoryExport`.
+ */
+export declare class InventoryExportResource {
+    #private;
+    constructor(client: DiscogsClient);
+    /**
+     * Requests a CSV export of your inventory.
+     *
+     * Exports are generated asynchronously — poll {@link InventoryExportResource.get} until the
+     * status reports success, then call {@link InventoryExportResource.downloadCsv}.
+     *
+     * @throws A `DiscogsError` with status 409 when an export is already in progress.
+     *
+     * @see https://www.discogs.com/developers/#page:inventory-export,header:inventory-export-export-your-inventory
+     */
+    create(): Promise<CreateExportResult>;
+    /**
+     * Lists your recent inventory exports, newest first.
+     *
+     * @remarks Discogs names the collection key `items` on this endpoint, not `exports`.
+     *
+     * @see https://www.discogs.com/developers/#page:inventory-export,header:inventory-export-get-recent-exports
+     */
+    list(params?: PaginationParams): Promise<InventoryExportsResponse>;
+    /**
+     * Gets the status of an export.
+     *
+     * @returns The export, or `null` when `ifModifiedSince` was supplied and Discogs answered
+     * `304 Not Modified`.
+     *
+     * @see https://www.discogs.com/developers/#page:inventory-export,header:inventory-export-get-an-export
+     */
+    get(exportId: number, options?: ConditionalRequestOptions): Promise<InventoryExport | null>;
+    /**
+     * Downloads a finished export as CSV text.
+     *
+     * @see https://www.discogs.com/developers/#page:inventory-export,header:inventory-export-download-an-export
+     */
+    downloadCsv(exportId: number): Promise<string>;
+    /**
+     * Downloads a finished export as a raw {@link Response}, so you can stream it to disk or
+     * read the `Content-Disposition` filename.
+     *
+     * @see https://www.discogs.com/developers/#page:inventory-export,header:inventory-export-download-an-export
+     */
+    downloadRaw(exportId: number): Promise<Response>;
+}
+
+/**
+ * Response of {@link InventoryExportResource.list}.
+ *
+ * Note that Discogs uses `items` as the collection key here, which is easy to confuse with
+ * `pagination.items` — the latter is a count, the former the array of exports.
+ */
+export declare type InventoryExportsResponse = Paginated<'items', InventoryExport>;
+
+/** Response of {@link MarketplaceResource.getInventory}. */
+export declare type InventoryResponse = Paginated<'listings', Listing>;
+
+/** Sort keys accepted by {@link MarketplaceResource.getInventory}. */
+export declare type InventorySort = 'listed' | 'price'
+/** Title of the release. */
+| 'item' | 'artist' | 'label' | 'catno' | 'audio'
+/** Owner-authenticated requests only. */
+| 'status'
+/** Owner-authenticated requests only. */
+| 'location';
+
+/**
+ * A submitted CSV upload against your Marketplace inventory.
+ *
+ * @see https://www.discogs.com/developers/#page:inventory-upload
+ */
+export declare interface InventoryUpload {
+    id: number;
+    status: JobStatus;
+    /** Human-readable summary containing light HTML, e.g. `"CSV file contains 1 records.<p>Processed 1 records."` */
+    results: string;
+    created_ts: string;
+    finished_ts: string | null;
+    filename: string;
+    type: InventoryUploadType;
+}
+
+/**
+ * Inventory upload endpoints.
+ *
+ * Every upload takes a comma-separated CSV whose first row is a header of **lower case**
+ * field names. Uploads are processed asynchronously — poll
+ * {@link InventoryUploadResource.get} for the outcome.
+ *
+ * Reachable as `client.inventoryUpload`.
+ */
+export declare class InventoryUploadResource {
+    #private;
+    constructor(client: DiscogsClient);
+    /**
+     * Uploads a CSV of listings to add to your inventory. Added listings go on sale immediately,
+     * priced in the currency from your Marketplace settings.
+     *
+     * Required columns: `release_id`, `price`, `media_condition`.
+     * Optional columns: `sleeve_condition`, `comments`, `accept_offer` (`Y` or `N`), `location`,
+     * `external_id`, `weight` (grams, non-negative integer), `format_quantity`.
+     * Any other column is ignored.
+     *
+     * @param csv - CSV text, or a `Blob`/`File` if you want to control the filename.
+     *
+     * @example
+     * ```ts
+     * await client.inventoryUpload.add(
+     *   'release_id,price,media_condition\n249504,12.50,Near Mint (NM or M-)\n',
+     * );
+     * ```
+     *
+     * @see https://www.discogs.com/developers/#page:inventory-upload,header:inventory-upload-add-inventory
+     */
+    add(csv: CsvUpload, filename?: string): Promise<CreateUploadResult>;
+    /**
+     * Uploads a CSV of changes to existing listings.
+     *
+     * Required column: `release_id`.
+     * At least one of: `price`, `media_condition`, `sleeve_condition`, `comments`,
+     * `accept_offer` (`Y` or `N`), `external_id`, `location`, `weight`, `format_quantity`.
+     *
+     * @see https://www.discogs.com/developers/#page:inventory-upload,header:inventory-upload-change-inventory
+     */
+    change(csv: CsvUpload, filename?: string): Promise<CreateUploadResult>;
+    /**
+     * Uploads a CSV of listings to delete. The only column is `listing_id`.
+     *
+     * @example
+     * ```ts
+     * await client.inventoryUpload.delete('listing_id\n12345678\n98765432\n');
+     * ```
+     *
+     * @see https://www.discogs.com/developers/#page:inventory-upload,header:inventory-upload-delete-inventory
+     */
+    delete(csv: CsvUpload, filename?: string): Promise<CreateUploadResult>;
+    /**
+     * Lists your recent inventory uploads.
+     *
+     * @remarks Discogs names the collection key `items` on this endpoint, not `uploads`.
+     *
+     * @see https://www.discogs.com/developers/#page:inventory-upload,header:inventory-upload-get-recent-uploads
+     */
+    list(params?: PaginationParams): Promise<InventoryUploadsResponse>;
+    /**
+     * Gets the status of an upload, including how many records were processed.
+     *
+     * @returns The upload, or `null` when `ifModifiedSince` was supplied and Discogs answered
+     * `304 Not Modified`.
+     *
+     * @see https://www.discogs.com/developers/#page:inventory-upload,header:inventory-upload-get-an-upload
+     */
+    get(uploadId: number, options?: ConditionalRequestOptions): Promise<InventoryUpload | null>;
+}
+
+/** Response of {@link InventoryUploadResource.list}. Uses `items` as the collection key. */
+export declare type InventoryUploadsResponse = Paginated<'items', InventoryUpload>;
+
+/** Which kind of change an inventory upload applies. */
+export declare type InventoryUploadType = 'add' | 'change' | 'delete';
+
+/**
+ * Processing status of an export or upload job.
+ *
+ * The docs only ever show `"success"`; the full set is not enumerated, so this stays a string.
+ */
+export declare type JobStatus = string;
+
+/**
+ * Authenticates with a consumer key and secret.
+ *
+ * Sends `Authorization: Discogs key=<key>, secret=<secret>`. This raises your rate limit to
+ * the authenticated tier and unlocks image URLs, but does not authenticate you as any
+ * particular user — endpoints that act on a user's data still require OAuth or a personal
+ * access token.
+ *
+ * @see https://www.discogs.com/developers/#page:authentication,header:authentication-discogs-auth-flow
+ */
+export declare class KeySecretAuth implements AuthStrategy {
+    #private;
+    constructor(consumerKey: string, consumerSecret: string);
+    authorize(request: AuthorizableRequest): void;
+}
+
+/**
+ * A label — a company or imprint that released records.
+ *
+ * @see https://www.discogs.com/developers/#page:database,header:database-label
+ */
+export declare interface Label {
+    id: number;
+    name: string;
+    resource_url: string;
+    uri: string;
+    releases_url: string;
+    profile: string;
+    data_quality: DataQuality;
+    contact_info?: string;
+    urls?: string[];
+    images?: Image_2[];
+    sublabels?: LabelRef[];
+    /** @remarks Undocumented; present when the label is itself a sublabel. */
+    parent_label?: LabelRef;
+}
+
+/** A label credit as embedded in releases. */
+export declare interface LabelCredit {
+    id: number;
+    name: string;
+    /** Catalogue number for this release on this label. */
+    catno: string;
+    entity_type: string;
+    /** @remarks Present on some resources only (e.g. collection/wantlist basic information). */
+    entity_type_name?: string;
+    resource_url: string;
+    /** @remarks Undocumented; returned by the live API on some resources. */
+    thumbnail_url?: string;
+}
+
+/** A sublabel or parent label reference. */
+export declare interface LabelRef {
+    id: number;
+    name: string;
+    resource_url: string;
+}
+
+/** One release on a label. */
+export declare interface LabelRelease {
+    id: number;
+    title: string;
+    artist: string;
+    catno: string;
+    format: string;
+    status: SubmissionStatus;
+    resource_url: string;
+    thumb: string;
+    year: number;
+    /** @remarks Undocumented; returned by the live API. */
+    stats?: MasterVersionStats;
+}
+
+/** Response of {@link DatabaseResource.getLabelReleases}. */
+export declare type LabelReleasesResponse = Paginated<'releases', LabelRelease>;
+
+/**
+ * A list with its items.
+ *
+ * @remarks Field names differ from {@link ListSummary} — see the module description.
+ */
+export declare interface ListDetail {
+    list_id: number;
+    name: string;
+    description: string;
+    public: boolean;
+    created_ts: string;
+    modified_ts: string;
+    url: string;
+    resource_url: string;
+    items: ListItem[];
+    /** @remarks Undocumented; returned by the live API. */
+    image_url?: string;
+    /** @remarks Undocumented; returned by the live API. */
+    user?: {
+        id: number;
+        username: string;
+        resource_url: string;
+    };
+}
+
+/**
+ * A Marketplace listing.
+ *
+ * Fields marked "owner only" are returned only when the request is authenticated as the
+ * listing's seller.
+ *
+ * @see https://www.discogs.com/developers/#page:marketplace,header:marketplace-listing
+ */
+export declare interface Listing {
+    id: number;
+    status: ListingStatusFilter;
+    resource_url: string;
+    uri: string;
+    condition: MediaCondition;
+    sleeve_condition?: SleeveCondition;
+    comments: string;
+    /** ISO 8601 timestamp of when the listing was posted. */
+    posted: string;
+    ships_from: string;
+    allow_offers: boolean;
+    audio: boolean;
+    price: Price;
+    original_price?: OriginalPrice;
+    shipping_price?: Price;
+    original_shipping_price?: OriginalPrice;
+    seller: ListingSeller;
+    release: ListingRelease;
+    /** Owner only. Shipping weight in grams. */
+    weight?: number;
+    /** Owner only. How many items this listing counts as for shipping purposes. */
+    format_quantity?: number;
+    /** Owner only. Seller-private reference, shown as "Private Comments" on the website. */
+    external_id?: string;
+    /** Owner only. Seller-private physical storage location. */
+    location?: string;
+    /** Owner only. Always `1` for NearMint sellers, for whom it is read-only. */
+    quantity?: number;
+    /** Only present for authenticated users. */
+    in_cart?: boolean;
+    /** @remarks Undocumented; returned by the live API. */
+    ships_from_country_code?: string;
+}
+
+/** Every {@link ListingStatusFilter}, as enumerated by the API's own 422 error message. */
+export declare const LISTING_STATUS_FILTERS: readonly ListingStatusFilter[];
+
+/** The release a listing refers to. */
+export declare interface ListingRelease {
+    id: number;
+    description: string;
+    resource_url: string;
+    thumbnail: string;
+    catalog_number: string;
+    year: number;
+    /** Present on some listings only. */
+    artist?: string;
+    /** Present on some listings only. */
+    title?: string;
+    /** Present on some listings only. */
+    format?: string;
+    /** @remarks Undocumented; returned by the live API. */
+    stats?: {
+        community?: {
+            in_collection: number;
+            in_wantlist: number;
+        };
+    };
+}
+
+/** The seller of a listing. Richer on {@link Listing} than on inventory entries. */
+export declare interface ListingSeller extends UserIdRef {
+    avatar_url?: string;
+    url?: string;
+    /** Free-text shipping policy. */
+    shipping?: string;
+    /** Free-text accepted payment methods. */
+    payment?: string;
+    stats?: SellerStats;
+    /** @remarks Undocumented; returned by the live API. */
+    html_url?: string;
+    /** @remarks Undocumented; returned by the live API. */
+    uid?: number;
+    /** @remarks Undocumented; returned by the live API. */
+    min_order_total?: number;
+}
+
+/** Listing statuses that can be set when creating or editing a listing. */
+export declare type ListingStatus = 'For Sale' | 'Draft';
+
+/** Listing statuses accepted as an inventory filter. */
+export declare type ListingStatusFilter = 'All' | 'Deleted' | 'Draft' | 'Expired' | 'For Sale' | 'Sold' | 'Suspended' | 'Violation';
+
+/** An entry in a list. */
+export declare interface ListItem {
+    id: number;
+    /** The kind of database object this entry points at. */
+    type: 'release' | 'master' | 'artist' | 'label';
+    display_title: string;
+    comment: string;
+    uri: string;
+    image_url: string;
+    resource_url: string;
+    /** @remarks Undocumented; returned by the live API. */
+    stats?: {
+        community?: {
+            in_collection: number;
+            in_wantlist: number;
+        };
+    };
+}
+
+/** Query parameters for {@link MarketplaceResource.listOrders}. */
+export declare interface ListOrdersParams extends PaginationParams {
+    status?: OrderStatusFilter;
+    /** ISO 8601 timestamp, e.g. `"2019-06-24T20:58:58Z"`. */
+    created_after?: string;
+    /** ISO 8601 timestamp. */
+    created_before?: string;
+    /** When omitted, both archived and unarchived orders are returned. */
+    archived?: boolean;
+    sort?: OrderSort;
+    sort_order?: SortOrder;
+}
+
+/**
+ * User list endpoints.
+ *
+ * Reachable as `client.lists`.
+ */
+export declare class ListsResource {
+    #private;
+    constructor(client: DiscogsClient);
+    /**
+     * Lists a user's lists. Private lists are only returned when authenticated as the owner.
+     *
+     * @see https://www.discogs.com/developers/#page:user-lists,header:user-lists-user-lists
+     */
+    getUserLists(username: string, params?: PaginationParams): Promise<UserListsResponse>;
+    /**
+     * Gets a list and its items. Private lists are only returned when authenticated as the
+     * owner.
+     *
+     * @remarks This endpoint names its fields differently from the index endpoint —
+     * `created_ts` / `modified_ts` / `list_id` / `url` rather than
+     * `date_added` / `date_changed` / `id` / `uri`.
+     *
+     * @see https://www.discogs.com/developers/#page:user-lists,header:user-lists-list
+     */
+    getList(listId: number | string): Promise<ListDetail>;
+}
+
+/** A list as returned by the per-user index endpoint. */
+export declare interface ListSummary {
+    id: number;
+    name: string;
+    description: string;
+    public: boolean;
+    date_added: string;
+    date_changed: string;
+    uri: string;
+    resource_url: string;
+    /** @remarks Undocumented; returned by the live API. */
+    image_url?: string;
+}
+
+/** The Discogs commission on a sale. */
+export declare type MarketplaceFee = Price;
+
+/**
+ * Marketplace endpoints.
+ *
+ * Reachable as `client.marketplace`.
+ */
+export declare class MarketplaceResource {
+    #private;
+    constructor(client: DiscogsClient);
+    /**
+     * Lists the listings in a user's inventory.
+     *
+     * Unless authenticated as the inventory's owner, only `For Sale` items are returned and the
+     * seller-private fields (`weight`, `format_quantity`, `external_id`, `location`,
+     * `quantity`) are omitted.
+     *
+     * @see https://www.discogs.com/developers/#page:marketplace,header:marketplace-inventory
+     */
+    getInventory(username: string, params?: GetInventoryParams): Promise<InventoryResponse>;
+    /**
+     * Gets a listing.
+     *
+     * @see https://www.discogs.com/developers/#page:marketplace,header:marketplace-listing
+     */
+    getListing(listingId: number, params?: GetListingParams): Promise<Listing>;
+    /**
+     * Creates a listing in the authenticated user's inventory.
+     *
+     * @see https://www.discogs.com/developers/#page:marketplace,header:marketplace-new-listing
+     */
+    createListing(params: CreateListingParams): Promise<CreateListingResponse>;
+    /**
+     * Edits a listing. Requires authentication as the listing's owner.
+     *
+     * Listings whose status is not `For Sale`, `Draft` or `Expired` cannot be edited, only
+     * deleted; a `Sold` listing has to be replaced with a new one.
+     *
+     * @see https://www.discogs.com/developers/#page:marketplace,header:marketplace-listing-post
+     */
+    editListing(listingId: number, params: EditListingParams): Promise<void>;
+    /**
+     * Permanently removes a listing. Requires authentication as the listing's owner.
+     *
+     * @see https://www.discogs.com/developers/#page:marketplace,header:marketplace-listing-delete
+     */
+    deleteListing(listingId: number): Promise<void>;
+    /**
+     * Gets an order. Requires authentication as the seller.
+     *
+     * @param orderId - Order ids are strings of the form `"1-1"`.
+     *
+     * @see https://www.discogs.com/developers/#page:marketplace,header:marketplace-order
+     */
+    getOrder(orderId: string): Promise<Order>;
+    /**
+     * Edits an order. Requires authentication as the seller.
+     *
+     * The new `status` must appear in the order's current `next_status` array. Setting
+     * `shipping` invoices the buyer and forces the status to `Invoice Sent`, so `shipping` and
+     * `status` cannot be sent together. Changing the status through this endpoint always
+     * messages the buyer with a fixed "Seller changed status from … to …" note — use
+     * {@link MarketplaceResource.addOrderMessage} to combine a status change with your own text.
+     *
+     * @see https://www.discogs.com/developers/#page:marketplace,header:marketplace-order-post
+     */
+    editOrder(orderId: string, params: EditOrderParams): Promise<Order>;
+    /**
+     * Lists the authenticated user's orders.
+     *
+     * @see https://www.discogs.com/developers/#page:marketplace,header:marketplace-list-orders
+     */
+    listOrders(params?: ListOrdersParams): Promise<OrdersResponse>;
+    /**
+     * Lists an order's messages, most recent first. Requires authentication as the seller.
+     *
+     * Entries are discriminated by their `type` field.
+     *
+     * @see https://www.discogs.com/developers/#page:marketplace,header:marketplace-list-orders-get
+     */
+    getOrderMessages(orderId: string, params?: PaginationParams): Promise<OrderMessagesResponse>;
+    /**
+     * Adds a message to an order's message log, optionally changing the order status at the
+     * same time. At least one of `message` or `status` must be supplied.
+     *
+     * @see https://www.discogs.com/developers/#page:marketplace,header:marketplace-list-orders-post
+     */
+    addOrderMessage(orderId: string, params: AddOrderMessageParams): Promise<AddOrderMessageResponse>;
+    /**
+     * Calculates the Discogs commission on a sale price, in the given currency (USD by default).
+     *
+     * @remarks The price is formatted to exactly two decimal places, because the endpoint
+     * requires it: `/marketplace/fee/20` returns a 404 while `/marketplace/fee/20.00` succeeds.
+     * The Discogs docs only ever show `10.00` and never state this, so passing a bare integer
+     * is an easy mistake to make.
+     *
+     * @see https://www.discogs.com/developers/#page:marketplace,header:marketplace-fee
+     */
+    getFee(price: number, currency?: Currency): Promise<MarketplaceFee>;
+    /**
+     * Gets suggested prices per media condition for a release, in the user's selling currency.
+     *
+     * Requires authentication, and the user must have completed their seller settings. Returns
+     * an empty object when Discogs has no suggestions for the release.
+     *
+     * @see https://www.discogs.com/developers/#page:marketplace,header:marketplace-price-suggestions
+     */
+    getPriceSuggestions(releaseId: number): Promise<PriceSuggestions>;
+    /**
+     * Gets marketplace statistics for a release: how many copies are for sale and the lowest
+     * listed price.
+     *
+     * `lowest_price` and `num_for_sale` are `null` when nothing is for sale or the release is
+     * blocked from sale.
+     *
+     * @see https://www.discogs.com/developers/#page:marketplace,header:marketplace-release-statistics
+     */
+    getReleaseStats(releaseId: number, params?: GetMarketplaceStatsParams): Promise<MarketplaceStats>;
+}
+
+/**
+ * Marketplace statistics for a release.
+ *
+ * `lowest_price` and `num_for_sale` are `null` when nothing is for sale, or when the release
+ * is blocked from sale.
+ */
+export declare interface MarketplaceStats {
+    lowest_price: Price | null;
+    num_for_sale: number | null;
+    blocked_from_sale: boolean;
+}
+
+/**
+ * A master release — the abstract "album" that groups together all its versions.
+ *
+ * @see https://www.discogs.com/developers/#page:database,header:database-master-release
+ */
+export declare interface Master {
+    id: number;
+    title: string;
+    resource_url: string;
+    uri: string;
+    versions_url: string;
+    main_release: number;
+    main_release_url: string;
+    artists: ArtistCredit[];
+    genres: string[];
+    styles?: string[];
+    tracklist: Track[];
+    images?: Image_2[];
+    videos?: Video[];
+    year: number;
+    data_quality: DataQuality;
+    num_for_sale: number;
+    lowest_price: number | null;
+    /** @remarks Undocumented; returned by the live API. */
+    most_recent_release?: number;
+    /** @remarks Undocumented; returned by the live API. */
+    most_recent_release_url?: string;
+}
+
+/** One release that is a version of a master release. */
+export declare interface MasterVersion {
+    id: number;
+    title: string;
+    status: SubmissionStatus;
+    resource_url: string;
+    thumb: string;
+    format: string;
+    major_formats: string[];
+    label: string;
+    catno: string;
+    country: string;
+    released: string;
+    stats: MasterVersionStats;
+}
+
+/** Sort keys accepted by {@link DatabaseResource.getMasterVersions}. */
+export declare type MasterVersionSort = 'released' | 'title' | 'format' | 'label' | 'catno' | 'country';
+
+/** Response of {@link DatabaseResource.getMasterVersions}. */
+export declare type MasterVersionsResponse = Paginated<'versions', MasterVersion>;
+
+/** Collection/wantlist counts for a master version, split by viewer and community. */
+export declare interface MasterVersionStats {
+    user: {
+        in_collection: number;
+        in_wantlist: number;
+    };
+    community: {
+        in_collection: number;
+        in_wantlist: number;
+    };
+}
+
+/** Maximum number of items Discogs will return per page. */
+export declare const MAX_PER_PAGE = 100;
+
+/** Every {@link MediaCondition}, best to worst. */
+export declare const MEDIA_CONDITIONS: readonly MediaCondition[];
+
+/** Goldmine grading for the media itself. */
+export declare type MediaCondition = 'Mint (M)' | 'Near Mint (NM or M-)' | 'Very Good Plus (VG+)' | 'Very Good (VG)' | 'Good Plus (G+)' | 'Good (G)' | 'Fair (F)' | 'Poor (P)';
+
+/** The three response representations Discogs offers, selected via the `Accept` header. */
+export declare type MediaType = 'discogs' | 'html' | 'plaintext';
+
+/**
+ * Signs requests with a full OAuth 1.0a access token, authenticating as the user who granted
+ * access.
+ *
+ * Obtain the access token and secret with {@link DiscogsOAuth}; they do not expire unless the
+ * user revokes them.
+ */
+export declare class OAuth1Auth implements AuthStrategy {
+    #private;
+    constructor(credentials: OAuthCredentials, options?: OAuthNonceOptions);
+    authorize(request: AuthorizableRequest): Promise<void>;
+}
+
+/**
+ * Credentials for a completed OAuth 1.0a flow. Authenticates as the user who granted access.
+ */
+export declare interface OAuthCredentials extends ConsumerCredentials {
+    /** The OAuth access token obtained at the end of the three-legged flow. */
+    accessToken: string;
+    /** The matching access token secret. */
+    accessTokenSecret: string;
+    /**
+     * Signature method to sign requests with. Defaults to `"PLAINTEXT"`, which is what the
+     * Discogs documentation recommends (all traffic is over HTTPS anyway).
+     */
+    signatureMethod?: OAuthSignatureMethod;
+}
+
+/** Injection points used by the tests to make signatures deterministic. */
+export declare interface OAuthNonceOptions {
+    /** Overrides nonce generation. Defaults to 16 random bytes, hex-encoded. */
+    nonce?: () => string;
+    /** Overrides the timestamp. Defaults to the current Unix time in seconds. */
+    timestamp?: () => string;
+}
+
+/** OAuth 1.0a signature methods supported by Discogs. */
+export declare type OAuthSignatureMethod = 'PLAINTEXT' | 'HMAC-SHA1';
+
+/**
+ * A Marketplace order.
+ *
+ * @see https://www.discogs.com/developers/#page:marketplace,header:marketplace-order
+ */
+export declare interface Order {
+    /** Order ids are strings of the form `"1-1"`, not numbers. */
+    id: string;
+    resource_url: string;
+    messages_url: string;
+    uri: string;
+    status: OrderStatusFilter;
+    /**
+     * The statuses this order may legally transition to. Discogs rejects any status not in this
+     * list, and the set is computed per order — there is no static transition table.
+     */
+    next_status: OrderStatus[];
+    items: OrderItem[];
+    buyer: UserIdRef;
+    seller: UserIdRef;
+    total: Price;
+    fee: Price;
+    shipping: OrderShipping;
+    shipping_address: string;
+    additional_instructions?: string;
+    archived: boolean;
+    created: string;
+    last_activity: string;
+    tracking?: OrderTracking;
+}
+
+/** Every {@link OrderStatusFilter}. */
+export declare const ORDER_STATUS_FILTERS: readonly OrderStatusFilter[];
+
+/** Every {@link OrderStatus} a seller may set. */
+export declare const ORDER_STATUSES: readonly OrderStatus[];
+
+/** A single item within an order. */
+export declare interface OrderItem {
+    id: number;
+    release: {
+        id: number;
+        description: string;
+        /** Present on {@link MarketplaceResource.listOrders} results. */
+        resource_url?: string;
+        /** Present on {@link MarketplaceResource.listOrders} results. */
+        thumbnail?: string;
+    };
+    price: Price;
+    media_condition?: MediaCondition;
+    sleeve_condition?: SleeveCondition;
+}
+
+/** An entry in an order's message log, discriminated by `type`. */
+export declare type OrderMessage = OrderRefundReceivedMessage | OrderRefundSentMessage | OrderTextMessage | OrderStatusMessage | OrderShippingMessage;
+
+/** Fields shared by every order message variant. */
+export declare interface OrderMessageBase {
+    timestamp: string;
+    message: string;
+    subject: string;
+    order: {
+        id: string;
+        resource_url: string;
+    };
+}
+
+/** Response of {@link MarketplaceResource.getOrderMessages}. */
+export declare type OrderMessagesResponse = Paginated<'messages', OrderMessage>;
+
+/** A refund the buyer received. */
+export declare interface OrderRefundReceivedMessage extends OrderMessageBase {
+    type: 'refund_received';
+    refund: {
+        amount: number;
+        order: {
+            id: string;
+            resource_url: string;
+        };
+    };
+}
+
+/** A refund the seller sent. */
+export declare interface OrderRefundSentMessage extends OrderMessageBase {
+    type: 'refund_sent';
+    refund: {
+        amount: number;
+        order: {
+            id: string;
+            resource_url: string;
+        };
+    };
+}
+
+/** Shipping cost on an order. Carries a `method` alongside the usual price fields. */
+export declare interface OrderShipping extends Price {
+    method: string;
+}
+
+/** An automatic message recording a shipping price change. */
+export declare interface OrderShippingMessage extends OrderMessageBase {
+    type: 'shipping';
+    original: number;
+    new: number;
+}
+
+/** Sort keys accepted by {@link MarketplaceResource.listOrders}. */
+export declare type OrderSort = 'id' | 'buyer' | 'created' | 'status' | 'last_activity';
+
+/** Response of {@link MarketplaceResource.listOrders}. */
+export declare type OrdersResponse = Paginated<'orders', Order>;
+
+/** Order statuses a seller may set. */
+export declare type OrderStatus = 'New Order' | 'Buyer Contacted' | 'Invoice Sent' | 'Payment Pending' | 'Payment Received' | 'In Progress' | 'Shipped' | 'Refund Sent' | 'Cancelled (Non-Paying Buyer)' | 'Cancelled (Item Unavailable)' | "Cancelled (Per Buyer's Request)";
+
+/** Order statuses accepted as a filter by {@link MarketplaceResource.listOrders}. */
+export declare type OrderStatusFilter = OrderStatus | 'All' | 'Merged' | 'Order Changed' | 'Cancelled' | 'Cancelled (Refund Received)';
+
+/** An automatic message recording a status change. */
+export declare interface OrderStatusMessage extends OrderMessageBase {
+    type: 'status';
+    /** Numeric status code, e.g. `1` order created, `3` invoice sent, `5` paid, `6` shipped. */
+    status_id: number;
+    actor: {
+        username: string;
+        resource_url: string;
+    };
+}
+
+/** A free-text message from the buyer or seller. */
+export declare interface OrderTextMessage extends OrderMessageBase {
+    type: 'message';
+    from: {
+        id: number;
+        username: string;
+        avatar_url: string;
+        resource_url: string;
+    };
+}
+
+/** Shipment tracking attached to an order. */
+export declare interface OrderTracking {
+    number: string;
+    carrier?: TrackingCarrier;
+    /** Auto-generated by Discogs from the carrier and tracking number. */
+    url?: string;
+}
+
+/**
+ * A monetary amount in the *seller's* original currency, returned alongside the converted
+ * {@link Price} on listing resources.
+ */
+export declare interface OriginalPrice {
+    curr_abbr: Currency;
+    curr_id: number;
+    formatted: string;
+    value: number;
+}
+
+/**
+ * A paginated response envelope.
+ *
+ * Discogs names the collection key differently per endpoint (`releases`, `listings`, `wants`,
+ * `items`, …), so the key is a type parameter.
+ *
+ * @typeParam K - Name of the key holding the collection.
+ * @typeParam T - Element type of the collection.
+ */
+export declare type Paginated<K extends string, T> = {
+    pagination: Pagination;
+} & {
+    [P in K]: T[];
+};
+
+/** The `pagination` object attached to every paginated response. */
+export declare interface Pagination {
+    /** The page currently being viewed. */
+    page: number;
+    /** Total number of pages available. */
+    pages: number;
+    /** Total number of items across all pages. */
+    items: number;
+    /** Number of items on each page. */
+    per_page: number;
+    urls: PaginationUrls;
+}
+
+/** Pagination parameters accepted by every paginated endpoint. */
+export declare interface PaginationParams {
+    /** 1-based page number. Defaults to `1`. */
+    page?: number;
+    /** Items per page. Defaults to `50`, maximum `100`. */
+    per_page?: number;
+}
+
+/** Links to other pages of a paginated result. May be an empty object on single-page results. */
+export declare interface PaginationUrls {
+    first?: string;
+    prev?: string;
+    next?: string;
+    last?: string;
+}
+
+/**
+ * Parses an RFC 5988 `Link` header into its `rel` relations.
+ *
+ * The same information is available in the body's `pagination.urls`, so this is mainly useful
+ * when you are working with a raw {@link Response} from {@link DiscogsClient.request}.
+ *
+ * @param header - Raw `Link` header value, or `null` when absent.
+ * @returns A map of relation name to URL. Empty when the header is absent or unparseable.
+ *
+ * @example
+ * ```ts
+ * parseLinkHeader('<https://api.discogs.com/artists/1/releases?page=2>; rel=next')
+ * // → { next: 'https://api.discogs.com/artists/1/releases?page=2' }
+ * ```
+ */
+export declare function parseLinkHeader(header: string | null | undefined): PaginationUrls;
+
+/**
+ * Reads the rate-limit headers off a response.
+ *
+ * @returns The parsed rate-limit state, or `null` when the headers are absent — which happens
+ * on endpoints Discogs does not throttle, and on responses served from a cache.
+ */
+export declare function parseRateLimit(headers: Headers): RateLimit | null;
+
+/** A monetary amount as returned by most Marketplace endpoints. */
+export declare interface Price {
+    currency: Currency;
+    value: number;
+}
+
+/**
+ * Suggested prices keyed by media condition, denominated in the user's selling currency.
+ *
+ * An empty object is returned when Discogs has no suggestions for the release.
+ */
+export declare type PriceSuggestions = Partial<Record<MediaCondition, Price>>;
+
+/** A bag of query-string parameters. `null` and `undefined` values are dropped. */
+export declare type QueryParams = Record<string, QueryValue>;
+
+/** Query-string values the serializer knows how to render. */
+export declare type QueryValue = string | number | boolean | null | undefined | Array<string | number>;
+
+/** Header carrying the total request allowance for the current window. */
+export declare const RATE_LIMIT_HEADER = "X-Discogs-Ratelimit";
+
+/** Header carrying the number of requests still available in the current window. */
+export declare const RATE_LIMIT_REMAINING_HEADER = "X-Discogs-Ratelimit-Remaining";
+
+/** Header carrying the number of requests already used in the current window. */
+export declare const RATE_LIMIT_USED_HEADER = "X-Discogs-Ratelimit-Used";
+
+/**
+ * Rate-limit state parsed from the `X-Discogs-Ratelimit*` response headers.
+ *
+ * Discogs throttles by source IP over a rolling 60-second window: 60 requests per minute when
+ * authenticated, 25 when not.
+ *
+ * @see https://www.discogs.com/developers/#page:home,header:home-rate-limiting
+ */
+export declare interface RateLimit {
+    /** Total number of requests permitted in the current one-minute window. */
+    limit: number;
+    /** Requests already made in the current window. */
+    used: number;
+    /** Requests still available in the current window. */
+    remaining: number;
+}
+
+/**
+ * A release — a particular physical or digital object released by one or more artists.
+ *
+ * @see https://www.discogs.com/developers/#page:database,header:database-release
+ */
+export declare interface Release {
+    id: number;
+    title: string;
+    status: SubmissionStatus;
+    data_quality: DataQuality;
+    resource_url: string;
+    uri: string;
+    artists: ArtistCredit[];
+    /** @remarks Undocumented; returned by the live API. Artists joined into a sortable string. */
+    artists_sort?: string;
+    extraartists?: ArtistCredit[];
+    labels: LabelCredit[];
+    companies: CompanyCredit[];
+    series: SeriesEntry[];
+    formats: Format[];
+    format_quantity: number;
+    identifiers: Identifier[];
+    genres: string[];
+    styles?: string[];
+    tracklist: Track[];
+    images?: Image_2[];
+    videos?: Video[];
+    community: ReleaseCommunity;
+    country?: string;
+    released?: string;
+    released_formatted?: string;
+    year: number;
+    notes?: string;
+    /** Estimated shipping weight in grams. */
+    estimated_weight?: number;
+    date_added: string;
+    date_changed: string;
+    master_id?: number;
+    master_url?: string;
+    thumb: string;
+    num_for_sale: number;
+    lowest_price: number | null;
+    /** @remarks Undocumented; returned by the live API. */
+    blocked_from_sale?: boolean;
+    /** @remarks Undocumented; returned by the live API. */
+    is_offensive?: boolean;
+}
+
+/** Community metadata attached to a release. */
+export declare interface ReleaseCommunity {
+    have: number;
+    want: number;
+    rating: CommunityRating;
+    status: SubmissionStatus;
+    data_quality: DataQuality;
+    submitter: UserRef;
+    contributors: UserRef[];
+}
+
+/** A user's rating of a release. */
+export declare interface ReleaseRating {
+    username: string;
+    release_id: number;
+    /** 1–5, or `0` when the user has not rated the release. */
+    rating: number;
+}
+
+/**
+ * "Have" and "want" counts for a release.
+ *
+ * @remarks Both fields may be absent for blocked releases; the live API also returns
+ * `is_offensive` on this endpoint.
+ */
+export declare interface ReleaseStats {
+    num_have?: number;
+    num_want?: number;
+    /** @remarks Undocumented; returned by the live API. */
+    is_offensive?: boolean;
+}
+
+/** Options for a single request. */
+export declare interface RequestOptions {
+    method?: HttpMethod;
+    /** Path relative to the base URL, e.g. `"/releases/249504"`. */
+    path: string;
+    query?: QueryParams;
+    /** Body to send as JSON. Mutually exclusive with `formData`. */
+    body?: unknown;
+    /** Body to send as `multipart/form-data`. Mutually exclusive with `body`. */
+    formData?: FormData;
+    /** Extra headers, merged over the defaults. */
+    headers?: HeadersInit;
+    /** Aborts the request. */
+    signal?: AbortSignal;
+    /**
+     * How to read the response body. `"json"` parses JSON, `"text"` returns the raw string,
+     * `"none"` skips reading entirely and leaves the body for you.
+     */
+    responseType?: 'json' | 'text' | 'none';
+}
+
+/** A temporary request token, valid for 15 minutes. */
+export declare interface RequestToken {
+    oauthToken: string;
+    oauthTokenSecret: string;
+    /** Discogs confirms it honoured the callback URL you supplied. */
+    callbackConfirmed: boolean;
+}
+
+/**
+ * Query parameters for {@link DatabaseResource.search}.
+ *
+ * Every field is optional, but at least one should be supplied for a meaningful result.
+ *
+ * @see https://www.discogs.com/developers/#page:database,header:database-search
+ */
+export declare interface SearchParams extends PaginationParams {
+    /** Free-text search query. Sent on the wire as `q`. */
+    q?: string;
+    /** Restrict results to a single resource type. */
+    type?: SearchType;
+    /** Search the combined `"Artist Name - Release Title"` field. */
+    title?: string;
+    /** Search release titles. */
+    release_title?: string;
+    /** Search release credits. */
+    credit?: string;
+    /** Search artist names. */
+    artist?: string;
+    /** Search artist name variations (ANV). */
+    anv?: string;
+    /** Search label names. */
+    label?: string;
+    /** Search genres. */
+    genre?: string;
+    /** Search styles. */
+    style?: string;
+    /** Search release country. */
+    country?: string;
+    /** Search release year. */
+    year?: string | number;
+    /** Search formats. */
+    format?: string;
+    /** Search catalogue numbers. */
+    catno?: string;
+    /** Search barcodes. */
+    barcode?: string;
+    /** Search track titles. */
+    track?: string;
+    /** Search by submitter username. */
+    submitter?: string;
+    /** Search by contributor username. */
+    contributor?: string;
+}
+
+/** Response of {@link DatabaseResource.search}. */
+export declare type SearchResponse = Paginated<'results', SearchResult>;
+
+/**
+ * A single search result.
+ *
+ * Which fields are populated depends on the `type` of the result, so nearly everything is
+ * optional.
+ */
+export declare interface SearchResult {
+    id: number;
+    type: SearchType;
+    title: string;
+    uri: string;
+    resource_url: string;
+    thumb: string;
+    /** @remarks Undocumented; returned by the live API. */
+    cover_image?: string;
+    /** Release year as a string — Discogs does not return a number here. */
+    year?: string;
+    country?: string;
+    catno?: string;
+    label?: string[];
+    genre?: string[];
+    style?: string[];
+    format?: string[];
+    barcode?: string[];
+    community?: {
+        want: number;
+        have: number;
+    };
+    /** @remarks Undocumented; returned by the live API for release results. */
+    master_id?: number | null;
+    /** @remarks Undocumented; returned by the live API for release results. */
+    master_url?: string | null;
+    /** @remarks Undocumented; returned by the live API for release results. */
+    formats?: Format[];
+    /** @remarks Undocumented; returned by the live API when authenticated. */
+    user_data?: {
+        in_wantlist: boolean;
+        in_collection: boolean;
+    };
+}
+
+/** Resource types that can be searched. */
+export declare type SearchType = 'release' | 'master' | 'artist' | 'label';
+
+/** Seller rating summary. */
+export declare interface SellerStats {
+    /** Percentage rating, returned as a string (e.g. `"100"`). */
+    rating: string;
+    stars: number;
+    total: number;
+}
+
+/** An entry in the `series` array of a release. */
+export declare interface SeriesEntry {
+    id: number;
+    name: string;
+    catno: string;
+    entity_type: string;
+    entity_type_name?: string;
+    resource_url: string;
+    /** @remarks Undocumented; returned by the live API on some resources. */
+    thumbnail_url?: string;
+}
+
+/** Every {@link SleeveCondition}. */
+export declare const SLEEVE_CONDITIONS: readonly SleeveCondition[];
+
+/** Grading for the sleeve: any {@link MediaCondition}, plus three sleeve-specific values. */
+export declare type SleeveCondition = MediaCondition | 'Generic' | 'Not Graded' | 'No Cover';
+
+/** Sort direction accepted by every endpoint that takes a `sort` parameter. */
+export declare type SortOrder = 'asc' | 'desc';
+
+/** An artist entry in a user's submissions. */
+export declare interface SubmissionArtist {
+    id: number;
+    name: string;
+    namevariations: string[];
+    data_quality: string;
+    releases_url: string;
+    resource_url: string;
+    uri: string;
+}
+
+/** A label entry in a user's submissions. */
+export declare interface SubmissionLabel {
+    id: number;
+    name: string;
+    profile?: string;
+    releases_url: string;
+    resource_url: string;
+    uri: string;
+    data_quality: string;
+}
+
+/** The database entries a user has submitted, grouped by resource type. */
+export declare interface Submissions {
+    artists: SubmissionArtist[];
+    labels: SubmissionLabel[];
+    releases: Release[];
+}
+
+/**
+ * Response of {@link UserResource.getSubmissions}.
+ *
+ * Unlike other paginated endpoints the collection key holds an object grouping three arrays,
+ * not a single array, so {@link Paginated} does not apply here.
+ */
+export declare interface SubmissionsResponse {
+    pagination: Pagination;
+    submissions: Submissions;
+}
+
+/** Submission status of a database entry, e.g. `"Accepted"`. */
+export declare type SubmissionStatus = string;
+
+/**
+ * Authenticates with a personal access token.
+ *
+ * Sends `Authorization: Discogs token=<token>`. This authenticates as the token holder and
+ * only as the token holder — use {@link OAuth1Auth} to act on behalf of other users.
+ *
+ * @see https://www.discogs.com/developers/#page:authentication,header:authentication-discogs-auth-flow
+ */
+export declare class TokenAuth implements AuthStrategy {
+    #private;
+    constructor(token: string);
+    authorize(request: AuthorizableRequest): void;
+}
+
+/** Credentials for a personal access token, generated in Discogs Developer Settings. */
+export declare interface TokenCredentials {
+    /** A personal access token. Authenticates as the token holder. */
+    token: string;
+}
+
+/** A single entry in a release or master tracklist. */
+export declare interface Track {
+    position: string;
+    /** Trailing underscore is part of the wire format. Usually `"track"` or `"heading"`. */
+    type_: string;
+    title: string;
+    duration: string;
+    artists?: ArtistCredit[];
+    extraartists?: ArtistCredit[];
+}
+
+/** Every {@link TrackingCarrier}. */
+export declare const TRACKING_CARRIERS: readonly TrackingCarrier[];
+
+/** Carriers Discogs can generate a tracking URL for. */
+export declare type TrackingCarrier = 'UPS' | 'USPS' | 'DHL' | 'Deutsche Post' | 'La Poste' | 'Royal Mail' | 'PostNL' | 'DHL Germany' | 'Other';
+
+/** Reference to a user that also carries their numeric id. */
+export declare interface UserIdRef extends UserRef {
+    id: number;
+}
+
+/** Response of {@link ListsResource.getUserLists}. */
+export declare type UserListsResponse = Paginated<'lists', ListSummary>;
+
+/**
+ * A user profile.
+ *
+ * `email` is only returned when authenticated as this user. `num_collection` and
+ * `num_wantlist` are only returned when authenticated as this user or when the respective
+ * list is public, and `num_lists` only counts private lists for the owner.
+ *
+ * @see https://www.discogs.com/developers/#page:user-identity,header:user-identity-profile
+ */
+export declare interface UserProfile {
+    id: number;
+    username: string;
+    /** The user's real name. */
+    name?: string;
+    /** Only visible when authenticated as this user. */
+    email?: string;
+    /** Profile text, which may contain BBCode. */
+    profile: string;
+    home_page: string;
+    location: string;
+    /** ISO 8601 registration timestamp. */
+    registered: string;
+    rank: number;
+    uri: string;
+    resource_url: string;
+    inventory_url: string;
+    wantlist_url: string;
+    collection_folders_url: string;
+    collection_fields_url: string;
+    avatar_url: string;
+    /** @remarks Not returned by the profile-edit endpoint. */
+    banner_url?: string;
+    num_lists: number;
+    num_for_sale: number;
+    num_collection?: number;
+    num_wantlist?: number;
+    num_pending: number;
+    releases_contributed: number;
+    releases_rated: number;
+    rating_avg: number;
+    /** The user's preferred currency. Not returned by the profile-edit endpoint. */
+    curr_abbr?: Currency;
+    buyer_rating?: number;
+    buyer_rating_stars?: number;
+    buyer_num_ratings?: number;
+    seller_rating?: number;
+    seller_rating_stars?: number;
+    seller_num_ratings?: number;
+    /** @remarks Undocumented; returned by the live API. Unread message count, owner only. */
+    num_unread?: number;
+    /** @remarks Undocumented; returned by the live API. */
+    activated?: boolean;
+    /** @remarks Undocumented; returned by the live API. */
+    marketplace_suspended?: boolean;
+    /** @remarks Undocumented; returned by the live API. */
+    is_staff?: boolean;
+    /** @remarks Undocumented; returned by the live API. */
+    seller_payment_disabled?: boolean;
+}
+
+/** Minimal reference to a user, as embedded in other resources. */
+export declare interface UserRef {
+    username: string;
+    resource_url: string;
+}
+
+/**
+ * User identity endpoints.
+ *
+ * Reachable as `client.user`.
+ */
+export declare class UserResource {
+    #private;
+    constructor(client: DiscogsClient);
+    /**
+     * Gets basic information about the authenticated user — useful as a credentials check at
+     * the end of the OAuth flow.
+     *
+     * @see https://www.discogs.com/developers/#page:user-identity,header:user-identity-identity
+     */
+    getIdentity(): Promise<Identity>;
+    /**
+     * Gets a user's profile.
+     *
+     * `email` is only returned when authenticated as this user; `num_collection` and
+     * `num_wantlist` only when authenticated as this user or when the list in question is
+     * public.
+     *
+     * @see https://www.discogs.com/developers/#page:user-identity,header:user-identity-profile
+     */
+    getProfile(username: string): Promise<UserProfile>;
+    /**
+     * Edits a user's profile. Requires authentication as that user.
+     *
+     * @see https://www.discogs.com/developers/#page:user-identity,header:user-identity-profile-post
+     */
+    editProfile(username: string, params: EditProfileParams): Promise<UserProfile>;
+    /**
+     * Lists the database entries a user has submitted, grouped into artists, labels and
+     * releases.
+     *
+     * @see https://www.discogs.com/developers/#page:user-identity,header:user-identity-user-submissions
+     */
+    getSubmissions(username: string, params?: PaginationParams): Promise<SubmissionsResponse>;
+    /**
+     * Lists a user's contributions — the releases they have edited or added to.
+     *
+     * @see https://www.discogs.com/developers/#page:user-identity,header:user-identity-user-contributions
+     */
+    getContributions(username: string, params?: GetContributionsParams): Promise<ContributionsResponse>;
+}
+
+/** An embedded video (usually YouTube) attached to a release, master or artist. */
+export declare interface Video {
+    uri: string;
+    title: string;
+    description: string;
+    /** Duration in seconds. */
+    duration: number;
+    embed: boolean;
+}
+
+/**
+ * A release on a user's wantlist.
+ *
+ * @remarks `notes` here is a plain string and is only visible to the wantlist owner — on
+ * collection items, by contrast, `notes` is an array of custom field values.
+ */
+export declare interface WantlistItem {
+    /** The release id. */
+    id: number;
+    resource_url: string;
+    /** 0–5, where `0` means unrated. */
+    rating: number;
+    /** Only visible when authenticated as the wantlist owner. */
+    notes?: string;
+    basic_information: BasicInformation;
+}
+
+/** Parameters accepted when adding to or editing an entry on the wantlist. */
+export declare interface WantlistItemParams {
+    /** User notes to associate with this release. */
+    notes?: string;
+    /** The user's rating of this release, from 0 (unrated) to 5 (best). Defaults to `0`. */
+    rating?: number;
+}
+
+/**
+ * User wantlist endpoints.
+ *
+ * Reachable as `client.wantlist`.
+ */
+export declare class WantlistResource {
+    #private;
+    constructor(client: DiscogsClient);
+    /**
+     * Lists the releases on a user's wantlist.
+     *
+     * A private wantlist requires authentication as its owner, and the `notes` field is only
+     * returned to the owner.
+     *
+     * @see https://www.discogs.com/developers/#page:user-wantlist,header:user-wantlist-wantlist
+     */
+    getWants(username: string, params?: PaginationParams): Promise<WantlistResponse>;
+    /**
+     * Adds a release to a user's wantlist. Requires authentication as the wantlist owner.
+     *
+     * @see https://www.discogs.com/developers/#page:user-wantlist,header:user-wantlist-add-to-wantlist
+     */
+    addToWantlist(username: string, releaseId: number, params?: WantlistItemParams): Promise<WantlistItem>;
+    /**
+     * Edits the notes or rating on a wantlist entry. Requires authentication as the owner.
+     *
+     * @see https://www.discogs.com/developers/#page:user-wantlist,header:user-wantlist-add-to-wantlist-post
+     */
+    editWantlistItem(username: string, releaseId: number, params?: WantlistItemParams): Promise<WantlistItem>;
+    /**
+     * Removes a release from a user's wantlist. Requires authentication as the owner.
+     *
+     * @see https://www.discogs.com/developers/#page:user-wantlist,header:user-wantlist-add-to-wantlist-delete
+     */
+    removeFromWantlist(username: string, releaseId: number): Promise<void>;
+}
+
+/** Response of {@link WantlistResource.getWants}. */
+export declare type WantlistResponse = Paginated<'wants', WantlistItem>;
+
+export { }