@hotcodepush/node 0.0.0-stage → 0.0.1

package/dist/index.mjs

@@ -0,0 +1,2269 @@
+//#region package.json
+var version = "0.0.0";
+//#endregion
+//#region src/errors.ts
+/**
+* Thrown when the API answers with a status outside 2xx.
+* `code`, `message` and `details` come from the API verbatim.
+* A response without the API error shape becomes `unexpected_response` with the status, and its body is dropped.
+*/
+var HotCodePushError = class extends Error {
+	code;
+	details;
+	status;
+	constructor(errorBody, status) {
+		super(errorBody.message);
+		this.code = errorBody.code;
+		this.details = errorBody.details;
+		this.name = "HotCodePushError";
+		this.status = status;
+	}
+};
+function isErrorBody(value) {
+	return typeof value === "object" && value !== null && "code" in value && typeof value.code === "string" && "message" in value && typeof value.message === "string";
+}
+function resolveErrorBody(text) {
+	try {
+		const body = JSON.parse(text);
+		return isErrorBody(body) ? body : void 0;
+	} catch {
+		return;
+	}
+}
+function resolveHotCodePushError(status, text) {
+	return new HotCodePushError(resolveErrorBody(text) ?? {
+		code: "unexpected_response",
+		message: `Request failed with status ${status}.`
+	}, status);
+}
+//#endregion
+//#region src/http-client.ts
+const COMMA_LIST_QUERY_NAMES = /* @__PURE__ */ new Set(["ids", "relations"]);
+const DEFAULT_BASE_URL = "https://api.hotcodepush.com";
+const DEFAULT_CLIENT = `node/${version}`;
+const IDEMPOTENT_METHODS = /* @__PURE__ */ new Set([
+	"DELETE",
+	"GET",
+	"PUT"
+]);
+const INITIAL_RETRY_DELAY_MS = 500;
+const JSON_TIMEOUT_MS = 6e4;
+const MAX_ATTEMPTS = 3;
+const MAX_RETRY_AFTER_MS = 6e4;
+const RETRY_AFTER_STATUSES = /* @__PURE__ */ new Set([429, 503]);
+const TOKEN_ENVIRONMENT_VARIABLE = "HOTCODEPUSH_TOKEN";
+const UPLOAD_TIMEOUT_MS = 6e5;
+var HttpClient = class {
+	baseUrl;
+	headers;
+	timeoutMs;
+	constructor(options) {
+		this.baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+		this.headers = resolveHeaders(options);
+		this.timeoutMs = options.timeout ?? JSON_TIMEOUT_MS;
+	}
+	async fetchBlob(options) {
+		const response = await this.fetchResponse(options);
+		await assertResponseOk(response);
+		return response.blob();
+	}
+	async fetchCreatingPost(options) {
+		return this.fetchJson({
+			body: options.body,
+			headers: { "Idempotency-Key": options.idempotencyKey ?? crypto.randomUUID() },
+			isRetryable: true,
+			method: "POST",
+			path: options.path
+		});
+	}
+	async fetchJson(options) {
+		return parseResponseBody(await this.fetchResponse(options));
+	}
+	async fetchStatus(options) {
+		const response = await this.fetchResponse(options);
+		await assertResponseOk(response);
+		await response.body?.cancel();
+	}
+	async fetchUpload(options) {
+		const fetchWithTimeout = withTimeout(fetch, UPLOAD_TIMEOUT_MS);
+		const fetchFunction = isBlobUploadBody(options) ? withRetry(fetchWithTimeout) : fetchWithTimeout;
+		const contentLength = isBlobUploadBody(options) ? options.body.size : options.contentLength;
+		return parseResponseBody(await fetchFunction(this.resolveRouteUrl(options.path), {
+			body: options.body,
+			duplex: "half",
+			headers: {
+				...this.headers,
+				"Content-Length": String(contentLength),
+				"Content-Type": options.contentType
+			},
+			method: "PUT"
+		}));
+	}
+	async fetchResponse(options) {
+		const fetchWithTimeout = withTimeout(fetch, this.timeoutMs);
+		return (options.isRetryable ?? IDEMPOTENT_METHODS.has(options.method) ? withRetry(fetchWithTimeout) : fetchWithTimeout)(this.resolveUrl(options), this.resolveRequestInit(options));
+	}
+	resolveRequestInit(options) {
+		const headers = {
+			...this.headers,
+			...options.headers
+		};
+		if (options.body === void 0) return {
+			headers,
+			method: options.method
+		};
+		return {
+			body: JSON.stringify(options.body),
+			headers: {
+				...headers,
+				"Content-Type": "application/json"
+			},
+			method: options.method
+		};
+	}
+	resolveRouteUrl(path) {
+		return new URL(this.baseUrl + path);
+	}
+	resolveUrl(options) {
+		const url = this.resolveRouteUrl(options.path);
+		for (const [name, value] of Object.entries(options.query ?? {})) for (const queryValue of resolveQueryValues(name, value)) url.searchParams.append(name, queryValue);
+		return url;
+	}
+};
+async function assertResponseOk(response) {
+	if (!response.ok) throw resolveHotCodePushError(response.status, await response.text());
+}
+function isBlobUploadBody(uploadBody) {
+	return uploadBody.body instanceof Blob;
+}
+function isRetryableStatus(status) {
+	return status === 408 || status === 429 || status >= 500;
+}
+async function parseResponseBody(response) {
+	await assertResponseOk(response);
+	const text = await response.text();
+	return text ? JSON.parse(text) : void 0;
+}
+function resolveHeaders(options) {
+	const headers = {
+		"Accept": "application/json",
+		"X-HotCodePush-Client": options.client ?? DEFAULT_CLIENT
+	};
+	const token = options.token || process.env[TOKEN_ENVIRONMENT_VARIABLE];
+	if (token) headers.Authorization = `Bearer ${token}`;
+	if (options.userAgent) headers["User-Agent"] = options.userAgent;
+	return headers;
+}
+function resolvePath(template, parameters = {}) {
+	return template.replace(/\{(\w+)\}/g, (_placeholder, name) => {
+		const parameter = parameters[name];
+		if (parameter === void 0) throw new Error(`The path parameter ${name} of ${template} is missing.`);
+		return encodeURIComponent(parameter);
+	});
+}
+function resolveQueryValues(name, value) {
+	if (value === void 0 || value === "") return [];
+	if (typeof value !== "object") return [String(value)];
+	if (COMMA_LIST_QUERY_NAMES.has(name)) return value.length === 0 ? [] : [value.join(",")];
+	return [...value];
+}
+function resolveRetryAfterMs(response) {
+	const retryAfter = response.headers.get("Retry-After")?.trim();
+	if (!RETRY_AFTER_STATUSES.has(response.status) || !retryAfter) return;
+	const retryAfterMs = /^\d+$/.test(retryAfter) ? Number(retryAfter) * 1e3 : Date.parse(retryAfter) - Date.now();
+	if (Number.isNaN(retryAfterMs)) return;
+	return Math.min(Math.max(retryAfterMs, 0), MAX_RETRY_AFTER_MS);
+}
+function sleep(milliseconds) {
+	return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+function withRetry(fetchFunction) {
+	return async (input, init) => {
+		for (let attempt = 1;; attempt++) {
+			const isLastAttempt = attempt === MAX_ATTEMPTS;
+			let retryAfterMs;
+			try {
+				const response = await fetchFunction(input, init);
+				if (isLastAttempt || !isRetryableStatus(response.status)) return response;
+				await response.body?.cancel();
+				retryAfterMs = resolveRetryAfterMs(response);
+			} catch (error) {
+				if (isLastAttempt) throw error;
+			}
+			await sleep(retryAfterMs ?? INITIAL_RETRY_DELAY_MS * 2 ** (attempt - 1));
+		}
+	};
+}
+function withTimeout(fetchFunction, timeoutMs) {
+	return (input, init) => fetchFunction(input, {
+		...init,
+		signal: AbortSignal.timeout(timeoutMs)
+	});
+}
+//#endregion
+//#region src/resources/binaries.ts
+var BinariesResource = class {
+	httpClient;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+	}
+	/**
+	* Counts the store builds of the app that match the filters.
+	*/
+	async count(options) {
+		const { appId, ...query } = options;
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/apps/{appId}/binaries/count", { appId }),
+			query
+		});
+	}
+	/**
+	* Creates a binary: a store build with a bundle compiled into it. Upload its files first.
+	* An identical create answers the existing binary. A different fingerprint or file set is refused unless `force` is set.
+	*/
+	async create(options) {
+		const { appId, idempotencyKey, ...body } = options;
+		return this.httpClient.fetchCreatingPost({
+			body,
+			idempotencyKey,
+			path: resolvePath("/v1/apps/{appId}/binaries", { appId })
+		});
+	}
+	async get(options) {
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/apps/{appId}/binaries/{binaryId}", options)
+		});
+	}
+	/**
+	* Lists the store builds of the app, newest first.
+	*/
+	async list(options) {
+		const { appId, ...query } = options;
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/apps/{appId}/binaries", { appId }),
+			query
+		});
+	}
+};
+//#endregion
+//#region src/resources/bundle-deltas.ts
+var BundleDeltasResource = class {
+	httpClient;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+	}
+	/**
+	* Counts the deltas of the bundle.
+	*/
+	async count(options) {
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/apps/{appId}/bundles/{bundleId}/deltas/count", options)
+		});
+	}
+	/**
+	* Lists the deltas of the bundle, newest first, one per base bundle that its devices run.
+	* `relations: ['baseBundle']` embeds the base bundle.
+	*/
+	async list(options) {
+		const { appId, bundleId, ...query } = options;
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/apps/{appId}/bundles/{bundleId}/deltas", {
+				appId,
+				bundleId
+			}),
+			query
+		});
+	}
+};
+//#endregion
+//#region src/resources/bundle-files.ts
+var BundleFilesResource = class {
+	httpClient;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+	}
+	/**
+	* Counts the files of the bundle that match the filters.
+	*/
+	async count(options) {
+		const { appId, bundleId, ...query } = options;
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/apps/{appId}/bundles/{bundleId}/files/count", {
+				appId,
+				bundleId
+			}),
+			query
+		});
+	}
+	/**
+	* Lists the files of the bundle, ordered by path.
+	* An embedded bundle answers the files its binary was created with.
+	* After creating a bundle, `isStored: false` selects the files still to upload.
+	*/
+	async list(options) {
+		const { appId, bundleId, ...query } = options;
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/apps/{appId}/bundles/{bundleId}/files", {
+				appId,
+				bundleId
+			}),
+			query
+		});
+	}
+};
+//#endregion
+//#region src/upload-in-parts.ts
+/**
+* The size of every part but the last.
+* The bucket requires at least five mebibytes, and the same size for all of them.
+*/
+const PART_SIZE_BYTES = 10485760;
+/**
+* The largest `Blob` sent in one request; a larger one goes up in parts.
+* It stays well under the request body cap of the API hosting plan.
+*/
+const SINGLE_UPLOAD_LIMIT_BYTES = 67108864;
+function isBlobAboveSingleUploadLimit(uploadBody) {
+	return uploadBody.body instanceof Blob && uploadBody.body.size > 67108864;
+}
+async function uploadInParts(uploads, pathParameters, blob) {
+	const { uploadId } = await uploads.create(pathParameters);
+	try {
+		const parts = [];
+		for (let start = 0, partNumber = 1; start < blob.size; start += PART_SIZE_BYTES, partNumber += 1) {
+			const uploadedPart = await uploads.parts.upload({
+				...pathParameters,
+				body: blob.slice(start, start + PART_SIZE_BYTES),
+				partNumber,
+				uploadId
+			});
+			parts.push(uploadedPart);
+		}
+		return await uploads.complete({
+			...pathParameters,
+			parts,
+			uploadId
+		});
+	} catch (error) {
+		await uploads.delete({
+			...pathParameters,
+			uploadId
+		}).catch(() => void 0);
+		throw error;
+	}
+}
+//#endregion
+//#region src/resources/bundle-pack-upload-parts.ts
+var BundlePackUploadPartsResource = class {
+	httpClient;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+	}
+	/**
+	* Uploads one part of a multipart pack upload.
+	* Pass the answered `etag` and `partNumber` to `complete`.
+	*/
+	async upload(options) {
+		const { appId, bundleId, partNumber, uploadId, ...uploadBody } = options;
+		return this.httpClient.fetchUpload({
+			...uploadBody,
+			contentType: "application/x-tar",
+			path: resolvePath("/v1/apps/{appId}/bundles/{bundleId}/pack/uploads/{uploadId}/parts/{partNumber}", {
+				appId,
+				bundleId,
+				partNumber,
+				uploadId
+			})
+		});
+	}
+};
+//#endregion
+//#region src/resources/bundle-pack-uploads.ts
+/**
+* Uploads a pack above the request body limit in parts.
+* Create the upload, upload the parts and complete it, or delete it to abort.
+*/
+var BundlePackUploadsResource = class {
+	httpClient;
+	parts;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+		this.parts = new BundlePackUploadPartsResource(httpClient);
+	}
+	/**
+	* Assembles the parts into the pack and replaces any pack uploaded before.
+	* R2 refuses a second completion, so the client never retries the call.
+	*/
+	async complete(options) {
+		const { appId, bundleId, uploadId, ...body } = options;
+		return this.httpClient.fetchJson({
+			body,
+			method: "POST",
+			path: resolvePath("/v1/apps/{appId}/bundles/{bundleId}/pack/uploads/{uploadId}/complete", {
+				appId,
+				bundleId,
+				uploadId
+			})
+		});
+	}
+	/**
+	* Starts a multipart upload of the pack.
+	* Every part but the last must have the same size of at least five mebibytes.
+	* The start holds no state, and an unused upload expires on its own, so the client retries the call.
+	*/
+	async create(options) {
+		return this.httpClient.fetchJson({
+			isRetryable: true,
+			method: "POST",
+			path: resolvePath("/v1/apps/{appId}/bundles/{bundleId}/pack/uploads", options)
+		});
+	}
+	/**
+	* Aborts a multipart pack upload and discards its parts.
+	*/
+	async delete(options) {
+		await this.httpClient.fetchJson({
+			method: "DELETE",
+			path: resolvePath("/v1/apps/{appId}/bundles/{bundleId}/pack/uploads/{uploadId}", options)
+		});
+	}
+};
+//#endregion
+//#region src/resources/bundle-pack.ts
+var BundlePackResource = class {
+	httpClient;
+	uploads;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+		this.uploads = new BundlePackUploadsResource(httpClient);
+	}
+	/**
+	* Uploads the full pack of the bundle, a tar, before the bundle is completed.
+	* A `Blob` above `SINGLE_UPLOAD_LIMIT_BYTES` goes up in parts. A stream goes up in one request, so it must stay within that limit.
+	*/
+	async upload(options) {
+		const { appId, bundleId, ...uploadBody } = options;
+		if (isBlobAboveSingleUploadLimit(uploadBody)) return uploadInParts(this.uploads, {
+			appId,
+			bundleId
+		}, uploadBody.body);
+		return this.httpClient.fetchUpload({
+			...uploadBody,
+			contentType: "application/x-tar",
+			path: resolvePath("/v1/apps/{appId}/bundles/{bundleId}/pack", {
+				appId,
+				bundleId
+			})
+		});
+	}
+};
+//#endregion
+//#region src/resources/bundles.ts
+var BundlesResource = class {
+	httpClient;
+	deltas;
+	files;
+	pack;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+		this.deltas = new BundleDeltasResource(httpClient);
+		this.files = new BundleFilesResource(httpClient);
+		this.pack = new BundlePackResource(httpClient);
+	}
+	/**
+	* Completes a bundle: checks that every listed file and the pack are uploaded, writes the manifest and sets the status to `ready`.
+	* A completed bundle answers itself again, so the client retries the call.
+	*/
+	async complete(options) {
+		return this.httpClient.fetchJson({
+			isRetryable: true,
+			method: "POST",
+			path: resolvePath("/v1/apps/{appId}/bundles/{bundleId}/complete", options)
+		});
+	}
+	/**
+	* Counts the bundles of the app that match the filters.
+	*/
+	async count(options) {
+		const { appId, ...query } = options;
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/apps/{appId}/bundles/count", { appId }),
+			query
+		});
+	}
+	/**
+	* Creates a bundle from its manifest. It stays `uploading` until completed.
+	* Find the files the app lacks with `apps.bundles.files.list` and `isStored: false`, and upload each through `apps.files.upload`.
+	* Upload the pack through `apps.bundles.pack.upload`.
+	*/
+	async create(options) {
+		const { appId, idempotencyKey, ...body } = options;
+		return this.httpClient.fetchCreatingPost({
+			body,
+			idempotencyKey,
+			path: resolvePath("/v1/apps/{appId}/bundles", { appId })
+		});
+	}
+	/**
+	* Deletes a bundle at once.
+	* A bundle that a release serves or a store build embeds is refused.
+	*/
+	async delete(options) {
+		await this.httpClient.fetchJson({
+			method: "DELETE",
+			path: resolvePath("/v1/apps/{appId}/bundles/{bundleId}", options)
+		});
+	}
+	async get(options) {
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/apps/{appId}/bundles/{bundleId}", options)
+		});
+	}
+	/**
+	* Lists the uploaded bundles of the app, newest first.
+	*/
+	async list(options) {
+		const { appId, ...query } = options;
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/apps/{appId}/bundles", { appId }),
+			query
+		});
+	}
+};
+//#endregion
+//#region src/resources/channel-audience.ts
+var ChannelAudienceResource = class {
+	httpClient;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+	}
+	/**
+	* Estimates which devices of the channel a release with these conditions would reach, before the release exists.
+	* Each condition is repeatable, and repeated conditions combine with AND.
+	*/
+	async get(options) {
+		const { appId, channelId, ...query } = options;
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/apps/{appId}/channels/{channelId}/audience", {
+				appId,
+				channelId
+			}),
+			query
+		});
+	}
+};
+//#endregion
+//#region src/resources/channel-qr-code.ts
+var ChannelQrCodeResource = class {
+	httpClient;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+	}
+	/**
+	* Gets the deep link of the channel as a QR image, built from the `channelLinkTemplate` of the app.
+	* The image is SVG unless `format` is `png`. Answers `not_found` while the template is unset.
+	*/
+	async get(options) {
+		const { appId, channelId, ...query } = options;
+		return this.httpClient.fetchBlob({
+			method: "GET",
+			path: resolvePath("/v1/apps/{appId}/channels/{channelId}/qr-code", {
+				appId,
+				channelId
+			}),
+			query
+		});
+	}
+};
+//#endregion
+//#region src/resources/channel-releases.ts
+var ChannelReleasesResource = class {
+	httpClient;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+	}
+	/**
+	* Releases a ready bundle, or what another channel serves, in this channel.
+	* The release gets the next number of the channel.
+	*/
+	async create(options) {
+		const { appId, channelId, idempotencyKey, ...body } = options;
+		return this.httpClient.fetchCreatingPost({
+			body,
+			idempotencyKey,
+			path: resolvePath("/v1/apps/{appId}/channels/{channelId}/releases", {
+				appId,
+				channelId
+			})
+		});
+	}
+	/**
+	* Revokes several releases of the channel at once: those in `releaseIds`, or every release numbered at or above `fromNumber`.
+	* Revoking a revoked release does nothing, so the client retries the call.
+	*/
+	async revoke(options) {
+		const { appId, channelId, ...body } = options;
+		return this.httpClient.fetchJson({
+			body,
+			isRetryable: true,
+			method: "POST",
+			path: resolvePath("/v1/apps/{appId}/channels/{channelId}/releases/revoke", {
+				appId,
+				channelId
+			})
+		});
+	}
+};
+//#endregion
+//#region src/resources/rollbacks.ts
+var RollbacksResource = class {
+	httpClient;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+	}
+	/**
+	* Rolls the channel back to its previous bundle, or to the bundle of `toReleaseId`.
+	* A rollback is a new release.
+	*/
+	async create(options) {
+		const { appId, channelId, idempotencyKey, ...body } = options;
+		return this.httpClient.fetchCreatingPost({
+			body,
+			idempotencyKey,
+			path: resolvePath("/v1/apps/{appId}/channels/{channelId}/rollbacks", {
+				appId,
+				channelId
+			})
+		});
+	}
+};
+//#endregion
+//#region src/resources/channels.ts
+var ChannelsResource = class {
+	httpClient;
+	audience;
+	qrCode;
+	releases;
+	rollbacks;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+		this.audience = new ChannelAudienceResource(httpClient);
+		this.qrCode = new ChannelQrCodeResource(httpClient);
+		this.releases = new ChannelReleasesResource(httpClient);
+		this.rollbacks = new RollbacksResource(httpClient);
+	}
+	/**
+	* Counts the channels of the app that match the filters.
+	*/
+	async count(options) {
+		const { appId, ...query } = options;
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/apps/{appId}/channels/count", { appId }),
+			query
+		});
+	}
+	async create(options) {
+		const { appId, idempotencyKey, ...body } = options;
+		return this.httpClient.fetchCreatingPost({
+			body,
+			idempotencyKey,
+			path: resolvePath("/v1/apps/{appId}/channels", { appId })
+		});
+	}
+	/**
+	* Deletes a channel at once. The default channel of the app is refused.
+	*/
+	async delete(options) {
+		await this.httpClient.fetchJson({
+			method: "DELETE",
+			path: resolvePath("/v1/apps/{appId}/channels/{channelId}", options)
+		});
+	}
+	/**
+	* Deletes the channels of the app named by `ids`, one to 100. An id of another app is skipped.
+	* The default channel, or a protected channel when the caller is a Member, refuses the whole set.
+	*/
+	async deleteMany(options) {
+		const { appId, ...query } = options;
+		await this.httpClient.fetchJson({
+			method: "DELETE",
+			path: resolvePath("/v1/apps/{appId}/channels", { appId }),
+			query
+		});
+	}
+	/**
+	* Gets a channel.
+	* To count its devices, call `apps.statistics.fleet.get` with its `channelId`.
+	*/
+	async get(options) {
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/apps/{appId}/channels/{channelId}", options)
+		});
+	}
+	/**
+	* Lists the channels of the app, newest first.
+	*/
+	async list(options) {
+		const { appId, ...query } = options;
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/apps/{appId}/channels", { appId }),
+			query
+		});
+	}
+	/**
+	* Pauses a channel: it serves nothing new, and devices keep what they have.
+	* Pausing a paused channel answers it unchanged, so the client retries the call.
+	*/
+	async pause(options) {
+		return this.httpClient.fetchJson({
+			isRetryable: true,
+			method: "POST",
+			path: resolvePath("/v1/apps/{appId}/channels/{channelId}/pause", options)
+		});
+	}
+	/**
+	* Resumes a paused channel.
+	* Resuming a running channel answers it unchanged, so the client retries the call.
+	*/
+	async resume(options) {
+		return this.httpClient.fetchJson({
+			isRetryable: true,
+			method: "POST",
+			path: resolvePath("/v1/apps/{appId}/channels/{channelId}/resume", options)
+		});
+	}
+	async update(options) {
+		const { appId, channelId, ...body } = options;
+		return this.httpClient.fetchJson({
+			body,
+			method: "PATCH",
+			path: resolvePath("/v1/apps/{appId}/channels/{channelId}", {
+				appId,
+				channelId
+			})
+		});
+	}
+};
+//#endregion
+//#region src/resources/device-events.ts
+var DeviceEventsResource = class {
+	httpClient;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+	}
+	/**
+	* Counts the events of the device that match the filter.
+	*/
+	async count(options) {
+		const { appId, deviceId, ...query } = options;
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/apps/{appId}/devices/{deviceId}/events/count", {
+				appId,
+				deviceId
+			}),
+			query
+		});
+	}
+	/**
+	* Lists the events of the device across all releases of the app, newest first, filtered by `releaseId`.
+	*/
+	async list(options) {
+		const { appId, deviceId, ...query } = options;
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/apps/{appId}/devices/{deviceId}/events", {
+				appId,
+				deviceId
+			}),
+			query
+		});
+	}
+};
+//#endregion
+//#region src/resources/devices.ts
+var DevicesResource = class {
+	httpClient;
+	events;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+		this.events = new DeviceEventsResource(httpClient);
+	}
+	/**
+	* Counts the devices of the app that match the filters.
+	*/
+	async count(options) {
+		const { appId, ...query } = options;
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/apps/{appId}/devices/count", { appId }),
+			query
+		});
+	}
+	/**
+	* Deletes a device from the registry, for an erasure request.
+	*/
+	async delete(options) {
+		await this.httpClient.fetchJson({
+			method: "DELETE",
+			path: resolvePath("/v1/apps/{appId}/devices/{deviceId}", options)
+		});
+	}
+	/**
+	* Deletes the devices of the app named by `ids`, one to 100. An id of another app is skipped.
+	*/
+	async deleteMany(options) {
+		const { appId, ...query } = options;
+		await this.httpClient.fetchJson({
+			method: "DELETE",
+			path: resolvePath("/v1/apps/{appId}/devices", { appId }),
+			query
+		});
+	}
+	async get(options) {
+		const { appId, deviceId, ...query } = options;
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/apps/{appId}/devices/{deviceId}", {
+				appId,
+				deviceId
+			}),
+			query
+		});
+	}
+	/**
+	* Lists the devices of the app, newest report first.
+	* `attribute` takes one `key=value` pair.
+	*/
+	async list(options) {
+		const { appId, ...query } = options;
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/apps/{appId}/devices", { appId }),
+			query
+		});
+	}
+};
+//#endregion
+//#region src/resources/file-upload-parts.ts
+var FileUploadPartsResource = class {
+	httpClient;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+	}
+	/**
+	* Uploads one part of a multipart file upload.
+	* Pass the answered `etag` and `partNumber` to `complete`.
+	*/
+	async upload(options) {
+		const { appId, partNumber, sha256, uploadId, ...uploadBody } = options;
+		return this.httpClient.fetchUpload({
+			...uploadBody,
+			contentType: "application/gzip",
+			path: resolvePath("/v1/apps/{appId}/files/{sha256}/uploads/{uploadId}/parts/{partNumber}", {
+				appId,
+				partNumber,
+				sha256,
+				uploadId
+			})
+		});
+	}
+};
+//#endregion
+//#region src/resources/file-uploads.ts
+/**
+* Uploads a larger file in parts.
+* Create the upload, upload the parts and complete it, or delete it to abort.
+*/
+var FileUploadsResource = class {
+	httpClient;
+	parts;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+		this.parts = new FileUploadPartsResource(httpClient);
+	}
+	/**
+	* Assembles the parts into the file and checks its hash.
+	* If the app already holds the hash, the stored file is answered without assembly, so the client retries the call.
+	*/
+	async complete(options) {
+		const { appId, sha256, uploadId, ...body } = options;
+		return this.httpClient.fetchJson({
+			body,
+			isRetryable: true,
+			method: "POST",
+			path: resolvePath("/v1/apps/{appId}/files/{sha256}/uploads/{uploadId}/complete", {
+				appId,
+				sha256,
+				uploadId
+			})
+		});
+	}
+	/**
+	* Starts a multipart file upload.
+	* Every part but the last must have the same size of at least five mebibytes.
+	* The start holds no state, and an unused upload expires on its own, so the client retries the call.
+	*/
+	async create(options) {
+		return this.httpClient.fetchJson({
+			isRetryable: true,
+			method: "POST",
+			path: resolvePath("/v1/apps/{appId}/files/{sha256}/uploads", options)
+		});
+	}
+	/**
+	* Aborts a multipart file upload and discards its parts.
+	*/
+	async delete(options) {
+		await this.httpClient.fetchJson({
+			method: "DELETE",
+			path: resolvePath("/v1/apps/{appId}/files/{sha256}/uploads/{uploadId}", options)
+		});
+	}
+};
+//#endregion
+//#region src/resources/files.ts
+var FilesResource = class {
+	httpClient;
+	uploads;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+		this.uploads = new FileUploadsResource(httpClient);
+	}
+	/**
+	* Uploads one file.
+	* The body is the gzip-compressed file, and `sha256` is the hash of the uncompressed content. A hash the app already holds answers the existing file.
+	* A `Blob` above `SINGLE_UPLOAD_LIMIT_BYTES` goes up in parts. A stream goes up in one request, so it must stay within that limit.
+	*/
+	async upload(options) {
+		const { appId, sha256, ...uploadBody } = options;
+		if (isBlobAboveSingleUploadLimit(uploadBody)) return uploadInParts(this.uploads, {
+			appId,
+			sha256
+		}, uploadBody.body);
+		return this.httpClient.fetchUpload({
+			...uploadBody,
+			contentType: "application/gzip",
+			path: resolvePath("/v1/apps/{appId}/files/{sha256}", {
+				appId,
+				sha256
+			})
+		});
+	}
+};
+//#endregion
+//#region src/resources/release-audience.ts
+var ReleaseAudienceResource = class {
+	httpClient;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+	}
+	/**
+	* Gets the devices a release reaches.
+	* The API evaluates the registry the same way a device evaluates the index.
+	*/
+	async get(options) {
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/apps/{appId}/releases/{releaseId}/audience", options)
+		});
+	}
+};
+//#endregion
+//#region src/resources/releases.ts
+var ReleasesResource = class {
+	httpClient;
+	audience;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+		this.audience = new ReleaseAudienceResource(httpClient);
+	}
+	/**
+	* Counts the releases of the app that match the filters.
+	* `number` is valid only beside `channelId`, since release numbers count per channel.
+	*/
+	async count(options) {
+		const { appId, ...query } = options;
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/apps/{appId}/releases/count", { appId }),
+			query
+		});
+	}
+	/**
+	* Gets a release with its status: when it went live in the index and when the purge completed.
+	*/
+	async get(options) {
+		const { appId, releaseId, ...query } = options;
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/apps/{appId}/releases/{releaseId}", {
+				appId,
+				releaseId
+			}),
+			query
+		});
+	}
+	/**
+	* Lists every release of the app, newest first.
+	* `channelId` selects the release log of one channel, and `number` beside it one release of that log.
+	*/
+	async list(options) {
+		const { appId, ...query } = options;
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/apps/{appId}/releases", { appId }),
+			query
+		});
+	}
+	/**
+	* Pauses a release: it is no longer offered, and devices on it keep it.
+	* Pausing a paused release answers it unchanged, so the client retries the call.
+	*/
+	async pause(options) {
+		return this.httpClient.fetchJson({
+			isRetryable: true,
+			method: "POST",
+			path: resolvePath("/v1/apps/{appId}/releases/{releaseId}/pause", options)
+		});
+	}
+	/**
+	* Resumes a paused release, so it is offered again.
+	* Resuming an active release answers it unchanged, so the client retries the call.
+	*/
+	async resume(options) {
+		return this.httpClient.fetchJson({
+			isRetryable: true,
+			method: "POST",
+			path: resolvePath("/v1/apps/{appId}/releases/{releaseId}/resume", options)
+		});
+	}
+	/**
+	* Revokes a release for good.
+	* Devices on it move to the newest eligible older release or to the embedded bundle.
+	* A repeat answers `release_revoked`, so the client never retries the call.
+	*/
+	async revoke(options) {
+		return this.httpClient.fetchJson({
+			method: "POST",
+			path: resolvePath("/v1/apps/{appId}/releases/{releaseId}/revoke", options)
+		});
+	}
+	/**
+	* Changes the rollout percentage (up or down), the progression schedule, the mandatory flag or the notes.
+	* Setting the progression schedule to null stops it.
+	*/
+	async update(options) {
+		const { appId, releaseId, ...body } = options;
+		return this.httpClient.fetchJson({
+			body,
+			method: "PATCH",
+			path: resolvePath("/v1/apps/{appId}/releases/{releaseId}", {
+				appId,
+				releaseId
+			})
+		});
+	}
+};
+//#endregion
+//#region src/resources/signing-keys.ts
+var SigningKeysResource = class {
+	httpClient;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+	}
+	/**
+	* Counts the signing keys of the app.
+	*/
+	async count(options) {
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/apps/{appId}/signing-keys/count", options)
+		});
+	}
+	/**
+	* Registers a public key. From then on, the app releases only signed bundles.
+	* The key is `rsa-v1_5-sha256:` followed by the base64 SPKI DER of an RSA key of at least 2048 bits.
+	* A key the app already holds answers its row unchanged, so the client retries the call.
+	*/
+	async create(options) {
+		const { appId, ...body } = options;
+		return this.httpClient.fetchJson({
+			body,
+			isRetryable: true,
+			method: "POST",
+			path: resolvePath("/v1/apps/{appId}/signing-keys", { appId })
+		});
+	}
+	async delete(options) {
+		await this.httpClient.fetchJson({
+			method: "DELETE",
+			path: resolvePath("/v1/apps/{appId}/signing-keys/{signingKeyId}", options)
+		});
+	}
+	/**
+	* Lists the signing keys of the app, newest first.
+	*/
+	async list(options) {
+		const { appId, ...query } = options;
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/apps/{appId}/signing-keys", { appId }),
+			query
+		});
+	}
+};
+//#endregion
+//#region src/resources/statistics-fleet.ts
+var StatisticsFleetResource = class {
+	httpClient;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+	}
+	/**
+	* Gets a snapshot of the fleet from the registry, for one channel when `channelId` is set.
+	*/
+	async get(options) {
+		const { appId, ...query } = options;
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/apps/{appId}/statistics/fleet", { appId }),
+			query
+		});
+	}
+};
+//#endregion
+//#region src/resources/statistics-updates.ts
+var StatisticsUpdatesResource = class {
+	httpClient;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+	}
+	/**
+	* Gets the update statistics from `periodSince` to `periodUntil`, both inclusive, for one channel when `channelId` is set.
+	* `releaseId` limits the adoption curves to that one release, whatever its age.
+	*/
+	async get(options) {
+		const { appId, ...query } = options;
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/apps/{appId}/statistics/updates", { appId }),
+			query
+		});
+	}
+};
+//#endregion
+//#region src/resources/statistics-usage.ts
+var StatisticsUsageResource = class {
+	httpClient;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+	}
+	/**
+	* Gets the usage statistics from `periodSince` to `periodUntil`, both inclusive.
+	*/
+	async get(options) {
+		const { appId, ...query } = options;
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/apps/{appId}/statistics/usage", { appId }),
+			query
+		});
+	}
+};
+//#endregion
+//#region src/resources/statistics.ts
+var StatisticsResource = class {
+	fleet;
+	updates;
+	usage;
+	constructor(httpClient) {
+		this.fleet = new StatisticsFleetResource(httpClient);
+		this.updates = new StatisticsUpdatesResource(httpClient);
+		this.usage = new StatisticsUsageResource(httpClient);
+	}
+};
+//#endregion
+//#region src/resources/apps.ts
+var AppsResource = class {
+	httpClient;
+	binaries;
+	bundles;
+	channels;
+	devices;
+	files;
+	releases;
+	signingKeys;
+	statistics;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+		this.binaries = new BinariesResource(httpClient);
+		this.bundles = new BundlesResource(httpClient);
+		this.channels = new ChannelsResource(httpClient);
+		this.devices = new DevicesResource(httpClient);
+		this.files = new FilesResource(httpClient);
+		this.releases = new ReleasesResource(httpClient);
+		this.signingKeys = new SigningKeysResource(httpClient);
+		this.statistics = new StatisticsResource(httpClient);
+	}
+	/**
+	* Soft-deletes an app. It is gone at once and hard-deleted after seven days.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async delete(options) {
+		await this.httpClient.fetchJson({
+			method: "DELETE",
+			path: resolvePath("/v1/apps/{appId}", options)
+		});
+	}
+	async get(options) {
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/apps/{appId}", options)
+		});
+	}
+	/**
+	* Moves an app to another organization in which the caller is an Admin.
+	* A repeat answers `validation` because the app is already there, so the client never retries the call.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async transfer(options) {
+		const { appId, ...body } = options;
+		return this.httpClient.fetchJson({
+			body,
+			method: "POST",
+			path: resolvePath("/v1/apps/{appId}/transfer", { appId })
+		});
+	}
+	async update(options) {
+		const { appId, ...body } = options;
+		return this.httpClient.fetchJson({
+			body,
+			method: "PATCH",
+			path: resolvePath("/v1/apps/{appId}", { appId })
+		});
+	}
+};
+//#endregion
+//#region src/resources/health.ts
+var HealthResource = class {
+	httpClient;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+	}
+	/**
+	* Checks that the API is up: resolves when it answers its plain-text `ok`.
+	* `unavailable` or any other status outside 2xx throws a `HotCodePushError`.
+	*/
+	async get() {
+		await this.httpClient.fetchStatus({
+			method: "GET",
+			path: "/health"
+		});
+	}
+};
+//#endregion
+//#region src/resources/invitations.ts
+var InvitationsResource = class {
+	httpClient;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+	}
+	/**
+	* Accepts an invitation addressed to the caller, with the token from the invitation mail.
+	* A repeat answers `invitation_invalid`, so the client never retries the call.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async accept(options) {
+		const { invitationId, ...body } = options;
+		return this.httpClient.fetchJson({
+			body,
+			method: "POST",
+			path: resolvePath("/v1/invitations/{invitationId}/accept", { invitationId })
+		});
+	}
+	/**
+	* Counts the pending invitations of the caller across all organizations.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async count() {
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/invitations/count")
+		});
+	}
+	/**
+	* Lists the pending invitations of the caller across all organizations, newest first.
+	* `relations: ['organization']` embeds the id and name of each organization.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async list(options = {}) {
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/invitations"),
+			query: options
+		});
+	}
+};
+//#endregion
+//#region src/resources/notification-preferences.ts
+/**
+* The notification preferences of the caller, one per category and medium.
+* They apply to the account or, with `organizationId`, to that membership.
+*/
+var NotificationPreferencesResource = class {
+	httpClient;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+	}
+	/**
+	* Lists the preferences of the caller, one per category and medium, defaults included.
+	* The order follows the catalog, with email first.
+	* Without `organizationId` it lists the account categories, with it the categories set per membership.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async list(options = {}) {
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/notification-preferences"),
+			query: options
+		});
+	}
+	/**
+	* Sets one preference, given by category and medium, and answers it.
+	* Email for a mandatory category is always on.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async update(options) {
+		return this.httpClient.fetchJson({
+			body: options,
+			method: "PATCH",
+			path: resolvePath("/v1/notification-preferences")
+		});
+	}
+};
+//#endregion
+//#region src/resources/notifications.ts
+/**
+* The in-app notifications of the caller across all organizations.
+*/
+var NotificationsResource = class {
+	httpClient;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+	}
+	/**
+	* Counts the notifications of the caller that match the filters.
+	* `isRead: false` gives the badge count of the bell.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async count(options = {}) {
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/notifications/count"),
+			query: options
+		});
+	}
+	/**
+	* Lists the notifications of the caller, newest first.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async list(options = {}) {
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/notifications"),
+			query: options
+		});
+	}
+	/**
+	* Marks one notification of the caller as read.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async update(options) {
+		const { notificationId, ...body } = options;
+		return this.httpClient.fetchJson({
+			body,
+			method: "PATCH",
+			path: resolvePath("/v1/notifications/{notificationId}", { notificationId })
+		});
+	}
+	/**
+	* Marks every unread notification of the caller as read.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async updateMany(options) {
+		await this.httpClient.fetchJson({
+			body: options,
+			method: "PATCH",
+			path: resolvePath("/v1/notifications")
+		});
+	}
+};
+//#endregion
+//#region src/resources/audit-logs.ts
+var AuditLogsResource = class {
+	httpClient;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+	}
+	/**
+	* Counts the audit log entries that match the filters.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async count(options) {
+		const { organizationId, ...query } = options;
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/organizations/{organizationId}/audit-logs/count", { organizationId }),
+			query
+		});
+	}
+	/**
+	* Downloads the audit log entries that match the filters as a `text/csv` `Blob`.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async downloadCsv(options) {
+		const { organizationId, ...filters } = options;
+		return this.httpClient.fetchBlob({
+			method: "GET",
+			path: resolvePath("/v1/organizations/{organizationId}/audit-logs", { organizationId }),
+			query: {
+				...filters,
+				format: "csv"
+			}
+		});
+	}
+	/**
+	* Lists the audit log of the organization, newest first.
+	* `type` takes a wildcard such as `channel.*` to match every action on one kind of object.
+	* Needs a plan that includes the audit log; any other plan answers `plan_required`.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async list(options) {
+		const { organizationId, ...query } = options;
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/organizations/{organizationId}/audit-logs", { organizationId }),
+			query
+		});
+	}
+};
+//#endregion
+//#region src/resources/checkouts.ts
+var CheckoutsResource = class {
+	httpClient;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+	}
+	/**
+	* Creates a Polar checkout that enables pay-as-you-go billing on a free organization.
+	* The email of the caller is pre-filled and can be changed on the Polar page.
+	* Once paid, the subscription names the organization and starts at the $5 minimum spending cap, which the customer can raise later.
+	* Each call creates another checkout and the API keeps no `Idempotency-Key` for it, so the client never retries the call.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async create(options) {
+		return this.httpClient.fetchJson({
+			method: "POST",
+			path: resolvePath("/v1/organizations/{organizationId}/checkouts", options)
+		});
+	}
+};
+//#endregion
+//#region src/resources/customer-portal-sessions.ts
+var CustomerPortalSessionsResource = class {
+	httpClient;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+	}
+	/**
+	* Creates a Polar customer portal session for the invoices and payment method of the organization.
+	* An organization that never subscribed has no portal.
+	* Each call creates another session and the API keeps no `Idempotency-Key` for it, so the client never retries the call.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async create(options) {
+		return this.httpClient.fetchJson({
+			method: "POST",
+			path: resolvePath("/v1/organizations/{organizationId}/customer-portal-sessions", options)
+		});
+	}
+};
+//#endregion
+//#region src/resources/limits.ts
+var LimitsResource = class {
+	httpClient;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+	}
+	/**
+	* Gets the limits in effect for the organization.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async get(options) {
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/organizations/{organizationId}/limits", options)
+		});
+	}
+};
+//#endregion
+//#region src/resources/members.ts
+var MembersResource = class {
+	httpClient;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+	}
+	/**
+	* Counts the members of the organization that match the filters.
+	*/
+	async count(options) {
+		const { organizationId, ...query } = options;
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/organizations/{organizationId}/members/count", { organizationId }),
+			query
+		});
+	}
+	/**
+	* Removes a member. Any member may remove themselves to leave the organization.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async delete(options) {
+		await this.httpClient.fetchJson({
+			method: "DELETE",
+			path: resolvePath("/v1/organizations/{organizationId}/members/{memberId}", options)
+		});
+	}
+	/**
+	* Removes the members of the organization named by `ids`, one to 100. An id of another organization is skipped.
+	* If the set holds the Owner, the whole set is refused.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async deleteMany(options) {
+		const { organizationId, ...query } = options;
+		await this.httpClient.fetchJson({
+			method: "DELETE",
+			path: resolvePath("/v1/organizations/{organizationId}/members", { organizationId }),
+			query
+		});
+	}
+	async get(options) {
+		const { memberId, organizationId, ...query } = options;
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/organizations/{organizationId}/members/{memberId}", {
+				memberId,
+				organizationId
+			}),
+			query
+		});
+	}
+	/**
+	* Lists the members of the organization, newest first.
+	*/
+	async list(options) {
+		const { organizationId, ...query } = options;
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/organizations/{organizationId}/members", { organizationId }),
+			query
+		});
+	}
+	/**
+	* Changes the role of a member. Setting `owner` transfers the ownership.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async update(options) {
+		const { memberId, organizationId, ...body } = options;
+		return this.httpClient.fetchJson({
+			body,
+			method: "PATCH",
+			path: resolvePath("/v1/organizations/{organizationId}/members/{memberId}", {
+				memberId,
+				organizationId
+			})
+		});
+	}
+};
+//#endregion
+//#region src/resources/organization-apps.ts
+var OrganizationAppsResource = class {
+	httpClient;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+	}
+	/**
+	* Counts the apps of the organization that match the filters.
+	*/
+	async count(options) {
+		const { organizationId, ...query } = options;
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/organizations/{organizationId}/apps/count", { organizationId }),
+			query
+		});
+	}
+	/**
+	* Creates an app with its default channel `production`.
+	*/
+	async create(options) {
+		const { idempotencyKey, organizationId, ...body } = options;
+		return this.httpClient.fetchCreatingPost({
+			body,
+			idempotencyKey,
+			path: resolvePath("/v1/organizations/{organizationId}/apps", { organizationId })
+		});
+	}
+	/**
+	* Lists the apps of the organization, newest first.
+	*/
+	async list(options) {
+		const { organizationId, ...query } = options;
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/organizations/{organizationId}/apps", { organizationId }),
+			query
+		});
+	}
+};
+//#endregion
+//#region src/resources/organization-invitations.ts
+var OrganizationInvitationsResource = class {
+	httpClient;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+	}
+	/**
+	* Counts the invitations of the organization that match the filters.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async count(options) {
+		const { organizationId, ...query } = options;
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/organizations/{organizationId}/invitations/count", { organizationId }),
+			query
+		});
+	}
+	/**
+	* Invites an email address to the organization. The invitation mail carries the token.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async create(options) {
+		const { idempotencyKey, organizationId, ...body } = options;
+		return this.httpClient.fetchCreatingPost({
+			body,
+			idempotencyKey,
+			path: resolvePath("/v1/organizations/{organizationId}/invitations", { organizationId })
+		});
+	}
+	/**
+	* Withdraws an invitation.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async delete(options) {
+		await this.httpClient.fetchJson({
+			method: "DELETE",
+			path: resolvePath("/v1/organizations/{organizationId}/invitations/{invitationId}", options)
+		});
+	}
+	/**
+	* Withdraws the invitations of the organization named by `ids`, one to 100. An id of another organization is skipped.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async deleteMany(options) {
+		const { organizationId, ...query } = options;
+		await this.httpClient.fetchJson({
+			method: "DELETE",
+			path: resolvePath("/v1/organizations/{organizationId}/invitations", { organizationId }),
+			query
+		});
+	}
+	/**
+	* Lists the invitations of the organization, newest first.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async list(options) {
+		const { organizationId, ...query } = options;
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/organizations/{organizationId}/invitations", { organizationId }),
+			query
+		});
+	}
+};
+//#endregion
+//#region src/resources/sso-provider-verifications.ts
+var SsoProviderVerificationsResource = class {
+	httpClient;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+	}
+	/**
+	* Verifies the SSO domain: looks for `domainVerificationToken` in the TXT record of the domain and sets `domainVerified` when found.
+	* Answers the provider, verified or still waiting for the record. A DNS resolver that cannot be reached answers `dns_lookup_failed`.
+	* A verified provider answers unchanged without a lookup, so the client retries the call.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async create(options) {
+		return this.httpClient.fetchJson({
+			isRetryable: true,
+			method: "POST",
+			path: resolvePath("/v1/organizations/{organizationId}/sso-provider/verifications", options)
+		});
+	}
+};
+//#endregion
+//#region src/resources/sso-provider.ts
+var SsoProviderResource = class {
+	httpClient;
+	verifications;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+		this.verifications = new SsoProviderVerificationsResource(httpClient);
+	}
+	/**
+	* Removes the SSO provider. Its members can sign in with a password again, and the domain is forgotten.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async delete(options) {
+		await this.httpClient.fetchJson({
+			method: "DELETE",
+			path: resolvePath("/v1/organizations/{organizationId}/sso-provider", options)
+		});
+	}
+	/**
+	* Gets the SSO provider of the organization.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async get(options) {
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/organizations/{organizationId}/sso-provider", options)
+		});
+	}
+	/**
+	* Sets the OIDC or SAML provider and its domain, replacing the one before.
+	* A new or changed domain starts unverified, with a new token for its TXT record.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async set(options) {
+		const { organizationId, ...body } = options;
+		return this.httpClient.fetchJson({
+			body,
+			method: "PUT",
+			path: resolvePath("/v1/organizations/{organizationId}/sso-provider", { organizationId })
+		});
+	}
+};
+//#endregion
+//#region src/resources/subscription.ts
+/**
+* The organization's one subscription.
+*/
+var SubscriptionResource = class {
+	httpClient;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+	}
+	/**
+	* Cancels the subscription at the end of its period, with the reason and comment from the retention dialog.
+	* A cancel already scheduled stays as it is, so the client retries the call.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async cancel(options) {
+		const { organizationId, ...body } = options;
+		await this.httpClient.fetchJson({
+			body,
+			isRetryable: true,
+			method: "POST",
+			path: resolvePath("/v1/organizations/{organizationId}/subscription/cancel", { organizationId })
+		});
+	}
+	/**
+	* Undoes a scheduled cancel, so the subscription renews as before.
+	* A subscription with no cancel scheduled stays as it is, so the client retries the call.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async uncancel(options) {
+		await this.httpClient.fetchJson({
+			isRetryable: true,
+			method: "POST",
+			path: resolvePath("/v1/organizations/{organizationId}/subscription/uncancel", options)
+		});
+	}
+};
+//#endregion
+//#region src/resources/usage-apps.ts
+var UsageAppsResource = class {
+	httpClient;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+	}
+	/**
+	* Counts the apps with usage in `month`, for paging through `list`.
+	*/
+	async count(options) {
+		const { organizationId, ...query } = options;
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/organizations/{organizationId}/usage/apps/count", { organizationId }),
+			query
+		});
+	}
+	/**
+	* Downloads the usage of every app in `month`, with the app name, as a `text/csv` `Blob`.
+	*/
+	async downloadCsv(options) {
+		const { organizationId, ...query } = options;
+		return this.httpClient.fetchBlob({
+			method: "GET",
+			path: resolvePath("/v1/organizations/{organizationId}/usage/apps", { organizationId }),
+			query: {
+				...query,
+				format: "csv"
+			}
+		});
+	}
+	/**
+	* Lists the usage of each live app in `month`, most monthly active devices first.
+	* `relations: ['app']` embeds the id and name of the app.
+	*/
+	async list(options) {
+		const { organizationId, ...query } = options;
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/organizations/{organizationId}/usage/apps", { organizationId }),
+			query
+		});
+	}
+};
+//#endregion
+//#region src/resources/usage.ts
+var UsageResource = class {
+	httpClient;
+	apps;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+		this.apps = new UsageAppsResource(httpClient);
+	}
+	/**
+	* Gets the usage of the organization in `month`, the current month by default, from the stored months.
+	*/
+	async get(options) {
+		const { organizationId, ...query } = options;
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/organizations/{organizationId}/usage", { organizationId }),
+			query
+		});
+	}
+};
+//#endregion
+//#region src/resources/webhook-deliveries.ts
+/**
+* The delivery log of a webhook. Each delivery is kept for 30 days.
+*/
+var WebhookDeliveriesResource = class {
+	httpClient;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+	}
+	/**
+	* Counts the deliveries of the webhook that match the filters.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async count(options) {
+		const { organizationId, webhookId, ...query } = options;
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/organizations/{organizationId}/webhooks/{webhookId}/deliveries/count", {
+				organizationId,
+				webhookId
+			}),
+			query
+		});
+	}
+	/**
+	* Lists the deliveries of the webhook, newest first.
+	* Filter by `status`, and by `createdSince` and `createdUntil`, both inclusive.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async list(options) {
+		const { organizationId, webhookId, ...query } = options;
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/organizations/{organizationId}/webhooks/{webhookId}/deliveries", {
+				organizationId,
+				webhookId
+			}),
+			query
+		});
+	}
+	/**
+	* Delivers the event again, once, within the request, and answers the settled delivery with its attempt count carried on.
+	* Each call makes another attempt, so the client never retries the call.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async redeliver(options) {
+		return this.httpClient.fetchJson({
+			method: "POST",
+			path: resolvePath("/v1/organizations/{organizationId}/webhooks/{webhookId}/deliveries/{deliveryId}/redeliver", options)
+		});
+	}
+};
+//#endregion
+//#region src/resources/webhooks.ts
+/**
+* The webhooks of the organization, for Admins and Owners.
+* Needs a plan that includes webhooks; any other plan answers `plan_required`.
+*/
+var WebhooksResource = class {
+	httpClient;
+	deliveries;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+		this.deliveries = new WebhookDeliveriesResource(httpClient);
+	}
+	/**
+	* Counts the webhooks of the organization.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async count(options) {
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/organizations/{organizationId}/webhooks/count", options)
+		});
+	}
+	/**
+	* Creates a webhook. Its name must be unique in the organization, or the call answers `webhook_name_taken`.
+	* A `raw` webhook answers its secret only this once.
+	* The API keeps no `Idempotency-Key` for it and a repeat answers `webhook_name_taken`, so the client never retries the call.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async create(options) {
+		const { organizationId, ...body } = options;
+		return this.httpClient.fetchJson({
+			body,
+			method: "POST",
+			path: resolvePath("/v1/organizations/{organizationId}/webhooks", { organizationId })
+		});
+	}
+	/**
+	* Deletes the webhook and its delivery log.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async delete(options) {
+		await this.httpClient.fetchJson({
+			method: "DELETE",
+			path: resolvePath("/v1/organizations/{organizationId}/webhooks/{webhookId}", options)
+		});
+	}
+	/**
+	* Gets a webhook.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async get(options) {
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/organizations/{organizationId}/webhooks/{webhookId}", options)
+		});
+	}
+	/**
+	* Lists the webhooks of the organization, newest first.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async list(options) {
+		const { organizationId, ...query } = options;
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/organizations/{organizationId}/webhooks", { organizationId }),
+			query
+		});
+	}
+	/**
+	* Sends one sample event, `webhook.test`, through the normal delivery path within the request, and answers the settled delivery.
+	* Each call sends another sample event, so the client never retries the call.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async test(options) {
+		return this.httpClient.fetchJson({
+			method: "POST",
+			path: resolvePath("/v1/organizations/{organizationId}/webhooks/{webhookId}/test", options)
+		});
+	}
+	/**
+	* Changes the name, the URL, the subscribed `events`, the app filter or `isEnabled`. The format and the secret never change.
+	* Enabling a webhook that was disabled after fifty failed deliveries in a row resets that count.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async update(options) {
+		const { organizationId, webhookId, ...body } = options;
+		return this.httpClient.fetchJson({
+			body,
+			method: "PATCH",
+			path: resolvePath("/v1/organizations/{organizationId}/webhooks/{webhookId}", {
+				organizationId,
+				webhookId
+			})
+		});
+	}
+};
+//#endregion
+//#region src/resources/organizations.ts
+var OrganizationsResource = class {
+	httpClient;
+	apps;
+	auditLogs;
+	checkouts;
+	customerPortalSessions;
+	invitations;
+	limits;
+	members;
+	ssoProvider;
+	subscription;
+	usage;
+	webhooks;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+		this.apps = new OrganizationAppsResource(httpClient);
+		this.auditLogs = new AuditLogsResource(httpClient);
+		this.checkouts = new CheckoutsResource(httpClient);
+		this.customerPortalSessions = new CustomerPortalSessionsResource(httpClient);
+		this.invitations = new OrganizationInvitationsResource(httpClient);
+		this.limits = new LimitsResource(httpClient);
+		this.members = new MembersResource(httpClient);
+		this.ssoProvider = new SsoProviderResource(httpClient);
+		this.subscription = new SubscriptionResource(httpClient);
+		this.usage = new UsageResource(httpClient);
+		this.webhooks = new WebhooksResource(httpClient);
+	}
+	/**
+	* Counts the organizations of the caller.
+	*/
+	async count() {
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/organizations/count")
+		});
+	}
+	/**
+	* Creates an organization with the caller as its Owner.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async create(options) {
+		const { idempotencyKey, ...body } = options;
+		return this.httpClient.fetchCreatingPost({
+			body,
+			idempotencyKey,
+			path: resolvePath("/v1/organizations")
+		});
+	}
+	/**
+	* Soft-deletes an organization and everything under it.
+	* It is gone at once and hard-deleted after seven days.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async delete(options) {
+		await this.httpClient.fetchJson({
+			method: "DELETE",
+			path: resolvePath("/v1/organizations/{organizationId}", options)
+		});
+	}
+	async get(options) {
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/organizations/{organizationId}", options)
+		});
+	}
+	/**
+	* Lists the organizations of the caller, newest first.
+	* The role of the caller in each sits on their member rows: `users.get({ relations: ['members'], userId: 'me' })`.
+	*/
+	async list(options = {}) {
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/organizations"),
+			query: options
+		});
+	}
+	/**
+	* Updates an organization.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async update(options) {
+		const { organizationId, ...body } = options;
+		return this.httpClient.fetchJson({
+			body,
+			method: "PATCH",
+			path: resolvePath("/v1/organizations/{organizationId}", { organizationId })
+		});
+	}
+};
+//#endregion
+//#region src/resources/qr-codes.ts
+var QrCodesResource = class {
+	httpClient;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+	}
+	/**
+	* Gets a URL on hotcodepush.com, one of its subdomains or the workers.dev subdomain of HotCodePush as a QR image.
+	* The image is SVG unless `format` is `png`. A URL on another host answers `validation`. Needs no token.
+	*/
+	async get(options) {
+		return this.httpClient.fetchBlob({
+			method: "GET",
+			path: resolvePath("/v1/qr-codes"),
+			query: options
+		});
+	}
+};
+//#endregion
+//#region src/resources/user-password.ts
+var UserPasswordResource = class {
+	httpClient;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+	}
+	/**
+	* Sets the first password of an account that signed up through GitHub, Google or SSO, and ends its other sessions.
+	* An account with a password answers `password_already_set`, as a repeat would, so the client never retries the call.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async create(options) {
+		const { userId, ...body } = options;
+		await this.httpClient.fetchJson({
+			body,
+			method: "POST",
+			path: resolvePath("/v1/users/{userId}/password", { userId })
+		});
+	}
+};
+//#endregion
+//#region src/resources/user-sessions.ts
+var UserSessionsResource = class {
+	httpClient;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+	}
+	/**
+	* Ends the sessions of the caller named by `ids`, one to 100, the current session included.
+	* An id that is not the caller's is skipped.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async deleteMany(options) {
+		const { userId, ...query } = options;
+		await this.httpClient.fetchJson({
+			method: "DELETE",
+			path: resolvePath("/v1/users/{userId}/sessions", { userId }),
+			query
+		});
+	}
+};
+//#endregion
+//#region src/resources/user-tokens.ts
+var UserTokensResource = class {
+	httpClient;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+	}
+	/**
+	* Deletes the API tokens of the caller named by `ids`, one to 100.
+	* An id that is not the caller's is skipped.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async deleteMany(options) {
+		const { userId, ...query } = options;
+		await this.httpClient.fetchJson({
+			method: "DELETE",
+			path: resolvePath("/v1/users/{userId}/tokens", { userId }),
+			query
+		});
+	}
+};
+//#endregion
+//#region src/resources/users.ts
+var UsersResource = class {
+	httpClient;
+	password;
+	sessions;
+	tokens;
+	constructor(httpClient) {
+		this.httpClient = httpClient;
+		this.password = new UserPasswordResource(httpClient);
+		this.sessions = new UserSessionsResource(httpClient);
+		this.tokens = new UserTokensResource(httpClient);
+	}
+	/**
+	* Soft-deletes the account of the caller. It is gone at once and hard-deleted after seven days.
+	* `userId` takes `me`. `password` is the account password; a wrong one answers `forbidden`.
+	* An account without a password also answers `forbidden` and must set one first through `users.password.create`.
+	* An API token answers `forbidden`; sign in with a session.
+	*/
+	async delete(options) {
+		const { userId, ...body } = options;
+		await this.httpClient.fetchJson({
+			body,
+			method: "DELETE",
+			path: resolvePath("/v1/users/{userId}", { userId })
+		});
+	}
+	/**
+	* Gets the caller behind the token.
+	* `userId` takes `me`; another user answers `forbidden`.
+	* `relations` embeds `accounts` (the sign-in identities) and `members` (the member rows of live organizations). With `members.organization`, each member row embeds its organization.
+	*/
+	async get(options) {
+		const { userId, ...query } = options;
+		return this.httpClient.fetchJson({
+			method: "GET",
+			path: resolvePath("/v1/users/{userId}", { userId }),
+			query
+		});
+	}
+};
+//#endregion
+//#region src/client.ts
+/**
+* The client for the HotCodePush REST API.
+* Resources mirror the API paths, so `/v1/apps/{appId}/channels` is `apps.channels`.
+*/
+var HotCodePush = class {
+	apps;
+	health;
+	invitations;
+	notificationPreferences;
+	notifications;
+	organizations;
+	qrCodes;
+	users;
+	constructor(options = {}) {
+		const httpClient = new HttpClient(options);
+		this.apps = new AppsResource(httpClient);
+		this.health = new HealthResource(httpClient);
+		this.invitations = new InvitationsResource(httpClient);
+		this.notificationPreferences = new NotificationPreferencesResource(httpClient);
+		this.notifications = new NotificationsResource(httpClient);
+		this.organizations = new OrganizationsResource(httpClient);
+		this.qrCodes = new QrCodesResource(httpClient);
+		this.users = new UsersResource(httpClient);
+	}
+};
+//#endregion
+export { HotCodePush, HotCodePushError, PART_SIZE_BYTES, SINGLE_UPLOAD_LIMIT_BYTES };