discogs-typescript 0.1.0

package/dist/index.js

@@ -0,0 +1,1739 @@
+//#region src/auth/token.ts
+/**
+* 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
+*/
+var TokenAuth = class {
+	#token;
+	constructor(token) {
+		if (!token) throw new TypeError("A personal access token is required.");
+		this.#token = token;
+	}
+	authorize(request) {
+		request.headers.set("Authorization", `Discogs token=${this.#token}`);
+	}
+};
+//#endregion
+//#region src/auth/key-secret.ts
+/**
+* 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
+*/
+var KeySecretAuth = class {
+	#key;
+	#secret;
+	constructor(consumerKey, consumerSecret) {
+		if (!consumerKey || !consumerSecret) throw new TypeError("Both a consumer key and a consumer secret are required.");
+		this.#key = consumerKey;
+		this.#secret = consumerSecret;
+	}
+	authorize(request) {
+		request.headers.set("Authorization", `Discogs key=${this.#key}, secret=${this.#secret}`);
+	}
+};
+//#endregion
+//#region src/auth/oauth.ts
+/**
+* Percent-encodes a value per RFC 3986, which is stricter than `encodeURIComponent`:
+* `!`, `'`, `(`, `)` and `*` must be escaped too.
+*
+* @internal
+*/
+function percentEncode(value) {
+	return encodeURIComponent(value).replace(/[!'()*]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`);
+}
+/**
+* Generates a random nonce.
+*
+* @internal
+*/
+function generateNonce() {
+	const bytes = /* @__PURE__ */ new Uint8Array(16);
+	crypto.getRandomValues(bytes);
+	return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+/**
+* Current Unix timestamp in seconds, as a string.
+*
+* @internal
+*/
+function currentTimestamp() {
+	return Math.floor(Date.now() / 1e3).toString();
+}
+/**
+* Builds the signature base string defined by RFC 5849 §3.4.1.
+*
+* Query-string parameters participate in the signature; JSON and multipart request bodies do
+* not, which covers every Discogs endpoint this client talks to.
+*
+* @internal
+*/
+function buildSignatureBaseString(method, url, oauthParams) {
+	const base = `${url.origin}${url.pathname}`;
+	const pairs = [];
+	for (const [key, value] of url.searchParams) pairs.push([key, value]);
+	for (const [key, value] of Object.entries(oauthParams)) pairs.push([key, value]);
+	const byteCompare = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+	const normalized = pairs.map(([key, value]) => [percentEncode(key), percentEncode(value)]).sort(([keyA, valueA], [keyB, valueB]) => keyA === keyB ? byteCompare(valueA, valueB) : byteCompare(keyA, keyB)).map(([key, value]) => `${key}=${value}`).join("&");
+	return [
+		method.toUpperCase(),
+		percentEncode(base),
+		percentEncode(normalized)
+	].join("&");
+}
+/**
+* The signing key: the percent-encoded consumer secret and token secret, joined by `&`.
+*
+* @internal
+*/
+function buildSigningKey(consumerSecret, tokenSecret = "") {
+	return `${percentEncode(consumerSecret)}&${percentEncode(tokenSecret)}`;
+}
+/**
+* Computes an HMAC-SHA1 signature and returns it base64-encoded.
+*
+* @internal
+*/
+async function hmacSha1(key, message) {
+	const encoder = new TextEncoder();
+	const cryptoKey = await crypto.subtle.importKey("raw", encoder.encode(key), {
+		name: "HMAC",
+		hash: "SHA-1"
+	}, false, ["sign"]);
+	const signature = await crypto.subtle.sign("HMAC", cryptoKey, encoder.encode(message));
+	let binary = "";
+	for (const byte of new Uint8Array(signature)) binary += String.fromCharCode(byte);
+	return btoa(binary);
+}
+/**
+* Computes the `oauth_signature` value for a request.
+*
+* @internal
+*/
+async function signRequest(options) {
+	const key = buildSigningKey(options.consumerSecret, options.tokenSecret);
+	if (options.signatureMethod === "PLAINTEXT") return key;
+	return hmacSha1(key, buildSignatureBaseString(options.method, options.url, options.oauthParams));
+}
+/**
+* Assembles an `Authorization: OAuth …` header value from a set of parameters.
+*
+* @internal
+*/
+function buildAuthorizationHeader(params) {
+	return `OAuth ${Object.entries(params).map(([key, value]) => `${percentEncode(key)}="${percentEncode(value)}"`).join(", ")}`;
+}
+/**
+* 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.
+*/
+var OAuth1Auth = class {
+	#consumerKey;
+	#consumerSecret;
+	#accessToken;
+	#accessTokenSecret;
+	#signatureMethod;
+	#nonce;
+	#timestamp;
+	constructor(credentials, options = {}) {
+		const { consumerKey, consumerSecret, accessToken, accessTokenSecret } = credentials;
+		if (!consumerKey || !consumerSecret || !accessToken || !accessTokenSecret) throw new TypeError("OAuth authentication requires consumerKey, consumerSecret, accessToken and accessTokenSecret.");
+		this.#consumerKey = consumerKey;
+		this.#consumerSecret = consumerSecret;
+		this.#accessToken = accessToken;
+		this.#accessTokenSecret = accessTokenSecret;
+		this.#signatureMethod = credentials.signatureMethod ?? "PLAINTEXT";
+		this.#nonce = options.nonce ?? generateNonce;
+		this.#timestamp = options.timestamp ?? currentTimestamp;
+	}
+	async authorize(request) {
+		const params = {
+			oauth_consumer_key: this.#consumerKey,
+			oauth_token: this.#accessToken,
+			oauth_signature_method: this.#signatureMethod,
+			oauth_timestamp: this.#timestamp(),
+			oauth_nonce: this.#nonce(),
+			oauth_version: "1.0"
+		};
+		const signature = await signRequest({
+			method: request.method,
+			url: request.url,
+			oauthParams: params,
+			consumerSecret: this.#consumerSecret,
+			tokenSecret: this.#accessTokenSecret,
+			signatureMethod: this.#signatureMethod
+		});
+		request.headers.set("Authorization", buildAuthorizationHeader({
+			...params,
+			oauth_signature: signature
+		}));
+	}
+};
+//#endregion
+//#region src/errors.ts
+/**
+* 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.
+*/
+var DiscogsError = class extends Error {
+	/** HTTP status code of the failing response. */
+	status;
+	/** The raw response object. */
+	response;
+	/** Parsed response body, when it could be read. */
+	body;
+	constructor(message, options) {
+		super(message);
+		this.name = new.target.name;
+		this.status = options.status;
+		this.response = options.response;
+		this.body = options.body;
+	}
+};
+/** 401 — the resource requires authentication, or the supplied credentials were rejected. */
+var DiscogsAuthenticationError = class extends DiscogsError {};
+/** 403 — authenticated, but not allowed to access or modify this resource. */
+var DiscogsPermissionError = class extends DiscogsError {};
+/** 404 — the resource does not exist. */
+var DiscogsNotFoundError = class extends DiscogsError {};
+/** 405 — the HTTP verb is not supported for this resource (e.g. `PUT /artists/1`). */
+var DiscogsMethodNotAllowedError = class extends DiscogsError {};
+/**
+* 422 — the request was well-formed but semantically wrong: a missing or mistyped parameter,
+* an invalid enum value, or a nonsensical action.
+*/
+var DiscogsValidationError = class 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.
+*/
+var DiscogsRateLimitError = class extends DiscogsError {
+	/** Rate-limit headers from the rejected response, when present. */
+	rateLimit;
+	constructor(message, options) {
+		super(message, options);
+		this.rateLimit = options.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.
+*/
+var DiscogsServerError = class extends DiscogsError {};
+/**
+* Extracts the human-readable message from a Discogs error body.
+*
+* @internal
+*/
+function extractMessage(body, response) {
+	if (typeof body === "object" && body !== null && "message" in body) {
+		const { message } = body;
+		if (typeof message === "string" && message.length > 0) return message;
+	}
+	if (typeof body === "string" && body.trim().length > 0) return body.trim();
+	return response.statusText || `Request failed with status ${String(response.status)}`;
+}
+/**
+* Builds the appropriate {@link DiscogsError} subclass for a failed response.
+*
+* @internal
+*/
+function createDiscogsError(response, body, rateLimit) {
+	const message = extractMessage(body, response);
+	const options = {
+		status: response.status,
+		response,
+		body
+	};
+	switch (response.status) {
+		case 401: return new DiscogsAuthenticationError(message, options);
+		case 403: return new DiscogsPermissionError(message, options);
+		case 404: return new DiscogsNotFoundError(message, options);
+		case 405: return new DiscogsMethodNotAllowedError(message, options);
+		case 422: return new DiscogsValidationError(message, options);
+		case 429: return new DiscogsRateLimitError(message, {
+			...options,
+			rateLimit
+		});
+		default:
+			if (response.status >= 500) return new DiscogsServerError(message, options);
+			return new DiscogsError(message, options);
+	}
+}
+//#endregion
+//#region src/rate-limit.ts
+/** Header carrying the total request allowance for the current window. */
+var RATE_LIMIT_HEADER = "X-Discogs-Ratelimit";
+/** Header carrying the number of requests already used in the current window. */
+var RATE_LIMIT_USED_HEADER = "X-Discogs-Ratelimit-Used";
+/** Header carrying the number of requests still available in the current window. */
+var RATE_LIMIT_REMAINING_HEADER = "X-Discogs-Ratelimit-Remaining";
+function readInt(headers, name) {
+	const raw = headers.get(name);
+	if (raw === null) return null;
+	const value = Number.parseInt(raw, 10);
+	return Number.isNaN(value) ? null : value;
+}
+/**
+* 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.
+*/
+function parseRateLimit(headers) {
+	const limit = readInt(headers, RATE_LIMIT_HEADER);
+	const used = readInt(headers, RATE_LIMIT_USED_HEADER);
+	const remaining = readInt(headers, RATE_LIMIT_REMAINING_HEADER);
+	if (limit === null && used === null && remaining === null) return null;
+	return {
+		limit: limit ?? 0,
+		used: used ?? 0,
+		remaining: remaining ?? 0
+	};
+}
+/** Default base URL of the Discogs website, which hosts the authorize page. */
+var DEFAULT_WEBSITE_URL = "https://www.discogs.com";
+/**
+* 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,
+*   },
+* });
+* ```
+*/
+var DiscogsOAuth = class {
+	#consumerKey;
+	#consumerSecret;
+	#userAgent;
+	#signatureMethod;
+	#baseUrl;
+	#websiteUrl;
+	#fetch;
+	#nonce;
+	#timestamp;
+	constructor(config) {
+		if (!config.consumerKey || !config.consumerSecret) throw new TypeError("DiscogsOAuth requires a consumerKey and a consumerSecret.");
+		if (!config.userAgent) throw new TypeError("DiscogsOAuth requires a userAgent. Discogs returns an empty response without one.");
+		this.#consumerKey = config.consumerKey;
+		this.#consumerSecret = config.consumerSecret;
+		this.#userAgent = config.userAgent;
+		this.#signatureMethod = config.signatureMethod ?? "PLAINTEXT";
+		this.#baseUrl = (config.baseUrl ?? "https://api.discogs.com").replace(/\/+$/, "");
+		this.#websiteUrl = (config.websiteUrl ?? "https://www.discogs.com").replace(/\/+$/, "");
+		this.#fetch = config.fetch ?? globalThis.fetch.bind(globalThis);
+		this.#nonce = config.nonce ?? generateNonce;
+		this.#timestamp = config.timestamp ?? currentTimestamp;
+	}
+	/**
+	* 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.
+	*/
+	async getRequestToken(callbackUrl) {
+		const url = new URL("/oauth/request_token", `${this.#baseUrl}/`);
+		const body = await this.#send("GET", url, { oauth_callback: callbackUrl });
+		const token = body.get("oauth_token");
+		const secret = body.get("oauth_token_secret");
+		if (token === null || secret === null) throw new Error(`Discogs did not return an oauth_token pair from ${url.pathname}: "${body.toString()}"`);
+		return {
+			oauthToken: token,
+			oauthTokenSecret: secret,
+			callbackConfirmed: body.get("oauth_callback_confirmed") === "true"
+		};
+	}
+	/**
+	* 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) {
+		const url = new URL("/oauth/authorize", `${this.#websiteUrl}/`);
+		url.searchParams.set("oauth_token", requestToken);
+		return url.toString();
+	}
+	/**
+	* 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.
+	*/
+	async getAccessToken(params) {
+		const url = new URL("/oauth/access_token", `${this.#baseUrl}/`);
+		const body = await this.#send("POST", url, {
+			oauth_token: params.oauthToken,
+			oauth_verifier: params.verifier
+		}, params.oauthTokenSecret);
+		const token = body.get("oauth_token");
+		const secret = body.get("oauth_token_secret");
+		if (token === null || secret === null) throw new Error(`Discogs did not return an oauth_token pair from ${url.pathname}: "${body.toString()}"`);
+		return {
+			oauthToken: token,
+			oauthTokenSecret: secret
+		};
+	}
+	/**
+	* Signs and sends a token request, returning the form-encoded response body.
+	*
+	* Both token endpoints answer with `application/x-www-form-urlencoded`, not JSON.
+	*/
+	async #send(method, url, extraParams, tokenSecret = "") {
+		const params = {
+			oauth_consumer_key: this.#consumerKey,
+			oauth_signature_method: this.#signatureMethod,
+			oauth_timestamp: this.#timestamp(),
+			oauth_nonce: this.#nonce(),
+			oauth_version: "1.0",
+			...extraParams
+		};
+		const signature = await signRequest({
+			method,
+			url,
+			oauthParams: params,
+			consumerSecret: this.#consumerSecret,
+			tokenSecret,
+			signatureMethod: this.#signatureMethod
+		});
+		const response = await this.#fetch(url.toString(), {
+			method,
+			headers: {
+				Authorization: buildAuthorizationHeader({
+					...params,
+					oauth_signature: signature
+				}),
+				"Content-Type": "application/x-www-form-urlencoded",
+				"User-Agent": this.#userAgent
+			}
+		});
+		const text = await response.text();
+		if (!response.ok) throw createDiscogsError(response, text, parseRateLimit(response.headers));
+		return new URLSearchParams(text);
+	}
+};
+//#endregion
+//#region src/auth/index.ts
+function isAuthStrategy(value) {
+	return typeof value.authorize === "function";
+}
+/**
+* Turns the client's `auth` option into a concrete {@link AuthStrategy}.
+*
+* Accepts a personal token, a consumer key/secret pair, a full set of OAuth credentials, or a
+* strategy object you built yourself.
+*
+* @internal
+*/
+function resolveAuth(auth) {
+	if (isAuthStrategy(auth)) return auth;
+	if ("token" in auth) return new TokenAuth(auth.token);
+	if ("accessToken" in auth) return new OAuth1Auth(auth);
+	if ("consumerKey" in auth) return new KeySecretAuth(auth.consumerKey, auth.consumerSecret);
+	throw new TypeError("Unrecognised auth option. Supply { token }, { consumerKey, consumerSecret }, { consumerKey, consumerSecret, accessToken, accessTokenSecret }, or an AuthStrategy.");
+}
+//#endregion
+//#region src/http.ts
+/**
+* Appends parameters to a URL's query string, skipping `null` and `undefined` and repeating
+* the key for array values.
+*
+* @internal
+*/
+function appendQuery(url, query) {
+	if (!query) return;
+	for (const [key, value] of Object.entries(query)) {
+		if (value === null || value === void 0) continue;
+		if (Array.isArray(value)) for (const item of value) url.searchParams.append(key, String(item));
+		else url.searchParams.append(key, String(value));
+	}
+}
+/**
+* Percent-encodes a value for use as a single path segment.
+*
+* Usernames may contain characters such as `.` and `+` that must survive the round trip.
+*
+* @internal
+*/
+function encodePathSegment(value) {
+	return encodeURIComponent(String(value));
+}
+/**
+* Sends a request to the Discogs API and returns the parsed body plus its metadata.
+*
+* Non-2xx responses are thrown as a {@link DiscogsError}. `304 Not Modified` is treated as a
+* success with a `null` body, so conditional requests against the inventory export and upload
+* status endpoints work as intended.
+*
+* @internal
+*/
+async function sendRequest(config, options) {
+	const method = options.method ?? "GET";
+	const url = new URL(options.path.replace(/^\//, ""), `${config.baseUrl}/`);
+	appendQuery(url, options.query);
+	const headers = new Headers(options.headers);
+	headers.set("User-Agent", config.userAgent);
+	if (!headers.has("Accept")) headers.set("Accept", `application/vnd.discogs.v2.${config.mediaType}+json`);
+	let body;
+	if (options.formData) body = options.formData;
+	else if (options.body !== void 0) {
+		body = JSON.stringify(options.body);
+		headers.set("Content-Type", "application/json");
+	}
+	await config.auth?.authorize({
+		method,
+		url,
+		headers
+	});
+	const init = {
+		method,
+		headers
+	};
+	if (body !== void 0) init.body = body;
+	if (options.signal) init.signal = options.signal;
+	const response = await config.fetch(url.toString(), init);
+	const rateLimit = parseRateLimit(response.headers);
+	config.onResponse?.({
+		response,
+		rateLimit
+	});
+	const responseType = options.responseType ?? "json";
+	if (response.status === 304) return {
+		data: null,
+		response,
+		rateLimit
+	};
+	if (!response.ok) throw createDiscogsError(response, await readErrorBody(response), rateLimit);
+	if (responseType === "none" || response.status === 204) return {
+		data: null,
+		response,
+		rateLimit
+	};
+	if (responseType === "text") return {
+		data: await response.text(),
+		response,
+		rateLimit
+	};
+	const text = await response.text();
+	if (text.length === 0) return {
+		data: null,
+		response,
+		rateLimit
+	};
+	return {
+		data: JSON.parse(text),
+		response,
+		rateLimit
+	};
+}
+/**
+* Reads a failed response's body as JSON, falling back to text, and to `undefined` when the
+* body cannot be read at all.
+*
+* @internal
+*/
+async function readErrorBody(response) {
+	let text;
+	try {
+		text = await response.text();
+	} catch {
+		return;
+	}
+	if (text.length === 0) return void 0;
+	try {
+		return JSON.parse(text);
+	} catch {
+		return text;
+	}
+}
+//#endregion
+//#region src/resources/collection.ts
+/**
+* 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`.
+*/
+var CollectionResource = class {
+	#client;
+	constructor(client) {
+		this.#client = client;
+	}
+	/**
+	* 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) {
+		return this.#client.requestData({ path: `/users/${encodePathSegment(username)}/collection/folders` });
+	}
+	/**
+	* 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, name) {
+		return this.#client.requestData({
+			method: "POST",
+			path: `/users/${encodePathSegment(username)}/collection/folders`,
+			body: { name }
+		});
+	}
+	/**
+	* 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, folderId) {
+		return this.#client.requestData({ path: `/users/${encodePathSegment(username)}/collection/folders/${encodePathSegment(folderId)}` });
+	}
+	/**
+	* 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, folderId, name) {
+		return this.#client.requestData({
+			method: "POST",
+			path: `/users/${encodePathSegment(username)}/collection/folders/${encodePathSegment(folderId)}`,
+			body: { name }
+		});
+	}
+	/**
+	* 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, folderId) {
+		return this.#client.requestData({
+			method: "DELETE",
+			path: `/users/${encodePathSegment(username)}/collection/folders/${encodePathSegment(folderId)}`,
+			responseType: "none"
+		});
+	}
+	/**
+	* 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, releaseId, params = {}) {
+		return this.#client.requestData({
+			path: `/users/${encodePathSegment(username)}/collection/releases/${encodePathSegment(releaseId)}`,
+			query: params
+		});
+	}
+	/**
+	* 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, folderId, params = {}) {
+		return this.#client.requestData({
+			path: `/users/${encodePathSegment(username)}/collection/folders/${encodePathSegment(folderId)}/releases`,
+			query: params
+		});
+	}
+	/**
+	* 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, folderId, releaseId) {
+		return this.#client.requestData({
+			method: "POST",
+			path: `/users/${encodePathSegment(username)}/collection/folders/${encodePathSegment(folderId)}/releases/${encodePathSegment(releaseId)}`
+		});
+	}
+	/**
+	* 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, folderId, releaseId, instanceId, params) {
+		return this.#client.requestData({
+			method: "POST",
+			path: `/users/${encodePathSegment(username)}/collection/folders/${encodePathSegment(folderId)}/releases/${encodePathSegment(releaseId)}/instances/${encodePathSegment(instanceId)}`,
+			body: params,
+			responseType: "none"
+		});
+	}
+	/**
+	* 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, folderId, releaseId, instanceId) {
+		return this.#client.requestData({
+			method: "DELETE",
+			path: `/users/${encodePathSegment(username)}/collection/folders/${encodePathSegment(folderId)}/releases/${encodePathSegment(releaseId)}/instances/${encodePathSegment(instanceId)}`,
+			responseType: "none"
+		});
+	}
+	/**
+	* 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) {
+		return this.#client.requestData({ path: `/users/${encodePathSegment(username)}/collection/fields` });
+	}
+	/**
+	* 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, folderId, releaseId, instanceId, fieldId, value) {
+		return this.#client.requestData({
+			method: "POST",
+			path: `/users/${encodePathSegment(username)}/collection/folders/${encodePathSegment(folderId)}/releases/${encodePathSegment(releaseId)}/instances/${encodePathSegment(instanceId)}/fields/${encodePathSegment(fieldId)}`,
+			query: { value },
+			responseType: "none"
+		});
+	}
+	/**
+	* 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) {
+		return this.#client.requestData({ path: `/users/${encodePathSegment(username)}/collection/value` });
+	}
+};
+//#endregion
+//#region src/resources/database.ts
+/**
+* Database endpoints.
+*
+* Reachable as `client.database`.
+*/
+var DatabaseResource = class {
+	#client;
+	constructor(client) {
+		this.#client = client;
+	}
+	/**
+	* 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, params = {}) {
+		return this.#client.requestData({
+			path: `/releases/${encodePathSegment(releaseId)}`,
+			query: params
+		});
+	}
+	/**
+	* 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, username) {
+		return this.#client.requestData({ path: `/releases/${encodePathSegment(releaseId)}/rating/${encodePathSegment(username)}` });
+	}
+	/**
+	* 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, username, rating) {
+		return this.#client.requestData({
+			method: "PUT",
+			path: `/releases/${encodePathSegment(releaseId)}/rating/${encodePathSegment(username)}`,
+			body: { rating }
+		});
+	}
+	/**
+	* 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, username) {
+		return this.#client.requestData({
+			method: "DELETE",
+			path: `/releases/${encodePathSegment(releaseId)}/rating/${encodePathSegment(username)}`,
+			responseType: "none"
+		});
+	}
+	/**
+	* 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) {
+		return this.#client.requestData({ path: `/releases/${encodePathSegment(releaseId)}/rating` });
+	}
+	/**
+	* Gets the "have" and "want" counts for a release.
+	*
+	* @see https://www.discogs.com/developers/#page:database,header:database-release-stats
+	*/
+	getReleaseStats(releaseId) {
+		return this.#client.requestData({ path: `/releases/${encodePathSegment(releaseId)}/stats` });
+	}
+	/**
+	* Gets a master release.
+	*
+	* @see https://www.discogs.com/developers/#page:database,header:database-master-release
+	*/
+	getMaster(masterId) {
+		return this.#client.requestData({ path: `/masters/${encodePathSegment(masterId)}` });
+	}
+	/**
+	* 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, params = {}) {
+		return this.#client.requestData({
+			path: `/masters/${encodePathSegment(masterId)}/versions`,
+			query: params
+		});
+	}
+	/**
+	* Gets an artist.
+	*
+	* @see https://www.discogs.com/developers/#page:database,header:database-artist
+	*/
+	getArtist(artistId) {
+		return this.#client.requestData({ path: `/artists/${encodePathSegment(artistId)}` });
+	}
+	/**
+	* 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, params = {}) {
+		return this.#client.requestData({
+			path: `/artists/${encodePathSegment(artistId)}/releases`,
+			query: params
+		});
+	}
+	/**
+	* Gets a label.
+	*
+	* @see https://www.discogs.com/developers/#page:database,header:database-label
+	*/
+	getLabel(labelId) {
+		return this.#client.requestData({ path: `/labels/${encodePathSegment(labelId)}` });
+	}
+	/**
+	* Lists the releases associated with a label.
+	*
+	* @see https://www.discogs.com/developers/#page:database,header:database-all-label-releases
+	*/
+	getLabelReleases(labelId, params = {}) {
+		return this.#client.requestData({
+			path: `/labels/${encodePathSegment(labelId)}/releases`,
+			query: params
+		});
+	}
+	/**
+	* 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 = {}) {
+		return this.#client.requestData({
+			path: "/database/search",
+			query: params
+		});
+	}
+};
+//#endregion
+//#region src/resources/inventory-export.ts
+/**
+* Inventory export endpoints.
+*
+* Reachable as `client.inventoryExport`.
+*/
+var InventoryExportResource = class {
+	#client;
+	constructor(client) {
+		this.#client = client;
+	}
+	/**
+	* 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
+	*/
+	async create() {
+		const { response } = await this.#client.request({
+			method: "POST",
+			path: "/inventory/export",
+			responseType: "none"
+		});
+		const location = response.headers.get("Location");
+		const match = location === null ? null : /\/inventory\/export\/(\d+)/.exec(location);
+		return {
+			id: match?.[1] === void 0 ? null : Number.parseInt(match[1], 10),
+			location
+		};
+	}
+	/**
+	* 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 = {}) {
+		return this.#client.requestData({
+			path: "/inventory/export",
+			query: params
+		});
+	}
+	/**
+	* 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, options = {}) {
+		return this.#client.requestData({
+			path: `/inventory/export/${encodePathSegment(exportId)}`,
+			headers: buildConditionalHeaders(options)
+		});
+	}
+	/**
+	* Downloads a finished export as CSV text.
+	*
+	* @see https://www.discogs.com/developers/#page:inventory-export,header:inventory-export-download-an-export
+	*/
+	downloadCsv(exportId) {
+		return this.#client.requestData({
+			path: `/inventory/export/${encodePathSegment(exportId)}/download`,
+			headers: { Accept: "text/csv" },
+			responseType: "text"
+		});
+	}
+	/**
+	* 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
+	*/
+	async downloadRaw(exportId) {
+		const { response } = await this.#client.request({
+			path: `/inventory/export/${encodePathSegment(exportId)}/download`,
+			headers: { Accept: "text/csv" },
+			responseType: "none"
+		});
+		return response;
+	}
+};
+/**
+* Builds the `If-Modified-Since` header for a conditional request.
+*
+* @internal
+*/
+function buildConditionalHeaders(options) {
+	if (options.ifModifiedSince === void 0) return {};
+	return { "If-Modified-Since": options.ifModifiedSince instanceof Date ? options.ifModifiedSince.toUTCString() : options.ifModifiedSince };
+}
+//#endregion
+//#region src/resources/inventory-upload.ts
+/**
+* Wraps a CSV payload in the `multipart/form-data` body Discogs expects, under the field name
+* `upload`.
+*
+* @internal
+*/
+function buildUploadFormData(csv, filename = "inventory.csv") {
+	const form = new FormData();
+	const blob = typeof csv === "string" ? new Blob([csv], { type: "text/csv" }) : csv;
+	form.append("upload", blob, filename);
+	return form;
+}
+/**
+* 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`.
+*/
+var InventoryUploadResource = class {
+	#client;
+	constructor(client) {
+		this.#client = client;
+	}
+	/**
+	* 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, filename) {
+		return this.#upload("add", csv, filename);
+	}
+	/**
+	* 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, filename) {
+		return this.#upload("change", csv, filename);
+	}
+	/**
+	* 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, filename) {
+		return this.#upload("delete", csv, filename);
+	}
+	/**
+	* 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 = {}) {
+		return this.#client.requestData({
+			path: "/inventory/upload",
+			query: params
+		});
+	}
+	/**
+	* 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, options = {}) {
+		return this.#client.requestData({
+			path: `/inventory/upload/${encodePathSegment(uploadId)}`,
+			headers: buildConditionalHeaders(options)
+		});
+	}
+	async #upload(kind, csv, filename) {
+		const { response } = await this.#client.request({
+			method: "POST",
+			path: `/inventory/upload/${kind}`,
+			formData: buildUploadFormData(csv, filename),
+			responseType: "none"
+		});
+		const location = response.headers.get("Location");
+		const match = location === null ? null : /\/inventory\/upload\/(\d+)/.exec(location);
+		return {
+			id: match?.[1] === void 0 ? null : Number.parseInt(match[1], 10),
+			location
+		};
+	}
+};
+//#endregion
+//#region src/resources/lists.ts
+/**
+* User list endpoints.
+*
+* Reachable as `client.lists`.
+*/
+var ListsResource = class {
+	#client;
+	constructor(client) {
+		this.#client = client;
+	}
+	/**
+	* 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, params = {}) {
+		return this.#client.requestData({
+			path: `/users/${encodePathSegment(username)}/lists`,
+			query: params
+		});
+	}
+	/**
+	* 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) {
+		return this.#client.requestData({ path: `/lists/${encodePathSegment(listId)}` });
+	}
+};
+//#endregion
+//#region src/resources/marketplace.ts
+/**
+* Marketplace endpoints.
+*
+* Reachable as `client.marketplace`.
+*/
+var MarketplaceResource = class {
+	#client;
+	constructor(client) {
+		this.#client = client;
+	}
+	/**
+	* 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, params = {}) {
+		return this.#client.requestData({
+			path: `/users/${encodePathSegment(username)}/inventory`,
+			query: params
+		});
+	}
+	/**
+	* Gets a listing.
+	*
+	* @see https://www.discogs.com/developers/#page:marketplace,header:marketplace-listing
+	*/
+	getListing(listingId, params = {}) {
+		return this.#client.requestData({
+			path: `/marketplace/listings/${encodePathSegment(listingId)}`,
+			query: params
+		});
+	}
+	/**
+	* Creates a listing in the authenticated user's inventory.
+	*
+	* @see https://www.discogs.com/developers/#page:marketplace,header:marketplace-new-listing
+	*/
+	createListing(params) {
+		return this.#client.requestData({
+			method: "POST",
+			path: "/marketplace/listings",
+			body: params
+		});
+	}
+	/**
+	* 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, params) {
+		return this.#client.requestData({
+			method: "POST",
+			path: `/marketplace/listings/${encodePathSegment(listingId)}`,
+			body: params,
+			responseType: "none"
+		});
+	}
+	/**
+	* 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) {
+		return this.#client.requestData({
+			method: "DELETE",
+			path: `/marketplace/listings/${encodePathSegment(listingId)}`,
+			responseType: "none"
+		});
+	}
+	/**
+	* 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) {
+		return this.#client.requestData({ path: `/marketplace/orders/${encodePathSegment(orderId)}` });
+	}
+	/**
+	* 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, params) {
+		return this.#client.requestData({
+			method: "POST",
+			path: `/marketplace/orders/${encodePathSegment(orderId)}`,
+			body: params
+		});
+	}
+	/**
+	* Lists the authenticated user's orders.
+	*
+	* @see https://www.discogs.com/developers/#page:marketplace,header:marketplace-list-orders
+	*/
+	listOrders(params = {}) {
+		return this.#client.requestData({
+			path: "/marketplace/orders",
+			query: params
+		});
+	}
+	/**
+	* 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, params = {}) {
+		return this.#client.requestData({
+			path: `/marketplace/orders/${encodePathSegment(orderId)}/messages`,
+			query: params
+		});
+	}
+	/**
+	* 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
+	*/
+	async addOrderMessage(orderId, params) {
+		if (params.message === void 0 && params.status === void 0) throw new TypeError("addOrderMessage requires at least one of \"message\" or \"status\".");
+		return this.#client.requestData({
+			method: "POST",
+			path: `/marketplace/orders/${encodePathSegment(orderId)}/messages`,
+			body: params
+		});
+	}
+	/**
+	* 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, currency) {
+		const amount = price.toFixed(2);
+		const path = currency === void 0 ? `/marketplace/fee/${amount}` : `/marketplace/fee/${amount}/${encodePathSegment(currency)}`;
+		return this.#client.requestData({ path });
+	}
+	/**
+	* 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) {
+		return this.#client.requestData({ path: `/marketplace/price_suggestions/${encodePathSegment(releaseId)}` });
+	}
+	/**
+	* 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, params = {}) {
+		return this.#client.requestData({
+			path: `/marketplace/stats/${encodePathSegment(releaseId)}`,
+			query: params
+		});
+	}
+};
+//#endregion
+//#region src/resources/user.ts
+/**
+* User identity endpoints.
+*
+* Reachable as `client.user`.
+*/
+var UserResource = class {
+	#client;
+	constructor(client) {
+		this.#client = client;
+	}
+	/**
+	* 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() {
+		return this.#client.requestData({ path: "/oauth/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) {
+		return this.#client.requestData({ path: `/users/${encodePathSegment(username)}` });
+	}
+	/**
+	* 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, params) {
+		return this.#client.requestData({
+			method: "POST",
+			path: `/users/${encodePathSegment(username)}`,
+			body: params
+		});
+	}
+	/**
+	* 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, params = {}) {
+		return this.#client.requestData({
+			path: `/users/${encodePathSegment(username)}/submissions`,
+			query: params
+		});
+	}
+	/**
+	* 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, params = {}) {
+		return this.#client.requestData({
+			path: `/users/${encodePathSegment(username)}/contributions`,
+			query: params
+		});
+	}
+};
+//#endregion
+//#region src/resources/wantlist.ts
+/**
+* User wantlist endpoints.
+*
+* Reachable as `client.wantlist`.
+*/
+var WantlistResource = class {
+	#client;
+	constructor(client) {
+		this.#client = client;
+	}
+	/**
+	* 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, params = {}) {
+		return this.#client.requestData({
+			path: `/users/${encodePathSegment(username)}/wants`,
+			query: params
+		});
+	}
+	/**
+	* 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, releaseId, params = {}) {
+		return this.#client.requestData({
+			method: "PUT",
+			path: `/users/${encodePathSegment(username)}/wants/${encodePathSegment(releaseId)}`,
+			query: params
+		});
+	}
+	/**
+	* 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, releaseId, params = {}) {
+		return this.#client.requestData({
+			method: "POST",
+			path: `/users/${encodePathSegment(username)}/wants/${encodePathSegment(releaseId)}`,
+			query: params
+		});
+	}
+	/**
+	* 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, releaseId) {
+		return this.#client.requestData({
+			method: "DELETE",
+			path: `/users/${encodePathSegment(username)}/wants/${encodePathSegment(releaseId)}`,
+			responseType: "none"
+		});
+	}
+};
+//#endregion
+//#region src/client.ts
+/**
+* The Discogs API client.
+*
+* @module
+*/
+/** Default base URL of the Discogs API. */
+var DEFAULT_BASE_URL = "https://api.discogs.com";
+/**
+* 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/
+*/
+var DiscogsClient = class {
+	/** Database: releases, masters, artists, labels and search. */
+	database;
+	/** Marketplace: inventory, listings, orders, fees, price suggestions and stats. */
+	marketplace;
+	/** Inventory export: request and download CSV exports of your inventory. */
+	inventoryExport;
+	/** Inventory upload: bulk add, change and delete listings from a CSV. */
+	inventoryUpload;
+	/** User identity: the authenticated user, profiles, submissions and contributions. */
+	user;
+	/** User collection: folders, items, custom fields and collection value. */
+	collection;
+	/** User wantlist. */
+	wantlist;
+	/** User lists. */
+	lists;
+	#config;
+	#rateLimit = null;
+	constructor(config) {
+		if (!config.userAgent) throw new TypeError("DiscogsClient requires a userAgent identifying your application. Discogs returns an empty response to requests without one.");
+		const auth = config.auth ? resolveAuth(config.auth) : null;
+		this.#config = {
+			baseUrl: (config.baseUrl ?? "https://api.discogs.com").replace(/\/+$/, ""),
+			userAgent: config.userAgent,
+			mediaType: config.mediaType ?? "discogs",
+			auth,
+			fetch: config.fetch ?? globalThis.fetch.bind(globalThis),
+			onResponse: (info) => {
+				this.#rateLimit = info.rateLimit ?? this.#rateLimit;
+				config.onResponse?.(info);
+			}
+		};
+		this.database = new DatabaseResource(this);
+		this.marketplace = new MarketplaceResource(this);
+		this.inventoryExport = new InventoryExportResource(this);
+		this.inventoryUpload = new InventoryUploadResource(this);
+		this.user = new UserResource(this);
+		this.collection = new CollectionResource(this);
+		this.wantlist = new WantlistResource(this);
+		this.lists = new ListsResource(this);
+	}
+	/**
+	* 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() {
+		return this.#rateLimit;
+	}
+	/**
+	* 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(options) {
+		return sendRequest(this.#config, options);
+	}
+	/**
+	* Sends a request and returns just the parsed body — what every resource method uses.
+	*
+	* @internal
+	*/
+	async requestData(options) {
+		const { data } = await sendRequest(this.#config, options);
+		return data;
+	}
+};
+//#endregion
+//#region src/pagination.ts
+/** Default number of items Discogs returns per page. */
+var DEFAULT_PER_PAGE = 50;
+/** Maximum number of items Discogs will return per page. */
+var MAX_PER_PAGE = 100;
+/**
+* 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' }
+* ```
+*/
+function parseLinkHeader(header) {
+	const urls = {};
+	if (!header) return urls;
+	for (const part of header.split(",")) {
+		const match = /<([^>]*)>\s*;\s*rel\s*=\s*"?([^";]+)"?/.exec(part.trim());
+		if (!match) continue;
+		const [, url, rel] = match;
+		if (url === void 0 || rel === void 0) continue;
+		switch (rel.trim()) {
+			case "first":
+				urls.first = url;
+				break;
+			case "prev":
+				urls.prev = url;
+				break;
+			case "next":
+				urls.next = url;
+				break;
+			case "last": urls.last = url;
+		}
+	}
+	return urls;
+}
+//#endregion
+//#region src/types/common.ts
+/** Every {@link Currency} value, in the order the Discogs docs list them. */
+var CURRENCIES = [
+	"USD",
+	"GBP",
+	"EUR",
+	"CAD",
+	"AUD",
+	"JPY",
+	"CHF",
+	"MXN",
+	"BRL",
+	"NZD",
+	"SEK",
+	"ZAR"
+];
+//#endregion
+//#region src/types/marketplace.ts
+/** Every {@link MediaCondition}, best to worst. */
+var MEDIA_CONDITIONS = [
+	"Mint (M)",
+	"Near Mint (NM or M-)",
+	"Very Good Plus (VG+)",
+	"Very Good (VG)",
+	"Good Plus (G+)",
+	"Good (G)",
+	"Fair (F)",
+	"Poor (P)"
+];
+/** Every {@link SleeveCondition}. */
+var SLEEVE_CONDITIONS = [
+	...MEDIA_CONDITIONS,
+	"Generic",
+	"Not Graded",
+	"No Cover"
+];
+/** Every {@link ListingStatusFilter}, as enumerated by the API's own 422 error message. */
+var LISTING_STATUS_FILTERS = [
+	"All",
+	"Deleted",
+	"Draft",
+	"Expired",
+	"For Sale",
+	"Sold",
+	"Suspended",
+	"Violation"
+];
+/** Every {@link OrderStatus} a seller may set. */
+var ORDER_STATUSES = [
+	"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)"
+];
+/** Every {@link OrderStatusFilter}. */
+var ORDER_STATUS_FILTERS = [
+	"All",
+	...ORDER_STATUSES,
+	"Merged",
+	"Order Changed",
+	"Cancelled",
+	"Cancelled (Refund Received)"
+];
+/** Every {@link TrackingCarrier}. */
+var TRACKING_CARRIERS = [
+	"UPS",
+	"USPS",
+	"DHL",
+	"Deutsche Post",
+	"La Poste",
+	"Royal Mail",
+	"PostNL",
+	"DHL Germany",
+	"Other"
+];
+//#endregion
+//#region src/types/collection.ts
+/** The permanent "All" folder, which lists every release in the collection. */
+var FOLDER_ALL = 0;
+/** The permanent "Uncategorized" folder, the default destination for new additions. */
+var FOLDER_UNCATEGORIZED = 1;
+//#endregion
+export { CURRENCIES, CollectionResource, DEFAULT_BASE_URL, DEFAULT_PER_PAGE, DEFAULT_WEBSITE_URL, DatabaseResource, DiscogsAuthenticationError, DiscogsClient, DiscogsError, DiscogsMethodNotAllowedError, DiscogsNotFoundError, DiscogsOAuth, DiscogsPermissionError, DiscogsRateLimitError, DiscogsServerError, DiscogsValidationError, FOLDER_ALL, FOLDER_UNCATEGORIZED, InventoryExportResource, InventoryUploadResource, KeySecretAuth, LISTING_STATUS_FILTERS, ListsResource, MAX_PER_PAGE, MEDIA_CONDITIONS, MarketplaceResource, OAuth1Auth, ORDER_STATUSES, ORDER_STATUS_FILTERS, RATE_LIMIT_HEADER, RATE_LIMIT_REMAINING_HEADER, RATE_LIMIT_USED_HEADER, SLEEVE_CONDITIONS, TRACKING_CARRIERS, TokenAuth, UserResource, WantlistResource, parseLinkHeader, parseRateLimit };
+
+//# sourceMappingURL=index.js.map