@oystehr/sdk 4.3.3 → 4.3.4

package/dist/esm/resources/types/fhir.d.ts

@@ -1,6 +1,6 @@
 import type { Operation } from 'fast-json-patch';
-import type { Binary as BinaryR4B, Bundle as BundleR4B, BundleEntry as BundleEntryR4B, FhirResource as FhirResourceR4B, OperationOutcome as OperationOutcomeR4B } from 'fhir/r4b';
-import type { Binary as BinaryR5, Bundle as BundleR5, BundleEntry as BundleEntryR5, FhirResource as FhirResourceR5, OperationOutcome as OperationOutcomeR5 } from 'fhir/r5';
+import type { Binary as BinaryR4B, Bundle as BundleR4B, BundleEntry as BundleEntryR4B, Coding as CodingR4B, FhirResource as FhirResourceR4B, OperationOutcome as OperationOutcomeR4B, Resource as ResourceR4B } from 'fhir/r4b';
+import type { Binary as BinaryR5, Bundle as BundleR5, BundleEntry as BundleEntryR5, Coding as CodingR5, FhirResource as FhirResourceR5, OperationOutcome as OperationOutcomeR5, Resource as ResourceR5 } from 'fhir/r5';
 export type FhirResource = FhirResourceR4B | FhirResourceR5;
 export type FhirBundle<F extends FhirResource> = F extends FhirResourceR4B ? BundleR4B<F> : BundleR5<F>;
 export type EntrylessFhirBundle<F extends FhirResource> = F extends FhirResourceR4B ? Omit<BundleR4B<F>, 'entry'> : Omit<BundleR5<F>, 'entry'>;
@@ -28,6 +28,8 @@ export type TransactionBundle<F extends FhirResource> = EntrylessFhirBundle<F> &
 export type BundleEntry<F extends FhirResource> = F extends FhirResourceR4B ? BundleEntryR4B<F> : BundleEntryR5<F>;
 export type Binary<F extends FhirResource> = F extends FhirResourceR4B ? BinaryR4B : BinaryR5;
 export type OperationOutcome = OperationOutcomeR4B | OperationOutcomeR5;
+export type Coding = CodingR4B | CodingR5;
+export type Resource = ResourceR4B | ResourceR5;
 export type SearchParam = {
     name: string;
     value: string | number;
@@ -89,6 +91,14 @@ export interface BatchInputPostRequest<F extends FhirResource> extends BatchInpu
     resource: F;
     fullUrl?: string;
 }
