@oystehr/sdk 4.3.2 → 4.3.4

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';
@@ -45,12 +46,18 @@ export class Oystehr {
   readonly fax: Fax;
   readonly lab: Lab;
   readonly erx: Erx;
-  readonly rcm: Rcm;
   readonly terminology: Terminology;
   readonly zambda: Zambda;
   readonly zambdaLogStream: ZambdaLogStream;
+  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;
@@ -73,10 +80,10 @@ export class Oystehr {
     this.fax = new Fax(config);
     this.lab = new Lab(config);
     this.erx = new Erx(config);
-    this.rcm = new Rcm(config);
     this.terminology = new Terminology(config);
     this.zambda = new Zambda(config);
     this.zambdaLogStream = new ZambdaLogStream(config);
+    this.rcm = new Rcm(config);
     this.fhir = new Fhir(config);
   }
 }

package/src/resources/classes/rcm.ts

@@ -4,6 +4,10 @@ import {
   OystehrClientRequest,
   RcmEligibilityCheckParams,
   RcmEligibilityCheckResponse,
+  RcmGetPayerParams,
+  RcmGetPayerResponse,
+  RcmListPayersParams,
+  RcmListPayersResponse,
   RcmSetClaimStatusParams,
   RcmSetClaimStatusResponse,
   RcmSubmitClaimParams,
@@ -58,4 +62,39 @@ export class Rcm extends SDKResource {
   setClaimStatus(params: RcmSetClaimStatusParams, request?: OystehrClientRequest): Promise<RcmSetClaimStatusResponse> {
     return this.request('/claim/{claimId}/status', 'post', this.#baseUrlThunk.bind(this))(params, request);
   }
+  /**
+   * Search for payers by name or identifier.
+   *
+   * Access Policy Action: `RCM:SearchPayer`
+   * Access Policy Resource: `RCM:Payer`
+   */
+  listPayers(params: RcmListPayersParams, request?: OystehrClientRequest): Promise<RcmListPayersResponse>;
+  /**
+   * Search for payers by name or identifier.
+   *
+   * Access Policy Action: `RCM:SearchPayer`
+   * Access Policy Resource: `RCM:Payer`
+   */
+  listPayers(request?: OystehrClientRequest): Promise<RcmListPayersResponse>;
+  /**
+   * Search for payers by name or identifier.
+   *
+   * Access Policy Action: `RCM:SearchPayer`
+   * Access Policy Resource: `RCM:Payer`
+   */
+  listPayers(
+    params?: RcmListPayersParams | OystehrClientRequest,
+    request?: OystehrClientRequest
+  ): Promise<RcmListPayersResponse> {
+    return this.request('/payer', 'get', this.#baseUrlThunk.bind(this))(params, request);
+  }
+  /**
+   * Retrieve a payer by its ID.
+   *
+   * Access Policy Action: `RCM:GetPayer`
+   * Access Policy Resource: `RCM:Payer`
+   */
+  getPayer(params: RcmGetPayerParams, request?: OystehrClientRequest): Promise<RcmGetPayerResponse> {
+    return this.request('/payer/{id}', 'get', this.#baseUrlThunk.bind(this))(params, request);
+  }
 }

package/src/resources/classes/user.ts

@@ -2,6 +2,7 @@
 
 import {
   OystehrClientRequest,
+  UserChangePasswordParams,
   UserDeleteParams,
   UserGetParams,
   UserGetResponse,
@@ -79,6 +80,15 @@ export class User extends SDKResource {
   resetPasswordLink(params: UserResetPasswordLinkParams, request?: OystehrClientRequest): Promise<void> {
     return this.request('/user/{id}/reset-password-link', 'post', this.#baseUrlThunk.bind(this))(params, request);
   }
+  /**
+   * Automatically changes the password for the User with the provided ID. [Users](https://docs.oystehr.com/oystehr/services/app/users/) are the people who log into the [Applications](https://docs.oystehr.com/oystehr/services/app/applications/) you configure for securing the apps you build on top of Oystehr.
+   *
+   * Access Policy Action: `App:ChangeUserPassword`
+   * Access Policy Resource: `App:User`
+   */
+  changePassword(params: UserChangePasswordParams, request?: OystehrClientRequest): Promise<void> {
+    return this.request('/user/{id}/change-password', 'post', this.#baseUrlThunk.bind(this))(params, request);
+  }
   /**
    * Invite a User to the Project. [Users](https://docs.oystehr.com/oystehr/services/app/users/) are the people who log into the [Applications](https://docs.oystehr.com/oystehr/services/app/applications/) you configure for securing the apps you build on top of Oystehr.
    *

package/src/resources/types/ErxGetMedicationHistoryParams.ts

@@ -0,0 +1,5 @@
+// AUTOGENERATED -- DO NOT EDIT
+
+export interface ErxGetMedicationHistoryParams {
+  patientId: string;
+}

package/src/resources/types/ErxGetMedicationHistoryResponse.ts

@@ -0,0 +1,45 @@
+// AUTOGENERATED -- DO NOT EDIT
+
+/**
+ * Success
+ */
+export type ErxGetMedicationHistoryResponse = {
+  /**
+   * Unique identifier for the medication history item.
+   */
+  id: number;
+  /**
+   * The Medi-Span identifier for the medication.
+   */
+  medicationId: number;
+  /**
+   * National Drug Code (NDC) identifier of medication.
+   */
+  ndc: string | null;
+  /**
+   * RxNorm Concept Unique (RxCUI) identifier of medication.
+   */
+  rxcui: number | null;
+  /**
+   * Human readable name of medication.
+   */
+  name: string;
+  route: string | null;
+  doseForm: string | null;
+  strength: string | null;
+  dispenseUnit: string | null;
+  isBrandName: boolean;
+  genericName: string | null;
+  isOtc: boolean;
+  refills: string;
+  daysSupply: number | null;
+  quantity: number;
+  classification: string | null;
+  schedule: number | null;
+  directions: string | null;
+  substitutionsAllowed: boolean;
+  writtenDate: string;
+  effectiveDate: string | null;
+  lastFillDate: string | null;
+  expirationDate: string | null;
+}[];

package/src/resources/types/ErxGetMedicationResponse.ts

@@ -9,7 +9,7 @@ export interface ErxGetMedicationResponse {
    */
   id: number;
   /**
-   * RxNorm Concept Unique (RxCUI) identifier of medication.
+   * National Drug Code (NDC) identifier of medication.
    */
   ndc?: string | null;
   /**

package/src/resources/types/RcmGetPayerParams.ts

@@ -0,0 +1,5 @@
+// AUTOGENERATED -- DO NOT EDIT
+
+export interface RcmGetPayerParams {
+  id: string;
+}

package/src/resources/types/RcmGetPayerResponse.ts

@@ -0,0 +1,7 @@
+// AUTOGENERATED -- DO NOT EDIT
+
+import { Organization } from 'fhir/r4b';
+/**
+ * A valid FHIR Organization object corresponding to the payer.
+ */
+export type RcmGetPayerResponse = Organization;

package/src/resources/types/RcmListPayersParams.ts

@@ -0,0 +1,11 @@
+// AUTOGENERATED -- DO NOT EDIT
+
+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

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