@haau3/sdk 0.2.0 → 0.2.2

package/dist/index.mjs

@@ -36,14 +36,45 @@ var APIPromise = class extends Promise {
 };
 //#endregion
 //#region src/errors.ts
+/** The fields {@link Haau3Error.toJSON} copies when they are set, in this order. */
+const LOGGED = [
+	"status",
+	"reason",
+	"retryAfter",
+	"attempts",
+	"durationMs",
+	"requestId",
+	"correlationId"
+];
 /** What every error this package throws has. */
 var Haau3Error = class extends Error {
 	name = "Haau3Error";
 	/** The `X-Request-Id` the API sent, when it answered. Quote it when you ask for help. */
 	requestId;
+	/** The `correlationId` you sent, as the API returned it in `X-Correlation-Id`, when it answered. */
+	correlationId;
 	constructor(message, requestId, options) {
-		super(message, options);
+		super(message, options?.cause === void 0 ? void 0 : { cause: options.cause });
 		this.requestId = requestId;
+		this.correlationId = options?.correlationId;
+	}
+	/**
+	* The error as a plain object that is safe to log: its name, its message and every field that is
+	* set, and never the body the API answered with (`outcome`, `problem`) or the `cause`.
+	* `JSON.stringify(error)` and loggers that call `toJSON` print this.
+	*
+	* ```ts
+	* logger.warn({ error: error.toJSON() }, "the plan read failed");
+	* ```
+	*/
+	toJSON() {
+		const json = {
+			name: this.name,
+			message: this.message
+		};
+		const fields = this;
+		for (const key of LOGGED) if (fields[key] !== void 0) json[key] = fields[key];
+		return json;
 	}
 };
 /**
@@ -70,7 +101,7 @@ var AuthError = class extends Haau3Error {
 	/** Milliseconds from the first attempt to the answer. */
 	durationMs;
 	constructor(message, status, requestId, body, timing) {
-		super(message, requestId);
+		super(message, requestId, { correlationId: timing?.correlationId });
 		this.status = status;
 		this.attempts = timing?.attempts ?? 1;
 		this.durationMs = timing?.durationMs;
@@ -90,7 +121,7 @@ var RefusedError = class extends Haau3Error {
 	/** Milliseconds from the first attempt to the answer. */
 	durationMs;
 	constructor(message, status, requestId, body, timing) {
-		super(message, requestId);
+		super(message, requestId, { correlationId: timing?.correlationId });
 		this.status = status;
 		this.attempts = timing?.attempts ?? 1;
 		this.durationMs = timing?.durationMs;
@@ -113,7 +144,10 @@ var NoAnswerError = class extends Haau3Error {
 	/** Milliseconds from the first attempt to the last failure, waits between attempts included. */
 	durationMs;
 	constructor(message, details) {
-		super(message, details.requestId, details.cause === void 0 ? void 0 : { cause: details.cause });
+		super(message, details.requestId, {
+			cause: details.cause,
+			correlationId: details.correlationId
+		});
 		this.reason = details.reason;
 		this.status = details.status;
 		this.retryAfter = details.retryAfter;
@@ -125,9 +159,14 @@ var NoAnswerError = class extends Haau3Error {
 //#endregion
 //#region src/version.ts
 /** This package's version, sent in the `User-Agent` header. A test holds it to package.json. */
-const VERSION = "0.2.0";
+const VERSION = "0.2.2";
 //#endregion
 //#region src/transport.ts
+/**
+* The form the API takes for your own request id: a UUID in its usual text form, any version, as the
+* spec's `X-Request-Id` parameter declares (`format: uuid`).
+*/
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 const DEFAULT_BASE_URL = "https://api.haau3.com";
 const DEFAULT_TIMEOUT = 65e3;
 const DEFAULT_MAX_RETRIES = 1;
@@ -214,6 +253,85 @@ function noAnswerReason(status) {
 	if (status === 504) return "timeout";
 	return "server-error";
 }
+/** Appends a query to a URL's parameters: a list sends the parameter once per value, `undefined` sends none. */
+function appendQuery(params, query) {
+	for (const [name, value] of Object.entries(query ?? {})) {
+		if (value === void 0) continue;
+		for (const item of Array.isArray(value) ? value : [value]) params.append(name, String(item));
+	}
+}
+/**
+* What one answer means: the answer itself, or the error it is. A single call and each entry of a
+* batch are judged alike. `name` says which request it was, in words that carry no value a caller
+* sent: the method and the operation's path with its `{id}` left in.
+*/
+function judge(name, status, body, context) {
+	const { requestId, attempts, durationMs, expects } = context;
+	const timing = {
+		attempts,
+		durationMs,
+		correlationId: context.correlationId
+	};
+	if (status >= 200 && status < 300) {
+		if (body === void 0) return {
+			ok: false,
+			error: new NoAnswerError(`${name} answered ${status} with ${context.missing}.`, {
+				reason: "unreadable",
+				status,
+				requestId,
+				...timing
+			})
+		};
+		if (expects && !expects.includes(body?.resourceType)) {
+			const wanted = expects.map(withArticle).join(" or ");
+			return {
+				ok: false,
+				error: new NoAnswerError(`${name} answered ${describeAnswer(body)} where ${wanted} was expected.`, {
+					reason: "unreadable",
+					status,
+					requestId,
+					...timing
+				})
+			};
+		}
+		return {
+			ok: true,
+			data: body
+		};
+	}
+	const errorBody = readErrorBody(body);
+	if ((status === 401 || status === 403) && !context.entry) return {
+		ok: false,
+		error: new AuthError(`${name} was refused: the API key was not accepted (${status}).`, status, requestId, errorBody, timing)
+	};
+	if (status === 429 || status >= 500) {
+		const reason = noAnswerReason(status);
+		return {
+			ok: false,
+			error: new NoAnswerError(`${name} got no answer (${reason}, ${status}) after ${attempts} attempt${attempts === 1 ? "" : "s"}.`, {
+				reason,
+				status,
+				retryAfter: context.retryAfter,
+				requestId,
+				body: errorBody,
+				...timing
+			})
+		};
+	}
+	if (status >= 400) return {
+		ok: false,
+		error: new RefusedError(`${name} was refused (${status}).`, status, requestId, errorBody, timing)
+	};
+	return {
+		ok: false,
+		error: new NoAnswerError(`${name} answered ${status}, which is not an answer.`, {
+			reason: "unreadable",
+			status,
+			requestId,
+			...timing
+		})
+	};
+}
 /** The connection, retries and errors every operation shares. */
 var Transport = class {
 	#apiKey;
@@ -252,6 +370,7 @@ var Transport = class {
 			headers: sent.response.headers,
 			body: parseBody(sent.text, sent.response.headers.get("content-type")) ?? sent.text,
 			requestId: sent.response.headers.get("x-request-id") ?? void 0,
+			correlationId: sent.response.headers.get("x-correlation-id") ?? void 0,
 			attempts: sent.attempts,
 			durationMs: sent.durationMs
 		};
@@ -284,57 +403,26 @@ var Transport = class {
 		const { response, text, attempts, durationMs } = await this.#send(method, url, body, options, label);
 		const status = response.status;
 		const requestId = response.headers.get("x-request-id") ?? void 0;
-		const parsed = parseBody(text, response.headers.get("content-type"));
-		const name = `${method} ${label}`;
-		const timing = {
-			attempts,
-			durationMs
-		};
-		if (status >= 200 && status < 300) {
-			if (parsed === void 0) throw new NoAnswerError(`${name} answered ${status} with a body that is not JSON.`, {
-				reason: "unreadable",
-				status,
-				requestId,
-				...timing
-			});
-			if (expects && !expects.includes(parsed?.resourceType)) {
-				const wanted = expects.map(withArticle).join(" or ");
-				throw new NoAnswerError(`${name} answered ${describeAnswer(parsed)} where ${wanted} was expected.`, {
-					reason: "unreadable",
-					status,
-					requestId,
-					...timing
-				});
-			}
-			return {
-				data: parsed,
-				requestId,
-				durationMs,
-				attempts,
-				status,
-				headers: response.headers
-			};
-		}
-		const errorBody = readErrorBody(parsed);
-		if (status === 401 || status === 403) throw new AuthError(`${name} was refused: the API key was not accepted (${status}).`, status, requestId, errorBody, timing);
-		if (status === 429 || status >= 500) {
-			const reason = noAnswerReason(status);
-			throw new NoAnswerError(`${name} got no answer (${reason}, ${status}) after ${attempts} attempt${attempts === 1 ? "" : "s"}.`, {
-				reason,
-				status,
-				retryAfter: retryAfterSeconds(response.headers),
-				requestId,
-				body: errorBody,
-				...timing
-			});
-		}
-		if (status >= 400) throw new RefusedError(`${name} was refused (${status}).`, status, requestId, errorBody, timing);
-		throw new NoAnswerError(`${name} answered ${status}, which is not an answer.`, {
-			reason: "unreadable",
-			status,
+		const correlationId = response.headers.get("x-correlation-id") ?? void 0;
+		const verdict = judge(`${method} ${label}`, status, parseBody(text, response.headers.get("content-type")), {
 			requestId,
-			...timing
+			correlationId,
+			attempts,
+			durationMs,
+			retryAfter: retryAfterSeconds(response.headers),
+			expects,
+			missing: "a body that is not JSON"
 		});
+		if (!verdict.ok) throw verdict.error;
+		return {
+			data: verdict.data,
+			requestId,
+			correlationId,
+			durationMs,
+			attempts,
+			status,
+			headers: response.headers
+		};
 	}
 	/** A URL on this client's base, refusing any other host so the key is never sent to one. */
 	url(pathOrUrl) {
@@ -344,10 +432,7 @@ var Transport = class {
 		const base = new URL(this.baseURL);
 		const url = /^https?:\/\//i.test(pathOrUrl) ? new URL(pathOrUrl) : new URL(base.pathname.replace(/\/$/, "") + (pathOrUrl.startsWith("/") ? pathOrUrl : `/${pathOrUrl}`), base);
 		if (url.origin !== base.origin) throw new Haau3Error(`Refusing to send the API key to ${url.origin}: the client's baseURL is ${base.origin}.`);
-		for (const [name, value] of Object.entries(query ?? {})) {
-			if (value === void 0) continue;
-			for (const item of Array.isArray(value) ? value : [value]) url.searchParams.append(name, String(item));
-		}
+		appendQuery(url.searchParams, query);
 		return url;
 	}
 	async #send(method, url, body, options, label) {
@@ -363,6 +448,10 @@ var Transport = class {
 			headers["content-type"] = fhir ? FHIR_JSON : "application/json";
 		}
 		for (const [name, value] of Object.entries(options.headers ?? {})) headers[name.toLowerCase()] = value;
+		if (options.correlationId !== void 0) {
+			if (!UUID.test(options.correlationId)) throw new Haau3Error(`${method} ${label} was not sent: correlationId must be a UUID, which is all the API keeps (it drops anything else).`);
+			headers["x-request-id"] = options.correlationId;
+		}
 		const timeout = options.timeout ?? this.timeout;
 		const maxRetries = options.maxRetries ?? this.maxRetries;
 		const fetchOptions = {
@@ -420,6 +509,499 @@ var Transport = class {
 	}
 };
 //#endregion
+//#region src/batch.ts
+/** What the batch needs from each entry it sends, kept off the entry itself. */
+const made = /* @__PURE__ */ new WeakMap();
+/** An entry for one operation. Called by the generated builder. */
+function entry(call) {
+	let path = call.path;
+	for (const [name, value] of Object.entries(call.pathParams ?? {})) path = path.replace(`{${name}}`, encodeURIComponent(value));
+	const search = new URLSearchParams();
+	appendQuery(search, call.query);
+	const relative = path.slice(12);
+	const query = search.toString();
+	const url = query ? `${relative}?${query}` : relative;
+	const value = Object.freeze({
+		method: call.method,
+		url
+	});
+	made.set(value, {
+		label: `${call.method} ${call.path}`,
+		resource: call.body,
+		expects: call.expects
+	});
+	return value;
+}
+/** The batch Bundle for these entries. Throws for anything the builder did not make. */
+function batchBundle(entries) {
+	if (!Array.isArray(entries)) throw new Haau3Error("batch() takes a function that returns a list of entries made by the builder it is given.");
+	return {
+		resourceType: "Bundle",
+		type: "batch",
+		entry: entries.map((value, index) => {
+			const internal = typeof value === "object" && value !== null ? made.get(value) : void 0;
+			if (!internal) throw new Haau3Error(`Entry ${index + 1} of the batch was not made by the builder batch() hands you.`);
+			return {
+				request: {
+					method: value.method,
+					url: value.url
+				},
+				...internal.resource !== void 0 ? { resource: internal.resource } : {}
+			};
+		})
+	};
+}
+/** A batch entry's status: "200", or "200 OK" with its reason phrase, as FHIR allows. */
+function entryStatus(entry) {
+	const match = /^(\d{3})(?:\s|$)/.exec(entry?.response?.status ?? "");
+	return match ? Number(match[1]) : void 0;
+}
+/**
+* Reads a batch-response into one result per entry sent. FHIR R4 says a batch-response holds one
+* entry for each entry of the request, in the same order, so each answer is paired with its request
+* by position. An answer that is not a batch-response, or holds another number of entries, cannot be
+* paired at all and is no answer.
+*/
+function readBatch(entries, answer, meta) {
+	const { requestId, correlationId, attempts, durationMs, status } = meta;
+	const timing = {
+		attempts,
+		durationMs,
+		correlationId
+	};
+	const answered = answer.entry ?? [];
+	if (answer.type !== "batch-response") throw new NoAnswerError(`POST /v1/fhir/r4 answered a Bundle that is not a batch-response.`, {
+		reason: "unreadable",
+		status,
+		requestId,
+		...timing
+	});
+	if (answered.length !== entries.length) throw new NoAnswerError(`POST /v1/fhir/r4 answered ${answered.length} entries for a batch of ${entries.length}.`, {
+		reason: "unreadable",
+		status,
+		requestId,
+		...timing
+	});
+	return entries.map((value, index) => {
+		const internal = made.get(value);
+		const name = `${internal.label} (entry ${index + 1} of ${entries.length})`;
+		const answeredEntry = answered[index];
+		const entryCode = entryStatus(answeredEntry);
+		if (entryCode === void 0) return {
+			ok: false,
+			error: new NoAnswerError(`${name} answered with no status.`, {
+				reason: "unreadable",
+				requestId,
+				...timing
+			})
+		};
+		const verdict = judge(name, entryCode, answeredEntry?.resource ?? (entryCode >= 400 ? answeredEntry?.response?.outcome : void 0), {
+			requestId,
+			correlationId,
+			attempts,
+			durationMs,
+			expects: internal.expects,
+			missing: "no resource",
+			entry: true
+		});
+		return verdict.ok ? {
+			ok: true,
+			data: verdict.data,
+			status: entryCode
+		} : {
+			ok: false,
+			error: verdict.error
+		};
+	});
+}
+//#endregion
+//#region src/generated/batch.ts
+/**
+* Every operation a batch can carry, each called as on {@link Haau3} and returning an entry for the
+* batch instead of sending. Everything on the FHIR base but the batch itself and
+* `reconcileMedications`.
+*/
+var BatchBuilder = class {
+	/**
+	* Check providers against a plan's network, as one entry of a batch. Called as `Haau3.checkInsurancePlanNetwork` is.
+	*
+	* `GET /v1/fhir/r4/InsurancePlan/{id}/$in-network`
+	*/
+	checkInsurancePlanNetwork(id, params) {
+		return entry({
+			method: "GET",
+			path: "/v1/fhir/r4/InsurancePlan/{id}/$in-network",
+			pathParams: { id },
+			query: params,
+			expects: ["Parameters"]
+		});
+	}
+	/**
+	* Look up a code, as one entry of a batch. Called as `Haau3.codeSystemLookup` is.
+	*
+	* `GET /v1/fhir/r4/CodeSystem/$lookup`
+	*/
+	codeSystemLookup(params) {
+		return entry({
+			method: "GET",
+			path: "/v1/fhir/r4/CodeSystem/$lookup",
+			query: params,
+			expects: ["Parameters"]
+		});
+	}
+	/**
+	* Look up a code, as one entry of a batch. Called as `Haau3.codeSystemLookupPost` is.
+	*
+	* `POST /v1/fhir/r4/CodeSystem/$lookup`
+	*/
+	codeSystemLookupPost(body) {
+		return entry({
+			method: "POST",
+			path: "/v1/fhir/r4/CodeSystem/$lookup",
+			body,
+			expects: ["Parameters"]
+		});
+	}
+	/**
+	* Validate a code in a code system, as one entry of a batch. Called as `Haau3.codeSystemValidateCode` is.
+	*
+	* `GET /v1/fhir/r4/CodeSystem/$validate-code`
+	*/
+	codeSystemValidateCode(params) {
+		return entry({
+			method: "GET",
+			path: "/v1/fhir/r4/CodeSystem/$validate-code",
+			query: params,
+			expects: ["Parameters"]
+		});
+	}
+	/**
+	* Validate a code in a code system, as one entry of a batch. Called as `Haau3.codeSystemValidateCodePost` is.
+	*
+	* `POST /v1/fhir/r4/CodeSystem/$validate-code`
+	*/
+	codeSystemValidateCodePost(body) {
+		return entry({
+			method: "POST",
+			path: "/v1/fhir/r4/CodeSystem/$validate-code",
+			body,
+			expects: ["Parameters"]
+		});
+	}
+	/**
+	* Capability statement, as one entry of a batch. Called as `Haau3.fhirMetadata` is.
+	*
+	* `GET /v1/fhir/r4/metadata`
+	*/
+	fhirMetadata(params) {
+		return entry({
+			method: "GET",
+			path: "/v1/fhir/r4/metadata",
+			query: params,
+			expects: ["CapabilityStatement", "TerminologyCapabilities"]
+		});
+	}
+	/**
+	* List a state's counties, as one entry of a batch. Called as `Haau3.listInsurancePlanCounties` is.
+	*
+	* `GET /v1/fhir/r4/InsurancePlan/$counties`
+	*/
+	listInsurancePlanCounties(params) {
+		return entry({
+			method: "GET",
+			path: "/v1/fhir/r4/InsurancePlan/$counties",
+			query: params,
+			expects: ["Parameters"]
+		});
+	}
+	/**
+	* Read an Endpoint, as one entry of a batch. Called as `Haau3.readEndpoint` is.
+	*
+	* `GET /v1/fhir/r4/Endpoint/{id}`
+	*/
+	readEndpoint(id) {
+		return entry({
+			method: "GET",
+			path: "/v1/fhir/r4/Endpoint/{id}",
+			pathParams: { id },
+			expects: ["Endpoint"]
+		});
+	}
+	/**
+	* Read a HealthcareService, as one entry of a batch. Called as `Haau3.readHealthcareService` is.
+	*
+	* `GET /v1/fhir/r4/HealthcareService/{id}`
+	*/
+	readHealthcareService(id) {
+		return entry({
+			method: "GET",
+			path: "/v1/fhir/r4/HealthcareService/{id}",
+			pathParams: { id },
+			expects: ["HealthcareService"]
+		});
+	}
+	/**
+	* Read a plan, as one entry of a batch. Called as `Haau3.readInsurancePlan` is.
+	*
+	* `GET /v1/fhir/r4/InsurancePlan/{id}`
+	*/
+	readInsurancePlan(id) {
+		return entry({
+			method: "GET",
+			path: "/v1/fhir/r4/InsurancePlan/{id}",
+			pathParams: { id },
+			expects: ["InsurancePlan"]
+		});
+	}
+	/**
+	* Read a Location, as one entry of a batch. Called as `Haau3.readLocation` is.
+	*
+	* `GET /v1/fhir/r4/Location/{id}`
+	*/
+	readLocation(id) {
+		return entry({
+			method: "GET",
+			path: "/v1/fhir/r4/Location/{id}",
+			pathParams: { id },
+			expects: ["Location"]
+		});
+	}
+	/**
+	* Read an Organization, as one entry of a batch. Called as `Haau3.readOrganization` is.
+	*
+	* `GET /v1/fhir/r4/Organization/{id}`
+	*/
+	readOrganization(id) {
+		return entry({
+			method: "GET",
+			path: "/v1/fhir/r4/Organization/{id}",
+			pathParams: { id },
+			expects: ["Organization"]
+		});
+	}
+	/**
+	* Read an OrganizationAffiliation, as one entry of a batch. Called as `Haau3.readOrganizationAffiliation` is.
+	*
+	* `GET /v1/fhir/r4/OrganizationAffiliation/{id}`
+	*/
+	readOrganizationAffiliation(id) {
+		return entry({
+			method: "GET",
+			path: "/v1/fhir/r4/OrganizationAffiliation/{id}",
+			pathParams: { id },
+			expects: ["OrganizationAffiliation"]
+		});
+	}
+	/**
+	* Read a Practitioner, as one entry of a batch. Called as `Haau3.readPractitioner` is.
+	*
+	* `GET /v1/fhir/r4/Practitioner/{id}`
+	*/
+	readPractitioner(id) {
+		return entry({
+			method: "GET",
+			path: "/v1/fhir/r4/Practitioner/{id}",
+			pathParams: { id },
+			expects: ["Practitioner"]
+		});
+	}
+	/**
+	* Read a PractitionerRole, as one entry of a batch. Called as `Haau3.readPractitionerRole` is.
+	*
+	* `GET /v1/fhir/r4/PractitionerRole/{id}`
+	*/
+	readPractitionerRole(id) {
+		return entry({
+			method: "GET",
+			path: "/v1/fhir/r4/PractitionerRole/{id}",
+			pathParams: { id },
+			expects: ["PractitionerRole"]
+		});
+	}
+	/**
+	* Read a questionnaire, as one entry of a batch. Called as `Haau3.readQuestionnaire` is.
+	*
+	* `GET /v1/fhir/r4/Questionnaire/{id}`
+	*/
+	readQuestionnaire(id) {
+		return entry({
+			method: "GET",
+			path: "/v1/fhir/r4/Questionnaire/{id}",
+			pathParams: { id },
+			expects: ["Questionnaire"]
+		});
+	}
+	/**
+	* Find endpoints, as one entry of a batch. Called as `Haau3.searchEndpoint` is.
+	*
+	* `GET /v1/fhir/r4/Endpoint`
+	*/
+	searchEndpoint(params) {
+		return entry({
+			method: "GET",
+			path: "/v1/fhir/r4/Endpoint",
+			query: params,
+			expects: ["Bundle"]
+		});
+	}
+	/**
+	* Find healthcare services, as one entry of a batch. Called as `Haau3.searchHealthcareService` is.
+	*
+	* `GET /v1/fhir/r4/HealthcareService`
+	*/
+	searchHealthcareService(params) {
+		return entry({
+			method: "GET",
+			path: "/v1/fhir/r4/HealthcareService",
+			query: params,
+			expects: ["Bundle"]
+		});
+	}
+	/**
+	* Find a plan, as one entry of a batch. Called as `Haau3.searchInsurancePlan` is.
+	*
+	* `GET /v1/fhir/r4/InsurancePlan`
+	*/
+	searchInsurancePlan(params) {
+		return entry({
+			method: "GET",
+			path: "/v1/fhir/r4/InsurancePlan",
+			query: params,
+			expects: ["Bundle"]
+		});
+	}
+	/**
+	* Find practice locations, as one entry of a batch. Called as `Haau3.searchLocation` is.
+	*
+	* `GET /v1/fhir/r4/Location`
+	*/
+	searchLocation(params) {
+		return entry({
+			method: "GET",
+			path: "/v1/fhir/r4/Location",
+			query: params,
+			expects: ["Bundle"]
+		});
+	}
+	/**
+	* Find organizations, payers and networks, as one entry of a batch. Called as `Haau3.searchOrganization` is.
+	*
+	* `GET /v1/fhir/r4/Organization`
+	*/
+	searchOrganization(params) {
+		return entry({
+			method: "GET",
+			path: "/v1/fhir/r4/Organization",
+			query: params,
+			expects: ["Bundle"]
+		});
+	}
+	/**
+	* Find the organizations in a network, as one entry of a batch. Called as `Haau3.searchOrganizationAffiliation` is.
+	*
+	* `GET /v1/fhir/r4/OrganizationAffiliation`
+	*/
+	searchOrganizationAffiliation(params) {
+		return entry({
+			method: "GET",
+			path: "/v1/fhir/r4/OrganizationAffiliation",
+			query: params,
+			expects: ["Bundle"]
+		});
+	}
+	/**
+	* Find a practitioner by NPI or name, as one entry of a batch. Called as `Haau3.searchPractitioner` is.
+	*
+	* `GET /v1/fhir/r4/Practitioner`
+	*/
+	searchPractitioner(params) {
+		return entry({
+			method: "GET",
+			path: "/v1/fhir/r4/Practitioner",
+			query: params,
+			expects: ["Bundle"]
+		});
+	}
+	/**
+	* Find practitioner roles, as one entry of a batch. Called as `Haau3.searchPractitionerRole` is.
+	*
+	* `GET /v1/fhir/r4/PractitionerRole`
+	*/
+	searchPractitionerRole(params) {
+		return entry({
+			method: "GET",
+			path: "/v1/fhir/r4/PractitionerRole",
+			query: params,
+			expects: ["Bundle"]
+		});
+	}
+	/**
+	* List or find a questionnaire, as one entry of a batch. Called as `Haau3.searchQuestionnaire` is.
+	*
+	* `GET /v1/fhir/r4/Questionnaire`
+	*/
+	searchQuestionnaire(params) {
+		return entry({
+			method: "GET",
+			path: "/v1/fhir/r4/Questionnaire",
+			query: params,
+			expects: ["Bundle"]
+		});
+	}
+	/**
+	* Expand a value set, as one entry of a batch. Called as `Haau3.valueSetExpand` is.
+	*
+	* `GET /v1/fhir/r4/ValueSet/$expand`
+	*/
+	valueSetExpand(params) {
+		return entry({
+			method: "GET",
+			path: "/v1/fhir/r4/ValueSet/$expand",
+			query: params,
+			expects: ["ValueSet"]
+		});
+	}
+	/**
+	* Expand a value set, as one entry of a batch. Called as `Haau3.valueSetExpandPost` is.
+	*
+	* `POST /v1/fhir/r4/ValueSet/$expand`
+	*/
+	valueSetExpandPost(body) {
+		return entry({
+			method: "POST",
+			path: "/v1/fhir/r4/ValueSet/$expand",
+			body,
+			expects: ["ValueSet"]
+		});
+	}
+	/**
+	* Validate a code against a value set, as one entry of a batch. Called as `Haau3.valueSetValidateCode` is.
+	*
+	* `GET /v1/fhir/r4/ValueSet/$validate-code`
+	*/
+	valueSetValidateCode(params) {
+		return entry({
+			method: "GET",
+			path: "/v1/fhir/r4/ValueSet/$validate-code",
+			query: params,
+			expects: ["Parameters"]
+		});
+	}
+	/**
+	* Validate a code against a value set, as one entry of a batch. Called as `Haau3.valueSetValidateCodePost` is.
+	*
+	* `POST /v1/fhir/r4/ValueSet/$validate-code`
+	*/
+	valueSetValidateCodePost(body) {
+		return entry({
+			method: "POST",
+			path: "/v1/fhir/r4/ValueSet/$validate-code",
+			body,
+			expects: ["Parameters"]
+		});
+	}
+};
+//#endregion
 //#region src/generated/methods.ts
 /** Every operation of the haau3 platform API. {@link Haau3} is the class to construct. */
 var Operations = class extends Transport {
@@ -989,6 +1571,8 @@ var Operations = class extends Transport {
 };
 //#endregion
 //#region src/client.ts
+/** The builder every batch is handed. It holds nothing, so one serves every call. */
+const builder = new BatchBuilder();
 /**
 * The haau3 platform API client.
 *
@@ -1028,6 +1612,45 @@ var Haau3 = class extends Operations {
 			page = await this.answer("GET", url, void 0, options, url.pathname, ["Bundle"]);
 		}
 	}
+	/**
+	* Several operations of the FHIR base in one request, each with its own answer or error, in the
+	* order given. The function you pass gets a builder with every operation a batch can carry, called
+	* as on this client; what it returns is sent.
+	*
+	* ```ts
+	* const [plan, counties] = await haau3.batch((b) => [
+	*   b.readInsurancePlan("H2406-013-000"),
+	*   b.listInsurancePlanCounties({ state: "NC" }),
+	* ]);
+	* if (plan.ok) plan.data; // fhir4.InsurancePlan
+	* else plan.error; // RefusedError or NoAnswerError, as the call alone would have thrown
+	* ```
+	*
+	* Each entry is checked as the call alone is, and fails alone: its result is `{ ok: false, error }`
+	* and the others still answer. An entry that fails is not retried. The batch itself is retried,
+	* and throws, as any call does: an {@link AuthError}, a {@link NoAnswerError} when no answer came
+	* back, a {@link RefusedError} when the API refused the whole batch. The API takes up to 100
+	* entries in up to 1 MiB, and gives a batch 60 seconds; a larger batch is refused, so send several.
+	* `reconcileMedications` cannot go in a batch.
+	*/
+	batch(build, options = {}) {
+		let entries;
+		let bundle;
+		try {
+			entries = build(builder);
+			bundle = batchBundle(entries);
+		} catch (error) {
+			return new APIPromise(Promise.reject(error));
+		}
+		return new APIPromise(this.#sendBatch(entries, bundle, options));
+	}
+	async #sendBatch(entries, bundle, options) {
+		const { data, ...meta } = await this.respond("POST", this.url("/v1/fhir/r4"), bundle, options, "/v1/fhir/r4", ["Bundle"]);
+		return {
+			...meta,
+			data: readBatch(entries, data, meta)
+		};
+	}
 };
 //#endregion
 export { APIPromise, AuthError, Haau3, Haau3Error, NoAnswerError, RefusedError, VERSION };