+/**
+ * A batch POST to a `_search` endpoint (e.g. `Patient/_search`). Search parameters
+ * may be appended to the URL as query parameters. Unlike a create POST there is no
+ * resource body.
+ */
+export interface BatchInputSearchPostRequest extends BatchInputBaseRequest {
+    method: 'POST';
+}
 export interface BatchInputBinaryPatchRequest<F extends FhirResource> extends BatchInputBaseRequest {
     method: 'PATCH';
     ifMatch?: string;
@@ -100,7 +110,7 @@ export interface BatchInputJSONPatchRequest extends BatchInputBaseRequest {
     operations: Operation[];
 }
 export type BatchInputPatchRequest<F extends FhirResource> = BatchInputBinaryPatchRequest<F> | BatchInputJSONPatchRequest;
-export type BatchInputRequest<F extends FhirResource> = BatchInputGetRequest | BatchInputHeadRequest | BatchInputPutRequest<F> | BatchInputPatchRequest<F> | BatchInputPostRequest<F> | BatchInputDeleteRequest;
+export type BatchInputRequest<F extends FhirResource> = BatchInputGetRequest | BatchInputHeadRequest | BatchInputPutRequest<F> | BatchInputPatchRequest<F> | BatchInputPostRequest<F> | BatchInputSearchPostRequest | BatchInputDeleteRequest;
 export interface BatchInput<F extends FhirResource> {
     requests: BatchInputRequest<F>[];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oystehr/sdk",
-  "version": "4.3.3",
+  "version": "4.3.4",
   "description": "Oystehr SDK",
   "scripts": {
     "lint": "eslint .",

package/src/config.ts

@@ -1,3 +1,5 @@
+import type { Coding } from './resources/types/fhir';
+
 /**
  * Configuration for the Oystehr SDK client
  */
@@ -62,6 +64,20 @@ export interface OystehrConfig {
      */
     retryOn?: number[];
   };
+  /**
+   * Optional workspace tag configuration. When set, all FHIR searches will be
+   * filtered to only return resources with this tag, and all FHIR mutations
+   * (create, update, patch) will have this tag injected automatically.
+   * Mutually exclusive with `ignoreTags`.
+   */
+  workspaceTag?: Coding;
+  /**
+   * Optional list of tags to ignore. When set, all FHIR searches will be
+   * filtered to exclude resources matching any of these tags, and mutations
+   * will throw an error if the resource carries any of these tags.
+   * Mutually exclusive with `workspaceTag`.
+   */
+  ignoreTags?: Coding[];
 }
 
 let globalConfig: OystehrConfig;

package/src/resources/classes/fhir-ext.ts

@@ -1,3 +1,4 @@
+import type { Operation } from 'fast-json-patch';
 import { Address as AddressR4B, HumanName as HumanNameR4B } from 'fhir/r4b';
 import { Address as AddressR5, HumanName as HumanNameR5 } from 'fhir/r5';
 import {
@@ -7,6 +8,7 @@ import {
   Binary,
   Bundle,
   BundleEntry,
+  Coding,
   FhirBundle,
   FhirCreateParams,
   FhirDeleteParams,
@@ -19,9 +21,13 @@ import {
   FhirSearchParams,
   FhirUpdateParams,
   OperationOutcome,
+  Resource,
+  SearchParam,
   TransactionBundle,
 } from '../..';
 import { addParamsToSearch, FhirFetcherResponse, OystehrClientRequest, SDKResource } from '../../client/client';
+import { OystehrConfig } from '../../config';
+import { OystehrFHIRError, OystehrSdkError } from '../../errors';
 
 // Code adapted from https://github.com/sindresorhus/uint8array-extras
 const MAX_BLOCK_SIZE = 65_535;
@@ -37,6 +43,209 @@ function stringToBase64(input: string): string {
   return base64;
 }
 
+function base64ToString(input: string): string {
+  const binaryString = globalThis.atob(input);
+  const bytes = new Uint8Array(binaryString.length);
+  for (let i = 0; i < binaryString.length; i++) {
+    bytes[i] = binaryString.charCodeAt(i);
+  }
+  return new globalThis.TextDecoder().decode(bytes);
+}
+
+// ─── Tag-mode helpers ────────────────────────────────────────────────────────
+
+/** Converts a Coding to the FHIR _tag parameter value format "system|code". */
+function codingToTagValue(coding: Coding): string {
+  return coding.system ? `${coding.system}|${coding.code ?? ''}` : coding.code ?? '';
+}
+
+/** Returns true if two Codings match on system (treating absent as empty string) and code. */
+function codingMatches(a: Coding, b: Coding): boolean {
+  return (a.system ?? '') === (b.system ?? '') && (a.code ?? '') === (b.code ?? '');
+}
+
+/**
+ * Appends _tag (tag-workspace mode) or _tag:not (ignore-tags mode) search
+ * params to an existing SearchParam array and returns the new array.
+ */
+function applyTagSearchParams(config: OystehrConfig, params: SearchParam[] | undefined): SearchParam[] {
+  const out: SearchParam[] = params ? [...params] : [];
+  if (config.workspaceTag) {
+    out.push({ name: '_tag', value: codingToTagValue(config.workspaceTag) });
+  } else if (config.ignoreTags?.length) {
+    for (const tag of config.ignoreTags) {
+      out.push({ name: '_tag:not', value: codingToTagValue(tag) });
+    }
+  }
+  return out;
+}
+
+/**
+ * In ignore-tags mode: throws OystehrSdkError if the resource carries any ignored tag.
+ * In tag-workspace mode: injects the workspace tag into resource.meta.tag if not already present.
+ * Returns the (possibly cloned) resource.
+ */
+function applyTagToResource<T extends FhirResource>(config: OystehrConfig, resource: T): T {
+  const resourceLike = resource as unknown as Resource;
+
+  if (config.ignoreTags?.length) {
+    const resourceTags = (resourceLike.meta?.tag ?? []) as Coding[];
+    for (const ignored of config.ignoreTags) {
+      if (resourceTags.some((t) => codingMatches(t, ignored))) {
+        throw new OystehrSdkError({
+          message: `Resource has an ignored tag (system: "${ignored.system ?? ''}", code: "${
+            ignored.code ?? ''
+          }") and cannot be mutated in ignoreTags mode`,
+          code: 400,
+        });
+      }
+    }
+    return resource;
+  }
+
+  if (config.workspaceTag) {
+    const tag = config.workspaceTag;
+    const existingTags = (resourceLike.meta?.tag ?? []) as Coding[];
+    if (!existingTags.some((t) => codingMatches(t, tag))) {
+      return {
+        ...resource,
+        meta: {
+          ...resourceLike.meta,
+          tag: [...existingTags, tag],
+        },
+      } as T;
+    }
+  }
+
+  return resource;
+}
+
+/**
+ * In ignore-tags mode: throws OystehrSdkError if any operation value resembles an ignored tag.
+ * In tag-workspace mode: guards against removal or loss of the workspace tag:
+ *   - add/replace of the tag array: ensures workspace tag is present in the value
+ *   - add/replace of meta: ensures workspace tag is present in meta.tag
+ *   - remove of /meta/tag or /meta: keeps the remove and appends an operation to restore the workspace tag
+ *   - add of a single tag (path ends in /-): left unchanged (workspace tag already on the resource)
+ */
+function applyTagToPatchOperations(config: OystehrConfig, operations: Operation[]): Operation[] {
+  if (config.ignoreTags?.length) {
+    for (const op of operations) {
+      if (op.op === 'add' || op.op === 'replace' || op.op === 'test') {
+        const opValue: unknown = op.value;
+        if (opValue !== null && opValue !== undefined && typeof opValue === 'object') {
+          const v = opValue as Coding;
+          if (v.code !== undefined) {
+            for (const ignored of config.ignoreTags) {
+              if (codingMatches(v, ignored)) {
+                throw new OystehrSdkError({
+                  message: `Patch operation contains an ignored tag (system: "${ignored.system ?? ''}", code: "${
+                    ignored.code ?? ''
+                  }") and cannot be applied in ignoreTags mode`,
+                  code: 400,
+                });
+              }
+            }
+          }
+        }
+      }
+    }
+    return operations;
+  }
+
+  if (config.workspaceTag) {
+    const tag = config.workspaceTag;
+    return operations.reduce<Operation[]>((result, op) => {
+      // remove /meta/tag — restore workspace tag afterwards
+      if (op.op === 'remove' && op.path === '/meta/tag') {
+        result.push(op);
+        result.push({ op: 'add' as const, path: '/meta/tag', value: [tag] });
+        return result;
+      }
+
+      // remove /meta — restore workspace tag afterwards
+      if (op.op === 'remove' && op.path === '/meta') {
+        result.push(op);
+        result.push({ op: 'add' as const, path: '/meta', value: { tag: [tag] } });
+        return result;
+      }
+
+      // add/replace the entire tag array — ensure workspace tag is present
+      if ((op.op === 'add' || op.op === 'replace') && op.path === '/meta/tag') {
+        const tags: Coding[] = Array.isArray(op.value) ? (op.value as Coding[]) : [];
+        if (!tags.some((t) => codingMatches(t, tag))) {
+          result.push({ ...op, value: [...tags, tag] });
+        } else {
+          result.push(op);
+        }
+        return result;
+      }
+
+      // add/replace the entire meta object — ensure workspace tag is present in meta.tag
+      if ((op.op === 'add' || op.op === 'replace') && op.path === '/meta') {
+        const metaValue: { tag?: Coding[] } =
+          op.value != null && typeof op.value === 'object' ? (op.value as { tag?: Coding[] }) : {};
+        const tags = metaValue.tag ?? [];
+        if (!tags.some((t) => codingMatches(t, tag))) {
+          result.push({ ...op, value: { ...metaValue, tag: [...tags, tag] } });
+        } else {
+          result.push(op);
+        }
+        return result;
+      }
+
+      // All other operations (including add /meta/tag/- for individual tags) pass through unchanged.
+      // Workspace tag is assumed already present on the resource from create/update.
+      result.push(op);
+      return result;
+    }, []);
+  }
+
+  return operations;
+}
+
+/**
+ * Throws OystehrFHIRError (404) if the retrieved resource violates the tag configuration:
+ *   - workspaceTag mode: resource must carry the workspace tag
+ *   - ignoreTags mode: resource must not carry any ignored tag
+ */
+function assertRetrievedResource(config: OystehrConfig, resource: FhirResource): void {
+  const resourceLike = resource as unknown as Resource;
+  const resourceTags = (resourceLike.meta?.tag ?? []) as Coding[];
+
+  if (config.workspaceTag) {
+    const tag = config.workspaceTag;
+    if (!resourceTags.some((t) => codingMatches(t, tag))) {
+      throw new OystehrFHIRError({
+        error: {
+          resourceType: 'OperationOutcome',
+          id: 'not-found',
+          issue: [{ severity: 'error', code: 'not-found', details: { text: 'Not found' } }],
+        },
+        code: 404,
+      });
+    }
+    return;
+  }
+
+  if (config.ignoreTags?.length) {
+    for (const ignored of config.ignoreTags) {
+      if (resourceTags.some((t) => codingMatches(t, ignored))) {
+        throw new OystehrFHIRError({
+          error: {
+            resourceType: 'OperationOutcome',
+            id: 'not-found',
+            issue: [{ severity: 'error', code: 'not-found', details: { text: 'Not found' } }],
+          },
+          code: 404,
+        });
+      }
+    }
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+
 /**
  * Optional parameter that can be passed to the client methods. It allows
  * overriding the access token or project ID, and setting various headers,
@@ -64,10 +273,11 @@ export async function search<T extends FhirResource>(
   params: FhirSearchParams<T>,
   request?: OystehrClientRequest
 ): Promise<FhirFetcherResponse<Bundle<T>>> {
-  const { resourceType, params: searchParams } = params;
+  const { resourceType } = params;
+  const taggedParams = applyTagSearchParams(this.config, params.params);
   let paramMap: Record<string, (string | number)[]> | undefined;
-  if (searchParams) {
-    paramMap = Object.entries(searchParams).reduce((acc, [_, param]) => {
+  if (taggedParams.length) {
+    paramMap = taggedParams.reduce((acc, param) => {
       if (!acc[param.name]) {
         acc[param.name] = [];
       }
@@ -96,8 +306,9 @@ export async function create<T extends FhirResource>(
   params: FhirCreateParams<T>,
   request?: OystehrClientRequest
 ): Promise<FhirFetcherResponse<FhirResourceReturnValue<T>>> {
-  const { resourceType } = params;
-  return this.fhirRequest(`/${resourceType}`, 'POST')(params as unknown as Record<string, unknown>, request);
+  const tagged = applyTagToResource(this.config, params);
+  const { resourceType } = tagged;
+  return this.fhirRequest(`/${resourceType}`, 'POST')(tagged as unknown as Record<string, unknown>, request);
 }
 
 export async function get<T extends FhirResource>(
@@ -105,7 +316,9 @@ export async function get<T extends FhirResource>(
   { resourceType, id }: FhirGetParams<T>,
   request?: OystehrClientRequest
 ): Promise<FhirFetcherResponse<FhirResourceReturnValue<T>>> {
-  return this.fhirRequest<FhirResourceReturnValue<T>>(`/${resourceType}/${id}`, 'GET')({}, request);
+  const result = await this.fhirRequest<FhirResourceReturnValue<T>>(`/${resourceType}/${id}`, 'GET')({}, request);
+  assertRetrievedResource(this.config, result);
+  return result;
 }
 
 export async function update<T extends FhirResource>(
@@ -113,8 +326,9 @@ export async function update<T extends FhirResource>(
   params: FhirUpdateParams<T>,
   request?: OystehrFHIRUpdateClientRequest
 ): Promise<FhirFetcherResponse<FhirResourceReturnValue<T>>> {
-  const { id, resourceType } = params;
-  return this.fhirRequest(`/${resourceType}/${id}`, 'PUT')(params as unknown as Record<string, unknown>, {
+  const tagged = applyTagToResource(this.config, params);
+  const { id, resourceType } = tagged;
+  return this.fhirRequest(`/${resourceType}/${id}`, 'PUT')(tagged as unknown as Record<string, unknown>, {
     ...request,
     ifMatch: request?.optimisticLockingVersionId ? `W/"${request.optimisticLockingVersionId}"` : undefined,
   });
@@ -125,7 +339,8 @@ export async function patch<T extends FhirResource>(
   { resourceType, id, operations }: FhirPatchParams<T>,
   request?: OystehrFHIRUpdateClientRequest
 ): Promise<FhirFetcherResponse<FhirResourceReturnValue<T>>> {
-  return this.fhirRequest(`/${resourceType}/${id}`, 'PATCH')(operations, {
+  const taggedOperations = applyTagToPatchOperations(this.config, operations);
+  return this.fhirRequest(`/${resourceType}/${id}`, 'PATCH')(taggedOperations, {
     ...request,
     contentType: 'application/json-patch+json',
     ifMatch: request?.optimisticLockingVersionId ? `W/"${request.optimisticLockingVersionId}"` : undefined,
@@ -180,10 +395,50 @@ export async function history<T extends FhirResource>(
   return this.fhirRequest(`/${resourceType}/${id}/_history?_total=accurate`, 'GET')({}, request);
 }
 
+/**
+ * Returns true when a batch GET/HEAD URL is a search (e.g. "Patient" or "Patient?name=foo")
+ * rather than a direct retrieval (e.g. "Patient/abc-123").
+ * A retrieval URL has a path segment after the resource type that is not a FHIR operation
+ * (operations start with "_", e.g. "_search" or "_history").
+ */
+function isBatchSearchUrl(url: string): boolean {
+  const path = url.split('?')[0];
+  const segments = path.split('/').filter(Boolean);
+  // Only one segment → bare resource type, always a search
+  if (segments.length <= 1) return true;
+  // Two or more segments: second segment is an ID if it doesn't start with '_'
+  return segments[1].startsWith('_');
+}
+
+/** Returns true when a batch POST URL targets a `_search` endpoint (e.g. "Patient/_search"). */
+function isBatchSearchPostUrl(url: string): boolean {
+  return url.split('?')[0].endsWith('/_search');
+}
+
 function batchInputRequestToBundleEntryItem<T extends FhirResource>(
-  request: BatchInputRequest<T>
+  request: BatchInputRequest<T>,
+  config: OystehrConfig
 ): BundleEntry<T | Binary<T>> {
-  const { method, url } = request;
+  const { method } = request;
+  let url = request.url;
+
+  // Inject tag search params into search request URLs before URL encoding.
+  // GET/HEAD: only for search URLs (not retrievals like Patient/<id>).
+  // POST: only for _search endpoints (not creates).
+  if (
+    ((method === 'GET' || method === 'HEAD') && isBatchSearchUrl(url)) ||
+    (method === 'POST' && isBatchSearchPostUrl(url))
+  ) {
+    if (config.workspaceTag) {
+      url += (url.includes('?') ? '&' : '?') + `_tag=${codingToTagValue(config.workspaceTag)}`;
+    }
+    if (config.ignoreTags?.length) {
+      for (const tag of config.ignoreTags) {
+        url += (url.includes('?') ? '&' : '?') + `_tag:not=${codingToTagValue(tag)}`;
+      }
+    }
+  }
+
   const baseRequest = {
     request: {
       method,
@@ -222,7 +477,7 @@ function batchInputRequestToBundleEntryItem<T extends FhirResource>(
 
   // PUT updates require a full resource
   if (method === 'PUT') {
-    const { resource } = request;
+    const resource = applyTagToResource(config, request.resource);
     return {
       request: {
         ...baseRequest.request,
@@ -235,15 +490,24 @@ function batchInputRequestToBundleEntryItem<T extends FhirResource>(
   // PATCH can be Binary resource or JSON patch
   if (method === 'PATCH') {
     if ('resource' in request) {
+      // Binary patch — decode operations, apply tag transforms, re-encode
+      let patchResource = request.resource;
+      const binaryData = patchResource.data;
+      if (binaryData) {
+        const operations = JSON.parse(base64ToString(binaryData)) as Operation[];
+        const taggedOperations = applyTagToPatchOperations(config, operations);
+        patchResource = { ...patchResource, data: stringToBase64(JSON.stringify(taggedOperations)) } as Binary<T>;
+      }
       return {
         request: {
           ...baseRequest.request,
           ifMatch: request.ifMatch,
         },
-        resource: request.resource,
+        resource: patchResource,
       } as BundleEntry<Binary<T>>;
     }
-    const data = stringToBase64(JSON.stringify(request.operations));
+    const operations = applyTagToPatchOperations(config, request.operations);
+    const data = stringToBase64(JSON.stringify(operations));
     return {
       ...baseRequest,
       resource: {
@@ -254,9 +518,15 @@ function batchInputRequestToBundleEntryItem<T extends FhirResource>(
     } as BundleEntry<Binary<T>>;
   }
 
+  // POST _search — no resource body; tag params were already injected into the URL above
+  if (method === 'POST' && isBatchSearchPostUrl(url)) {
+    return baseRequest as BundleEntry<T>;
+  }
+
   // POST creates require a full resource
-  if (method === 'POST') {
-    const { resource, fullUrl } = request;
+  if (method === 'POST' && 'resource' in request) {
+    const resource = applyTagToResource(config, request.resource);
+    const { fullUrl } = request;
     return {
       ...baseRequest,
       resource: resource as T,
@@ -284,13 +554,35 @@ export async function batch<BundleContentType extends FhirResource>(
     {
       resourceType: 'Bundle',
       type: 'batch',
-      entry: input.requests.map(batchInputRequestToBundleEntryItem),
+      entry: input.requests.map((req) => batchInputRequestToBundleEntryItem(req, this.config)),
     },
     request
   );
+  // Validate each GET/HEAD retrieval entry against the tag config.
+  // Violations are replaced with a synthetic 404 OperationOutcome entry; batch entries are independent.
+  const rawEntries = resp.entry as Array<BundleEntry<BundleContentType>> | undefined;
+  const processedEntries: Array<BundleEntry<BundleContentType>> | undefined =
+    this.config.workspaceTag || this.config.ignoreTags?.length
+      ? rawEntries?.map((entry, i) => {
+          const req = input.requests[i];
+          if (!req || !entry?.resource) return entry;
+          if ((req.method === 'GET' || req.method === 'HEAD') && !isBatchSearchUrl(req.url)) {
+            try {
+              assertRetrievedResource(this.config, entry.resource);
+            } catch (err) {
+              if (!(err instanceof OystehrFHIRError)) throw err;
+              return {
+                request: entry.request,
+                response: { status: '404', outcome: err.cause },
+              } as unknown as BundleEntry<BundleContentType>;
+            }
+          }
+          return entry;
+        })
+      : rawEntries;
   const bundle: BatchBundle<BundleContentType> = {
     ...resp,
-    entry: resp.entry as Array<BundleEntry<BundleContentType>> | undefined,
+    entry: processedEntries,
     unbundle: function (this: { entry?: Array<BundleEntry<BundleContentType>> | undefined }) {
       return (
         this.entry
@@ -317,10 +609,21 @@ export async function transaction<BundleContentType extends FhirResource>(
     {
       resourceType: 'Bundle',
       type: 'transaction',
-      entry: input.requests.map(batchInputRequestToBundleEntryItem),
+      entry: input.requests.map((req) => batchInputRequestToBundleEntryItem(req, this.config)),
     },
     request
   );
+  // Validate each GET/HEAD retrieval entry against the tag config.
+  // A violation throws OystehrFHIRError(404) — transactions are all-or-nothing.
+  if (this.config.workspaceTag || this.config.ignoreTags?.length) {
+    (resp.entry as Array<BundleEntry<BundleContentType>> | undefined)?.forEach((entry, i) => {
+      const req = input.requests[i];
+      if (!req || !entry?.resource) return;
+      if ((req.method === 'GET' || req.method === 'HEAD') && !isBatchSearchUrl(req.url)) {
+        assertRetrievedResource(this.config, entry.resource);
+      }
+    });
+  }
   const bundle: TransactionBundle<BundleContentType> = {
     ...resp,
     entry: resp.entry as Array<BundleEntry<BundleContentType>> | undefined,

package/src/resources/classes/index.ts

@@ -1,6 +1,7 @@
 // AUTOGENERATED -- DO NOT EDIT
 
 import { OystehrConfig } from '../../config';
+import { OystehrSdkError } from '../../errors';
 import { Application } from './application';
 import { Charge } from './charge';
 import { Conversation } from './conversation';
@@ -51,6 +52,12 @@ export class Oystehr {
   readonly rcm: Rcm;
   readonly fhir: Fhir;
   constructor(config: OystehrConfig) {
+    if (config.workspaceTag && config.ignoreTags) {
+      throw new OystehrSdkError({
+        message: 'workspaceTag and ignoreTags are mutually exclusive and cannot both be set in config',
+        code: 400,
+      });
+    }
     this.config = config;
     this.config.services ??= {};
     this.config.services['projectApiUrl'] ??= config.projectApiUrl;

package/src/resources/types/RcmListPayersParams.ts

@@ -4,4 +4,8 @@ export interface RcmListPayersParams {
   name?: string;
   identifier?: string;
   includeInactive?: boolean;
+  cursor?: string;
+  limit?: number;
+  sort?: 'id' | 'name';
+  sortOrder?: 'asc' | 'desc';
 }

package/src/resources/types/RcmListPayersResponse.ts

@@ -4,4 +4,12 @@ import { Organization } from 'fhir/r4b';
 /**
  * List of payers matching the search criteria.
  */
-export type RcmListPayersResponse = Organization[];
+export interface RcmListPayersResponse {
+  data: Organization[];
+  metadata: {
+    /**
+     * Cursor to fetch the next page of results. Null if there are no further pages.
+     */
+    nextCursor: string | null;
+  };
+}

package/src/resources/types/fhir.ts

@@ -3,15 +3,19 @@ import type {
   Binary as BinaryR4B,
   Bundle as BundleR4B,
   BundleEntry as BundleEntryR4B,
+  Coding as CodingR4B,
   FhirResource as FhirResourceR4B,
   OperationOutcome as OperationOutcomeR4B,
+  Resource as ResourceR4B,
 } from 'fhir/r4b';
 import type {
   Binary as BinaryR5,
   Bundle as BundleR5,
   BundleEntry as BundleEntryR5,
+  Coding as CodingR5,
   FhirResource as FhirResourceR5,
   OperationOutcome as OperationOutcomeR5,
+  Resource as ResourceR5,
 } from 'fhir/r5';
 
 export type FhirResource = FhirResourceR4B | FhirResourceR5;
@@ -46,6 +50,8 @@ export type TransactionBundle<F extends FhirResource> = EntrylessFhirBundle<F> &
 export type BundleEntry<F extends FhirResource> = F extends FhirResourceR4B ? BundleEntryR4B<F> : BundleEntryR5<F>;
 export type Binary<F extends FhirResource> = F extends FhirResourceR4B ? BinaryR4B : BinaryR5;
 export type OperationOutcome = OperationOutcomeR4B | OperationOutcomeR5;
+export type Coding = CodingR4B | CodingR5;
+export type Resource = ResourceR4B | ResourceR5;
 
 export type SearchParam = { name: string; value: string | number };
 
@@ -119,6 +125,15 @@ export interface BatchInputPostRequest<F extends FhirResource> extends BatchInpu
   fullUrl?: string;
 }
 
+/**
+ * A batch POST to a `_search` endpoint (e.g. `Patient/_search`). Search parameters
+ * may be appended to the URL as query parameters. Unlike a create POST there is no
+ * resource body.
+ */
+export interface BatchInputSearchPostRequest extends BatchInputBaseRequest {
+  method: 'POST';
+}
+
 export interface BatchInputBinaryPatchRequest<F extends FhirResource> extends BatchInputBaseRequest {
   method: 'PATCH';
   ifMatch?: string;
@@ -141,6 +156,7 @@ export type BatchInputRequest<F extends FhirResource> =
   | BatchInputPutRequest<F>
   | BatchInputPatchRequest<F>
   | BatchInputPostRequest<F>
+  | BatchInputSearchPostRequest
   | BatchInputDeleteRequest;
 
 export interface BatchInput<F extends FhirResource> {