@haau3/sdk 0.0.0 → 0.1.0

package/dist/index.mjs

@@ -0,0 +1,886 @@
+//#region src/errors.ts
+/** 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;
+	constructor(message, requestId, options) {
+		super(message, options);
+		this.requestId = requestId;
+	}
+};
+/**
+* Attaches the body the API answered with, readable by code but never printed: the property is
+* not enumerable, so `console.log(error)`, `util.inspect` and `JSON.stringify` leave it out. A body
+* can repeat what the request carried, and for some operations that is a patient's data.
+*/
+function attachBody(error, body) {
+	if (!body) return;
+	const key = body.kind === "outcome" ? "outcome" : "problem";
+	Object.defineProperty(error, key, {
+		value: body.value,
+		enumerable: false,
+		writable: false,
+		configurable: false
+	});
+}
+/** The API refused the key: none was sent, it is not one the API knows, or it was revoked (401, 403). */
+var AuthError = class extends Haau3Error {
+	name = "AuthError";
+	status;
+	constructor(message, status, requestId, body) {
+		super(message, requestId);
+		this.status = status;
+		attachBody(this, body);
+	}
+};
+/**
+* The API answered and refused the request: a parameter it does not take, a record that does not
+* exist (404), a page that no longer exists (410), a body that is too large (413). `status` says
+* which, and the body says why.
+*/
+var RefusedError = class extends Haau3Error {
+	name = "RefusedError";
+	status;
+	constructor(message, status, requestId, body) {
+		super(message, requestId);
+		this.status = status;
+		attachBody(this, body);
+	}
+};
+/**
+* The request got no answer, after every attempt the client was allowed. This never means "no
+* results": an empty search answers with an empty Bundle or list, not with this error.
+*/
+var NoAnswerError = class extends Haau3Error {
+	name = "NoAnswerError";
+	reason;
+	/** The last status the API answered with, when it answered at all. */
+	status;
+	/** Seconds to wait before trying again, when the API said. */
+	retryAfter;
+	/** How many attempts were made. */
+	attempts;
+	constructor(message, details) {
+		super(message, details.requestId, details.cause === void 0 ? void 0 : { cause: details.cause });
+		this.reason = details.reason;
+		this.status = details.status;
+		this.retryAfter = details.retryAfter;
+		this.attempts = details.attempts;
+		attachBody(this, details.body);
+	}
+};
+//#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.1.0";
+//#endregion
+//#region src/transport.ts
+const DEFAULT_BASE_URL = "https://api.haau3.com";
+const DEFAULT_TIMEOUT = 65e3;
+const DEFAULT_MAX_RETRIES = 1;
+/** The longest `Retry-After` the client waits out. A longer one fails at once and says when. */
+const LONGEST_WAIT_SECONDS = 60;
+const FHIR_JSON = "application/fhir+json";
+/**
+* True in a browser. A key in a browser is public, and the API answers no browser anyway (it sends
+* no CORS headers). jsdom, which test runners use to render components on a server, is not one.
+*/
+function inBrowser() {
+	const g = globalThis;
+	return typeof g.window !== "undefined" && typeof g.document !== "undefined" && !(g.navigator?.userAgent ?? "").includes("jsdom");
+}
+function envKey() {
+	return globalThis.process?.env?.HAAU3_API_KEY || void 0;
+}
+/** Seconds from a `Retry-After` header, when it holds a number of seconds. */
+function retryAfterSeconds(headers) {
+	const value = headers.get("retry-after");
+	if (value === null || !/^\d+$/.test(value.trim())) return void 0;
+	return Number(value.trim());
+}
+/** Exponential backoff with jitter: about 0.5 s, then 1 s, 2 s and so on, never past 8 s. */
+function backoff(attempt) {
+	return Math.min(8e3, 500 * 2 ** (attempt - 1)) * (.5 + Math.random() * .5);
+}
+function sleep(ms, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) return reject(signal.reason);
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(signal.reason);
+		};
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+function parseBody(text, contentType) {
+	if (!contentType || !/json/i.test(contentType)) return void 0;
+	try {
+		return JSON.parse(text);
+	} catch {
+		return;
+	}
+}
+function readErrorBody(body) {
+	if (!body || typeof body !== "object") return void 0;
+	const record = body;
+	if (record.resourceType === "OperationOutcome") return {
+		kind: "outcome",
+		value: body
+	};
+	if (typeof record.type === "string" && typeof record.status === "number") return {
+		kind: "problem",
+		value: body
+	};
+}
+function noAnswerReason(status) {
+	if (status === 429) return "rate-limited";
+	if (status === 502 || status === 503) return "unavailable";
+	if (status === 504) return "timeout";
+	return "server-error";
+}
+/** The connection, retries and errors every operation shares. */
+var Transport = class {
+	#apiKey;
+	#fetch;
+	/** Where requests go. */
+	baseURL;
+	/** Milliseconds one attempt may take. */
+	timeout;
+	/** How many times a request is retried. */
+	maxRetries;
+	constructor(options = {}) {
+		if (inBrowser()) throw new Haau3Error("@haau3/sdk runs on a server only: an API key in a browser is public. Call the API from your server.");
+		const apiKey = options.apiKey ?? envKey();
+		if (!apiKey) throw new Haau3Error("No API key: pass apiKey, or set HAAU3_API_KEY.");
+		const fetchImpl = options.fetch ?? globalThis.fetch;
+		if (!fetchImpl) throw new Haau3Error("No fetch: pass one as the fetch option. Node 22 and newer have one.");
+		this.#apiKey = apiKey;
+		this.#fetch = fetchImpl;
+		this.baseURL = (options.baseURL ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+		this.timeout = options.timeout ?? DEFAULT_TIMEOUT;
+		this.maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+	}
+	/**
+	* Sends any request and returns what the API answered, whatever its status. Throws only when no
+	* answer arrived ({@link NoAnswerError}), or for a URL that is not on the client's own `baseURL`.
+	*/
+	async request(request) {
+		const url = this.#url(request.path, request.query);
+		const sent = await this.#send(request.method, url, request.body, request, url.pathname);
+		return {
+			status: sent.response.status,
+			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,
+			attempts: sent.attempts,
+			durationMs: sent.durationMs
+		};
+	}
+	/** Runs one operation of the spec and returns its answer, or throws one of the three errors. */
+	async operation(call, options = {}) {
+		let path = call.path;
+		for (const [name, value] of Object.entries(call.pathParams ?? {})) path = path.replace(`{${name}}`, encodeURIComponent(value));
+		return this.answer(call.method, this.#url(path, call.query), call.body, options, call.path);
+	}
+	/**
+	* Sends a request and reads its answer. `label` names the request in an error message: the
+	* operation's path with its `{id}` left in, so no value a caller sent ends up in a message.
+	*/
+	async answer(method, url, body, options, label) {
+		const { response, text, attempts } = 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}`;
+		if (status >= 200 && status < 300) {
+			if (parsed === void 0) throw new NoAnswerError(`${name} answered ${status} with a body that is not JSON.`, {
+				reason: "unreadable",
+				attempts,
+				status,
+				requestId
+			});
+			return parsed;
+		}
+		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);
+		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,
+				attempts,
+				status,
+				retryAfter: retryAfterSeconds(response.headers),
+				requestId,
+				body: errorBody
+			});
+		}
+		if (status >= 400) throw new RefusedError(`${name} was refused (${status}).`, status, requestId, errorBody);
+		throw new NoAnswerError(`${name} answered ${status}, which is not an answer.`, {
+			reason: "unreadable",
+			attempts,
+			status,
+			requestId
+		});
+	}
+	/** A URL on this client's base, refusing any other host so the key is never sent to one. */
+	url(pathOrUrl) {
+		return this.#url(pathOrUrl, void 0);
+	}
+	#url(pathOrUrl, query) {
+		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));
+		}
+		return url;
+	}
+	async #send(method, url, body, options, label) {
+		const fhir = url.pathname.startsWith("/v1/fhir/") || url.pathname === "/v1/fhir";
+		const headers = {
+			accept: fhir ? FHIR_JSON : "application/json",
+			authorization: `Bearer ${this.#apiKey}`,
+			"user-agent": `haau3-sdk/${VERSION}`
+		};
+		let payload;
+		if (body !== void 0) {
+			payload = typeof body === "string" ? body : JSON.stringify(body);
+			headers["content-type"] = fhir ? FHIR_JSON : "application/json";
+		}
+		for (const [name, value] of Object.entries(options.headers ?? {})) headers[name.toLowerCase()] = value;
+		const timeout = options.timeout ?? this.timeout;
+		const maxRetries = options.maxRetries ?? this.maxRetries;
+		const started = Date.now();
+		let attempt = 0;
+		for (;;) {
+			attempt += 1;
+			const attemptSignal = AbortSignal.timeout(timeout);
+			const signal = options.signal ? AbortSignal.any([options.signal, attemptSignal]) : attemptSignal;
+			const canRetry = attempt <= maxRetries;
+			let response;
+			let text;
+			try {
+				response = await this.#fetch(url, {
+					method,
+					headers,
+					body: payload,
+					signal,
+					redirect: "manual"
+				});
+				text = await response.text();
+			} catch (error) {
+				if (options.signal?.aborted) throw options.signal.reason;
+				const reason = attemptSignal.aborted ? "timeout" : "network";
+				if (canRetry) {
+					await sleep(backoff(attempt), options.signal);
+					continue;
+				}
+				throw new NoAnswerError(`${method} ${label} got no answer (${reason}) after ${attempt} attempt${attempt === 1 ? "" : "s"}.`, {
+					reason,
+					attempts: attempt,
+					cause: error
+				});
+			}
+			if ((response.status === 429 || response.status >= 500) && canRetry) {
+				const wait = retryAfterSeconds(response.headers);
+				if (wait === void 0 || wait <= LONGEST_WAIT_SECONDS) {
+					await sleep(wait === void 0 ? backoff(attempt) : wait * 1e3, options.signal);
+					continue;
+				}
+			}
+			return {
+				response,
+				text,
+				attempts: attempt,
+				durationMs: Date.now() - started
+			};
+		}
+	}
+};
+//#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 {
+	/**
+	* Check providers against a plan's network
+	*
+	* FHIR instance-level operation `$in-network` on InsurancePlan: for each NPI, whether the CMS National Provider Directory lists the provider in a network this plan names, for the plan's year. The answer is a `Parameters` resource: the `plan`; the directory's `data-date`; one `network` per network checked, with the number of organizations it lists; a `reason` when there is no network data; a Marketplace plan's own `directory`; one `provider` per NPI, in the order sent, with its `status` (`in-network`, `not-found`, `not-in-directory` or `no-network-data`) and, when listed, `evidence` references to the directory's records on this base; then a `source` when the directory was asked. `not-found` never means out of network: the directory's network data is incomplete, and a listing is not a statement of a contract. All or nothing: a lookup that fails fails the whole answer. GET only. Defined by the haau3 implementation guide (`https://haau3.com/fhir/OperationDefinition/InsurancePlan-in-network`).
+	*
+	* `GET /v1/fhir/r4/InsurancePlan/{id}/$in-network`
+	*/
+	checkInsurancePlanNetwork(id, params, options) {
+		return this.operation({
+			method: "GET",
+			path: "/v1/fhir/r4/InsurancePlan/{id}/$in-network",
+			pathParams: { id },
+			query: params
+		}, options);
+	}
+	/**
+	* Look up a code
+	*
+	* FHIR `CodeSystem/$lookup`. Returns a code's display and requested properties. On POST, a `coding` parameter may stand in for `system` + `code`.
+	*
+	* `GET /v1/fhir/r4/CodeSystem/$lookup`
+	*/
+	codeSystemLookup(params, options) {
+		return this.operation({
+			method: "GET",
+			path: "/v1/fhir/r4/CodeSystem/$lookup",
+			query: params
+		}, options);
+	}
+	/**
+	* Look up a code
+	*
+	* FHIR `CodeSystem/$lookup`. Returns a code's display and requested properties. On POST, a `coding` parameter may stand in for `system` + `code`.
+	*
+	* `POST /v1/fhir/r4/CodeSystem/$lookup`
+	*/
+	codeSystemLookupPost(body, options) {
+		return this.operation({
+			method: "POST",
+			path: "/v1/fhir/r4/CodeSystem/$lookup",
+			body
+		}, options);
+	}
+	/**
+	* Validate a code in a code system
+	*
+	* FHIR `CodeSystem/$validate-code`. Asks whether a code exists in a code system — distinct from the ValueSet operation of the same name, which asks about membership of a particular set. On POST, a `coding` or `codeableConcept` parameter may stand in for `url` + `code`; a codeableConcept validates if any of its codings does.
+	*
+	* `GET /v1/fhir/r4/CodeSystem/$validate-code`
+	*/
+	codeSystemValidateCode(params, options) {
+		return this.operation({
+			method: "GET",
+			path: "/v1/fhir/r4/CodeSystem/$validate-code",
+			query: params
+		}, options);
+	}
+	/**
+	* Validate a code in a code system
+	*
+	* FHIR `CodeSystem/$validate-code`. Asks whether a code exists in a code system — distinct from the ValueSet operation of the same name, which asks about membership of a particular set. On POST, a `coding` or `codeableConcept` parameter may stand in for `url` + `code`; a codeableConcept validates if any of its codings does.
+	*
+	* `POST /v1/fhir/r4/CodeSystem/$validate-code`
+	*/
+	codeSystemValidateCodePost(body, options) {
+		return this.operation({
+			method: "POST",
+			path: "/v1/fhir/r4/CodeSystem/$validate-code",
+			body
+		}, options);
+	}
+	/**
+	* Run several operations in one request (batch)
+	*
+	* POST a FHIR `Bundle` with `type: batch` to send several requests in one round trip. Each entry's `request.url` is relative to this base and may be any read, search or operation of any service on it, except `$reconcile-medications`, which a batch refuses by name. Entries are independent: one that fails, such as a lookup of an unknown code, does not fail the others, and each carries its own status in the `batch-response`. For example, a batch of 50 terminology lookups measured about 4.8 ms per code, against 181 ms each when sent one at a time. Transaction bundles are not accepted: nothing on this base writes, so all or nothing would only turn one bad entry into a wholly failed request. A batch carries at most 100 entries in at most 1 MiB, and has 60 seconds: an entry still running then answers `504` inside the `200`. See https://docs.haau3.com/errors#limits.
+	*
+	* `POST /v1/fhir/r4`
+	*/
+	fhirBatch(body, options) {
+		return this.operation({
+			method: "POST",
+			path: "/v1/fhir/r4",
+			body
+		}, options);
+	}
+	/**
+	* Capability statement
+	*
+	* FHIR `[base]/metadata`. Returns the `CapabilityStatement` for this service, or a `TerminologyCapabilities` when called with `?mode=terminology` — which lists the code systems served, and names those that are recognised but not served. `mode` is the only parameter it takes.
+	*
+	* `GET /v1/fhir/r4/metadata`
+	*/
+	fhirMetadata(params, options) {
+		return this.operation({
+			method: "GET",
+			path: "/v1/fhir/r4/metadata",
+			query: params
+		}, options);
+	}
+	/**
+	* List a state's counties
+	*
+	* FHIR type-level operation `$counties` on InsurancePlan: the counties and county equivalents of a state, the District of Columbia or a territory, sorted by name, each with the five-digit FIPS code `coverage-area-county` takes. The answer is a `Parameters` resource: one `county` parameter per county, whose `code` part is a Coding in `http://terminology.hl7.org/CodeSystem/FIPS64` with the county's name as its display and whose `state` part is the state's code, then a `source` parameter naming the list: the U.S. Census Bureau's 2020 county codes. It answers whether or not a plan is sold in a county. GET only. Defined by the haau3 implementation guide (`https://haau3.com/fhir/OperationDefinition/InsurancePlan-counties`).
+	*
+	* `GET /v1/fhir/r4/InsurancePlan/$counties`
+	*/
+	listInsurancePlanCounties(params, options) {
+		return this.operation({
+			method: "GET",
+			path: "/v1/fhir/r4/InsurancePlan/$counties",
+			query: params
+		}, options);
+	}
+	/**
+	* List scheduling publishers
+	*
+	* Returns the SMART Scheduling Links publishers (sources) the platform ingests. Requires a valid API key.
+	*
+	* `GET /v1/scheduling/publishers`
+	*/
+	listPublishers(options) {
+		return this.operation({
+			method: "GET",
+			path: "/v1/scheduling/publishers"
+		}, options);
+	}
+	/**
+	* List service types
+	*
+	* Returns the distinct service types observed across served slots, each with its `system` and a `count` of the slots carrying it. It is a discovery aid for the `serviceTypeCode` filter on `GET /v1/scheduling/slots`. Requires a valid API key.
+	*
+	* `GET /v1/scheduling/service-types`
+	*/
+	listServiceTypes(params, options) {
+		return this.operation({
+			method: "GET",
+			path: "/v1/scheduling/service-types",
+			query: params
+		}, options);
+	}
+	/**
+	* List specialties
+	*
+	* Returns the distinct specialties observed across served slots, from the provider's `specialties` and the schedule's, each with its `system` and a `count` of the slots carrying it. It is a discovery aid for the `specialty` filter on `GET /v1/scheduling/slots`. Codes are each publisher's own. Requires a valid API key.
+	*
+	* `GET /v1/scheduling/specialties`
+	*/
+	listSpecialties(params, options) {
+		return this.operation({
+			method: "GET",
+			path: "/v1/scheduling/specialties",
+			query: params
+		}, options);
+	}
+	/**
+	* Read an Endpoint
+	*
+	* Read one endpoint by id, as returned by a search on this service.
+	*
+	* `GET /v1/fhir/r4/Endpoint/{id}`
+	*/
+	readEndpoint(id, options) {
+		return this.operation({
+			method: "GET",
+			path: "/v1/fhir/r4/Endpoint/{id}",
+			pathParams: { id }
+		}, options);
+	}
+	/**
+	* Read a HealthcareService
+	*
+	* Read one healthcare service by id, as returned by a search on this service.
+	*
+	* `GET /v1/fhir/r4/HealthcareService/{id}`
+	*/
+	readHealthcareService(id, options) {
+		return this.operation({
+			method: "GET",
+			path: "/v1/fhir/r4/HealthcareService/{id}",
+			pathParams: { id }
+		}, options);
+	}
+	/**
+	* Read a plan
+	*
+	* Read one plan by its id. A Medicare Advantage plan's id is CMS's plan id with the segment in three digits (`H2406-013-000`); a Marketplace plan's is its HIOS plan id with the variant (`19898FL0340001-01`). The plan conforms to the haau3 Plan Benefits profile and to the SBC InsurancePlan profile of the CARIN Digital Insurance Card guide, 2.0.0-ballot, and names the CMS release it was read from.
+	*
+	* `GET /v1/fhir/r4/InsurancePlan/{id}`
+	*/
+	readInsurancePlan(id, options) {
+		return this.operation({
+			method: "GET",
+			path: "/v1/fhir/r4/InsurancePlan/{id}",
+			pathParams: { id }
+		}, options);
+	}
+	/**
+	* Read a Location
+	*
+	* Read one location by id, as returned by a search on this service.
+	*
+	* `GET /v1/fhir/r4/Location/{id}`
+	*/
+	readLocation(id, options) {
+		return this.operation({
+			method: "GET",
+			path: "/v1/fhir/r4/Location/{id}",
+			pathParams: { id }
+		}, options);
+	}
+	/**
+	* Read an Organization
+	*
+	* Read one organization, payer or network by id, as returned by a search on this service.
+	*
+	* `GET /v1/fhir/r4/Organization/{id}`
+	*/
+	readOrganization(id, options) {
+		return this.operation({
+			method: "GET",
+			path: "/v1/fhir/r4/Organization/{id}",
+			pathParams: { id }
+		}, options);
+	}
+	/**
+	* Read an OrganizationAffiliation
+	*
+	* Read one organization affiliation by id, as returned by a search on this service.
+	*
+	* `GET /v1/fhir/r4/OrganizationAffiliation/{id}`
+	*/
+	readOrganizationAffiliation(id, options) {
+		return this.operation({
+			method: "GET",
+			path: "/v1/fhir/r4/OrganizationAffiliation/{id}",
+			pathParams: { id }
+		}, options);
+	}
+	/**
+	* Read a Practitioner
+	*
+	* Read one practitioner by id, as returned by a search on this service.
+	*
+	* `GET /v1/fhir/r4/Practitioner/{id}`
+	*/
+	readPractitioner(id, options) {
+		return this.operation({
+			method: "GET",
+			path: "/v1/fhir/r4/Practitioner/{id}",
+			pathParams: { id }
+		}, options);
+	}
+	/**
+	* Read a PractitionerRole
+	*
+	* Read one practitioner role by id, as returned by a search on this service.
+	*
+	* `GET /v1/fhir/r4/PractitionerRole/{id}`
+	*/
+	readPractitionerRole(id, options) {
+		return this.operation({
+			method: "GET",
+			path: "/v1/fhir/r4/PractitionerRole/{id}",
+			pathParams: { id }
+		}, options);
+	}
+	/**
+	* Read a questionnaire
+	*
+	* Read one questionnaire by id. Ids are the identifier its source gives the instrument, for example `44249-1`. A search with no parameters lists the ids this service holds copies of; any other id its source publishes is fetched live.
+	*
+	* The resource is returned exactly as its source publishes it, including its `copyright` and the order of every answer option.
+	*
+	* `GET /v1/fhir/r4/Questionnaire/{id}`
+	*/
+	readQuestionnaire(id, options) {
+		return this.operation({
+			method: "GET",
+			path: "/v1/fhir/r4/Questionnaire/{id}",
+			pathParams: { id }
+		}, options);
+	}
+	/**
+	* Reconcile one patient's medication records
+	*
+	* FHIR system-level operation `$reconcile-medications`. POST one patient's MedicationRequest, MedicationStatement, MedicationDispense and MedicationAdministration records, with the Medications they reference, as a `collection` or `searchset` Bundle; every entry needs a `fullUrl`. The response is one reconciled medication list: a `collection` Bundle holding one reconciled MedicationRequest per clinical drug, a Provenance for each naming the records behind it, and an OperationOutcome when a record was skipped. To evaluate the list as of another date, POST a Parameters resource with `resource` parts, or one `bundle` part, and an `asOf` part. This operation receives patient data, so send it only under an executed agreement. Nothing a request carries is stored or logged, apart from the request's ids, and the operation is not offered inside a batch. The contract is published at https://fhir.haau3.com/OperationDefinition-reconcile-medications.html.
+	*
+	* `POST /v1/fhir/r4/$reconcile-medications`
+	*/
+	reconcileMedications(body, options) {
+		return this.operation({
+			method: "POST",
+			path: "/v1/fhir/r4/$reconcile-medications",
+			body
+		}, options);
+	}
+	/**
+	* Find endpoints
+	*
+	* Search `Endpoint` by managing organization; `connection-type`, `status` and `name` narrow a search but cannot stand alone.
+	*
+	* `GET /v1/fhir/r4/Endpoint`
+	*/
+	searchEndpoint(params, options) {
+		return this.operation({
+			method: "GET",
+			path: "/v1/fhir/r4/Endpoint",
+			query: params
+		}, options);
+	}
+	/**
+	* Find healthcare services
+	*
+	* Search `HealthcareService` by location, or by network beside a location. The directory's service records name a network and, for a few, a location; none names an organization, so `organization` is refused rather than answered with nothing.
+	*
+	* `GET /v1/fhir/r4/HealthcareService`
+	*/
+	searchHealthcareService(params, options) {
+		return this.operation({
+			method: "GET",
+			path: "/v1/fhir/r4/HealthcareService",
+			query: params
+		}, options);
+	}
+	/**
+	* Find a plan
+	*
+	* Search the Medicare Advantage and ACA Marketplace plans being served, by identifier, name, or the state or county a plan is sold in. A search needs at least one of `identifier`, a form of `name`, `coverage-area-state` or `coverage-area-county`; `type` and `sold-to` narrow a search but are not one. Every result is the whole plan, sorted by name and then id, and every page states the total. Follow the `next` link to continue.
+	*
+	* A plan sold in only part of a county matches the whole county. `GET /v1/fhir/r4/InsurancePlan/$counties?state=FL` lists a state's counties and their codes.
+	*
+	* Every other parameter is refused by name rather than ignored, so a search never quietly answers a different question than the one asked. `address-state` and `address-postalcode` are refused with a pointer to the coverage-area parameters, because in FHIR R4 they search a plan's contact address.
+	*
+	* Drug-only and dental-only plans are not served. An identifier search that finds one answers no plan and an `OperationOutcome` entry saying why.
+	*
+	* `GET /v1/fhir/r4/InsurancePlan`
+	*/
+	searchInsurancePlan(params, options) {
+		return this.operation({
+			method: "GET",
+			path: "/v1/fhir/r4/InsurancePlan",
+			query: params
+		}, options);
+	}
+	/**
+	* Find practice locations
+	*
+	* Search `Location` by managing organization or name; the address parameters and `status` narrow a search but cannot stand alone. A distance search (`near`) is refused because the directory does not apply it.
+	*
+	* `GET /v1/fhir/r4/Location`
+	*/
+	searchLocation(params, options) {
+		return this.operation({
+			method: "GET",
+			path: "/v1/fhir/r4/Location",
+			query: params
+		}, options);
+	}
+	/**
+	* Find organizations, payers and networks
+	*
+	* Search `Organization` by name, NPI, parent (`partof`) or type. `type=ntwk` lists the insurance networks the directory holds and `type=pay` its payers; any other type, `active` and the address parameters narrow a search but cannot stand alone.
+	*
+	* The directory records networks by the text of their type rather than a code. This service searches that text for `type=ntwk` and confirms every answer is a network; if the directory changes how it records them, the search answers 502 rather than serve something else.
+	*
+	* An NPI search can return a parent organization beside the practice, when the parent lists the NPI among several. `_revinclude` brings the roles, affiliations, locations and endpoints that point at each match, up to 100 per page.
+	*
+	* `GET /v1/fhir/r4/Organization`
+	*/
+	searchOrganization(params, options) {
+		return this.operation({
+			method: "GET",
+			path: "/v1/fhir/r4/Organization",
+			query: params
+		}, options);
+	}
+	/**
+	* Find the organizations in a network
+	*
+	* Search `OrganizationAffiliation`: which organizations take part in which networks. `network` lists a network's members; with `participating-organization` beside it, it asks whether the directory lists that organization in that network. The directory's network data is sparse, so an organization a network's records do not list is not shown to be out of network. For a network, the primary organization is the network itself.
+	*
+	* `GET /v1/fhir/r4/OrganizationAffiliation`
+	*/
+	searchOrganizationAffiliation(params, options) {
+		return this.operation({
+			method: "GET",
+			path: "/v1/fhir/r4/OrganizationAffiliation",
+			query: params
+		}, options);
+	}
+	/**
+	* Find a practitioner by NPI or name
+	*
+	* Search `Practitioner` by `identifier` to resolve an NPI you already hold, or by name to find someone. A search needs one or the other (or an `_id`): `address-city`, `address-state` and `active` narrow a search but cannot stand alone. Specialties are searched on `PractitionerRole`.
+	*
+	* Three identifier systems are accepted, `http://terminology.hl7.org/NamingSystem/npi`, `http://hl7.org/fhir/sid/us-npi` and `urn:oid:2.16.840.1.113883.4.6`, as well as a bare 10-digit value. All of them resolve the same provider. **Responses carry the directory's own system, `http://hl7.org/fhir/sid/us-npi`**, which may differ from the one you sent. Any other identifier system is refused by name: a system the directory does not index would answer with an empty result, which reads as 'no such provider'.
+	*
+	* One NPI per search. To resolve several, POST a batch `Bundle` with one entry each.
+	*
+	* `GET /v1/fhir/r4/Practitioner`
+	*/
+	searchPractitioner(params, options) {
+		return this.operation({
+			method: "GET",
+			path: "/v1/fhir/r4/Practitioner",
+			query: params
+		}, options);
+	}
+	/**
+	* Find practitioner roles
+	*
+	* Search `PractitionerRole`: the organizations, specialties, locations and networks practitioners are associated with. A search names a practitioner, an organization, a location or an endpoint; `specialty` (NUCC), `new-patient` and `active` narrow it.
+	*
+	* `network` and `new-patient-from-network` follow the directory's own rule: each needs a practitioner, organization, location or specialty beside it, and a search without one is refused before the directory is asked. A network search beside a practitioner or an organization answers in under a second; beside a specialty or a busy location the directory can take 10 to 15 seconds. The directory's network data is sparse, so a role a network's records do not list is not shown to be out of network.
+	*
+	* `identifier` is not offered because the directory does not carry identifiers on these resources.
+	*
+	* `GET /v1/fhir/r4/PractitionerRole`
+	*/
+	searchPractitionerRole(params, options) {
+		return this.operation({
+			method: "GET",
+			path: "/v1/fhir/r4/PractitionerRole",
+			query: params
+		}, options);
+	}
+	/**
+	* Search provider locations
+	*
+	* Returns the matching slots grouped by provider location: each item in `providerLocations` is one provider at one location, or a location with no provider, with its total slot count and soonest availability, paginated by provider location. Its opaque `key` drills down to its individual slots via `GET /v1/scheduling/slots?providerLocationKey=<key>`. Same filters as `/slots`. Requires a valid API key.
+	*
+	* `GET /v1/scheduling/provider-locations`
+	*/
+	searchProviderLocations(params, options) {
+		return this.operation({
+			method: "GET",
+			path: "/v1/scheduling/provider-locations",
+			query: params
+		}, options);
+	}
+	/**
+	* List or find a questionnaire
+	*
+	* With no parameters, this lists the questionnaires this service holds copies of. Those render the same way on every request, and that list is what you can rely on.
+	*
+	* Naming a canonical `url` reaches any questionnaire the source publishes, including ones this service holds no copy of. Those depend on the source being reachable, and when it cannot answer you get a `502`, `503` or `504` carrying an `OperationOutcome`, so a failure never arrives looking like an empty result.
+	*
+	* A canonical that is the address of a form published at its own address, under `https://smart-health-checkin.org/connectathon/Questionnaire/` or another place this service is set up to reach, is fetched from that address and served exactly as published, its entry's `fullUrl` the address it was fetched from. Any other canonical matches nothing.
+	*
+	* Two parameters are offered: `url` (the canonical, optionally as `{url}|{version}`) and `version`. Every other parameter, `status` included, is refused by name rather than ignored, so a search never quietly answers a different question than the one asked. Results are never paged: one page, with `total` set.
+	*
+	* Questionnaires are served exactly as their source publishes them. Each carries its own `copyright`, which must be kept with the form wherever it goes.
+	*
+	* `GET /v1/fhir/r4/Questionnaire`
+	*/
+	searchQuestionnaire(params, options) {
+		return this.operation({
+			method: "GET",
+			path: "/v1/fhir/r4/Questionnaire",
+			query: params
+		}, options);
+	}
+	/**
+	* Search appointment slots
+	*
+	* Returns provider availability slots matching the filters, with pagination. Requires a valid API key.
+	*
+	* `GET /v1/scheduling/slots`
+	*/
+	searchSlots(params, options) {
+		return this.operation({
+			method: "GET",
+			path: "/v1/scheduling/slots",
+			query: params
+		}, options);
+	}
+	/**
+	* Expand a value set
+	*
+	* FHIR `ValueSet/$expand`. Expands a value set canonical to its member codes, with an optional text filter and paging (`count=0` returns the total only).
+	*
+	* `GET /v1/fhir/r4/ValueSet/$expand`
+	*/
+	valueSetExpand(params, options) {
+		return this.operation({
+			method: "GET",
+			path: "/v1/fhir/r4/ValueSet/$expand",
+			query: params
+		}, options);
+	}
+	/**
+	* Expand a value set
+	*
+	* FHIR `ValueSet/$expand`. Expands a value set canonical to its member codes, with an optional text filter and paging (`count=0` returns the total only).
+	*
+	* `POST /v1/fhir/r4/ValueSet/$expand`
+	*/
+	valueSetExpandPost(body, options) {
+		return this.operation({
+			method: "POST",
+			path: "/v1/fhir/r4/ValueSet/$expand",
+			body
+		}, options);
+	}
+	/**
+	* Validate a code against a value set
+	*
+	* FHIR `ValueSet/$validate-code`. A code that is not in the set is a successful `200` with `result: false`, not an error. On POST, a `coding` or `codeableConcept` parameter may stand in for `system` + `code`; a codeableConcept validates if any of its codings is in the set — useful when an element carries a vendor-local coding alongside a standard one.
+	*
+	* `GET /v1/fhir/r4/ValueSet/$validate-code`
+	*/
+	valueSetValidateCode(params, options) {
+		return this.operation({
+			method: "GET",
+			path: "/v1/fhir/r4/ValueSet/$validate-code",
+			query: params
+		}, options);
+	}
+	/**
+	* Validate a code against a value set
+	*
+	* FHIR `ValueSet/$validate-code`. A code that is not in the set is a successful `200` with `result: false`, not an error. On POST, a `coding` or `codeableConcept` parameter may stand in for `system` + `code`; a codeableConcept validates if any of its codings is in the set — useful when an element carries a vendor-local coding alongside a standard one.
+	*
+	* `POST /v1/fhir/r4/ValueSet/$validate-code`
+	*/
+	valueSetValidateCodePost(body, options) {
+		return this.operation({
+			method: "POST",
+			path: "/v1/fhir/r4/ValueSet/$validate-code",
+			body
+		}, options);
+	}
+};
+//#endregion
+//#region src/client.ts
+/**
+* The haau3 platform API client.
+*
+* ```ts
+* import { Haau3 } from "@haau3/sdk";
+*
+* const haau3 = new Haau3(); // reads HAAU3_API_KEY
+* const plan = await haau3.readInsurancePlan("H2406-013-000");
+* ```
+*
+* Every operation of the API is a method named by its operationId. Server-side only: the
+* constructor refuses to run in a browser, where a key would be public.
+*/
+var Haau3 = class extends Operations {
+	constructor(options = {}) {
+		super(options);
+	}
+	/**
+	* Every page of a FHIR search, starting with the one you have, following each `next` link
+	* until there is none. A link to any host but the client's own `baseURL` is refused, so the key
+	* is never sent elsewhere.
+	*
+	* ```ts
+	* const first = await haau3.searchInsurancePlan({ "coverage-area-state": "NC" });
+	* for await (const page of haau3.pages(first)) {
+	*   for (const entry of page.entry ?? []) console.log(entry.resource?.id);
+	* }
+	* ```
+	*/
+	async *pages(first, options = {}) {
+		let page = first;
+		while (page) {
+			yield page;
+			const next = page.link?.find((link) => link.relation === "next")?.url;
+			if (!next) return;
+			const url = this.url(next);
+			page = await this.answer("GET", url, void 0, options, url.pathname);
+		}
+	}
+};
+//#endregion
+export { AuthError, Haau3, Haau3Error, NoAnswerError, RefusedError, VERSION };