@aws-sdk/client-healthlake 3.873.0 → 3.878.0

package/README.md

@@ -6,8 +6,9 @@
 
 AWS SDK for JavaScript HealthLake Client for Node.js, Browser and React Native.
 
-<p>AWS HealthLake is a HIPAA eligibile service that allows customers to store,
-transform, query, and analyze their FHIR-formatted data in a consistent fashion in the cloud.</p>
+<p>This is the <i>AWS HealthLake API Reference</i>. For an introduction to
+the service, see <a href="https://docs.aws.amazon.com/healthlake/latest/devguide/what-is.html">What is AWS HealthLake?</a> in the <i>AWS HealthLake Developer
+Guide</i>.</p>
 
 ## Installing
 

package/dist-cjs/index.js

@@ -52,10 +52,19 @@ __export(index_exports, {
   ThrottlingException: () => ThrottlingException,
   UntagResourceCommand: () => UntagResourceCommand,
   ValidationException: () => ValidationException,
+  ValidationLevel: () => ValidationLevel,
   __Client: () => import_smithy_client.Client,
   paginateListFHIRDatastores: () => paginateListFHIRDatastores,
   paginateListFHIRExportJobs: () => paginateListFHIRExportJobs,
-  paginateListFHIRImportJobs: () => paginateListFHIRImportJobs
+  paginateListFHIRImportJobs: () => paginateListFHIRImportJobs,
+  waitForFHIRDatastoreActive: () => waitForFHIRDatastoreActive,
+  waitForFHIRDatastoreDeleted: () => waitForFHIRDatastoreDeleted,
+  waitForFHIRExportJobCompleted: () => waitForFHIRExportJobCompleted,
+  waitForFHIRImportJobCompleted: () => waitForFHIRImportJobCompleted,
+  waitUntilFHIRDatastoreActive: () => waitUntilFHIRDatastoreActive,
+  waitUntilFHIRDatastoreDeleted: () => waitUntilFHIRDatastoreDeleted,
+  waitUntilFHIRExportJobCompleted: () => waitUntilFHIRExportJobCompleted,
+  waitUntilFHIRImportJobCompleted: () => waitUntilFHIRImportJobCompleted
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -402,6 +411,11 @@ var InputDataConfig;
     return visitor._(value.$unknown[0], value.$unknown[1]);
   }, "visit");
 })(InputDataConfig || (InputDataConfig = {}));
+var ValidationLevel = {
+  MINIMAL: "minimal",
+  STRICT: "strict",
+  STRUCTURE_ONLY: "structure-only"
+};
 
 // src/protocols/Aws_json1_0.ts
 var se_CreateFHIRDatastoreCommand = /* @__PURE__ */ __name(async (input, context) => {
@@ -803,7 +817,8 @@ var se_StartFHIRImportJobRequest = /* @__PURE__ */ __name((input, context) => {
     DatastoreId: [],
     InputDataConfig: import_smithy_client._json,
     JobName: [],
-    JobOutputDataConfig: import_smithy_client._json
+    JobOutputDataConfig: import_smithy_client._json,
+    ValidationLevel: []
   });
 }, "se_StartFHIRImportJobRequest");
 var de_DatastoreProperties = /* @__PURE__ */ __name((output, context) => {
@@ -873,7 +888,8 @@ var de_ImportJobProperties = /* @__PURE__ */ __name((output, context) => {
     JobProgressReport: /* @__PURE__ */ __name((_) => de_JobProgressReport(_, context), "JobProgressReport"),
     JobStatus: import_smithy_client.expectString,
     Message: import_smithy_client.expectString,
-    SubmitTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "SubmitTime")
+    SubmitTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "SubmitTime"),
+    ValidationLevel: import_smithy_client.expectString
   });
 }, "de_ImportJobProperties");
 var de_ImportJobPropertiesList = /* @__PURE__ */ __name((output, context) => {
@@ -1171,6 +1187,202 @@ var paginateListFHIRExportJobs = (0, import_core.createPaginator)(HealthLakeClie
 // src/pagination/ListFHIRImportJobsPaginator.ts
 
 var paginateListFHIRImportJobs = (0, import_core.createPaginator)(HealthLakeClient, ListFHIRImportJobsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/waiters/waitForFHIRDatastoreActive.ts
+var import_util_waiter = require("@smithy/util-waiter");
+var checkState = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new DescribeFHIRDatastoreCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.DatastoreProperties.DatastoreStatus;
+      }, "returnComparator");
+      if (returnComparator() === "ACTIVE") {
+        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.DatastoreProperties.DatastoreStatus;
+      }, "returnComparator");
+      if (returnComparator() === "CREATE_FAILED") {
+        return { state: import_util_waiter.WaiterState.FAILURE, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.DatastoreProperties.DatastoreStatus;
+      }, "returnComparator");
+      if (returnComparator() === "DELETED") {
+        return { state: import_util_waiter.WaiterState.FAILURE, reason };
+      }
+    } catch (e) {
+    }
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForFHIRDatastoreActive = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 60, maxDelay: 120 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+}, "waitForFHIRDatastoreActive");
+var waitUntilFHIRDatastoreActive = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 60, maxDelay: 120 };
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilFHIRDatastoreActive");
+
+// src/waiters/waitForFHIRDatastoreDeleted.ts
+
+var checkState2 = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new DescribeFHIRDatastoreCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.DatastoreProperties.DatastoreStatus;
+      }, "returnComparator");
+      if (returnComparator() === "DELETED") {
+        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+      }
+    } catch (e) {
+    }
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForFHIRDatastoreDeleted = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 120, maxDelay: 120 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState2);
+}, "waitForFHIRDatastoreDeleted");
+var waitUntilFHIRDatastoreDeleted = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 120, maxDelay: 120 };
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState2);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilFHIRDatastoreDeleted");
+
+// src/waiters/waitForFHIRExportJobCompleted.ts
+
+var checkState3 = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new DescribeFHIRExportJobCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.ExportJobProperties.JobStatus;
+      }, "returnComparator");
+      if (returnComparator() === "COMPLETED") {
+        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.ExportJobProperties.JobStatus;
+      }, "returnComparator");
+      if (returnComparator() === "COMPLETED_WITH_ERRORS") {
+        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.ExportJobProperties.JobStatus;
+      }, "returnComparator");
+      if (returnComparator() === "CANCEL_COMPLETED") {
+        return { state: import_util_waiter.WaiterState.FAILURE, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.ExportJobProperties.JobStatus;
+      }, "returnComparator");
+      if (returnComparator() === "FAILED") {
+        return { state: import_util_waiter.WaiterState.FAILURE, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.ExportJobProperties.JobStatus;
+      }, "returnComparator");
+      if (returnComparator() === "CANCEL_FAILED") {
+        return { state: import_util_waiter.WaiterState.FAILURE, reason };
+      }
+    } catch (e) {
+    }
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForFHIRExportJobCompleted = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 120, maxDelay: 120 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState3);
+}, "waitForFHIRExportJobCompleted");
+var waitUntilFHIRExportJobCompleted = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 120, maxDelay: 120 };
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState3);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilFHIRExportJobCompleted");
+
+// src/waiters/waitForFHIRImportJobCompleted.ts
+
+var checkState4 = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new DescribeFHIRImportJobCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.ImportJobProperties.JobStatus;
+      }, "returnComparator");
+      if (returnComparator() === "COMPLETED") {
+        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.ImportJobProperties.JobStatus;
+      }, "returnComparator");
+      if (returnComparator() === "COMPLETED_WITH_ERRORS") {
+        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.ImportJobProperties.JobStatus;
+      }, "returnComparator");
+      if (returnComparator() === "FAILED") {
+        return { state: import_util_waiter.WaiterState.FAILURE, reason };
+      }
+    } catch (e) {
+    }
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForFHIRImportJobCompleted = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 120, maxDelay: 120 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState4);
+}, "waitForFHIRImportJobCompleted");
+var waitUntilFHIRImportJobCompleted = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 120, maxDelay: 120 };
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState4);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilFHIRImportJobCompleted");
 // Annotate the CommonJS export names for ESM import in node:
 
 0 && (module.exports = {
@@ -1195,6 +1407,14 @@ var paginateListFHIRImportJobs = (0, import_core.createPaginator)(HealthLakeClie
   paginateListFHIRDatastores,
   paginateListFHIRExportJobs,
   paginateListFHIRImportJobs,
+  waitForFHIRDatastoreActive,
+  waitUntilFHIRDatastoreActive,
+  waitForFHIRDatastoreDeleted,
+  waitUntilFHIRDatastoreDeleted,
+  waitForFHIRExportJobCompleted,
+  waitUntilFHIRExportJobCompleted,
+  waitForFHIRImportJobCompleted,
+  waitUntilFHIRImportJobCompleted,
   AccessDeniedException,
   AuthorizationStrategy,
   CmkType,
@@ -1209,6 +1429,7 @@ var paginateListFHIRImportJobs = (0, import_core.createPaginator)(HealthLakeClie
   ResourceNotFoundException,
   JobStatus,
   OutputDataConfig,
-  InputDataConfig
+  InputDataConfig,
+  ValidationLevel
 });
 

package/dist-es/index.js

@@ -2,5 +2,6 @@ export * from "./HealthLakeClient";
 export * from "./HealthLake";
 export * from "./commands";
 export * from "./pagination";
+export * from "./waiters";
 export * from "./models";
 export { HealthLakeServiceException } from "./models/HealthLakeServiceException";

package/dist-es/models/models_0.js

@@ -137,3 +137,8 @@ export var InputDataConfig;
         return visitor._(value.$unknown[0], value.$unknown[1]);
     };
 })(InputDataConfig || (InputDataConfig = {}));
+export const ValidationLevel = {
+    MINIMAL: "minimal",
+    STRICT: "strict",
+    STRUCTURE_ONLY: "structure-only",
+};

package/dist-es/protocols/Aws_json1_0.js

@@ -404,6 +404,7 @@ const se_StartFHIRImportJobRequest = (input, context) => {
         InputDataConfig: _json,
         JobName: [],
         JobOutputDataConfig: _json,
+        ValidationLevel: [],
     });
 };
 const de_DatastoreProperties = (output, context) => {
@@ -478,6 +479,7 @@ const de_ImportJobProperties = (output, context) => {
         JobStatus: __expectString,
         Message: __expectString,
         SubmitTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        ValidationLevel: __expectString,
     });
 };
 const de_ImportJobPropertiesList = (output, context) => {

package/dist-es/waiters/index.js

@@ -0,0 +1,4 @@
+export * from "./waitForFHIRDatastoreActive";
+export * from "./waitForFHIRDatastoreDeleted";
+export * from "./waitForFHIRExportJobCompleted";
+export * from "./waitForFHIRImportJobCompleted";

package/dist-es/waiters/waitForFHIRDatastoreActive.js

@@ -0,0 +1,49 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeFHIRDatastoreCommand, } from "../commands/DescribeFHIRDatastoreCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeFHIRDatastoreCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.DatastoreProperties.DatastoreStatus;
+            };
+            if (returnComparator() === "ACTIVE") {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.DatastoreProperties.DatastoreStatus;
+            };
+            if (returnComparator() === "CREATE_FAILED") {
+                return { state: WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.DatastoreProperties.DatastoreStatus;
+            };
+            if (returnComparator() === "DELETED") {
+                return { state: WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForFHIRDatastoreActive = async (params, input) => {
+    const serviceDefaults = { minDelay: 60, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilFHIRDatastoreActive = async (params, input) => {
+    const serviceDefaults = { minDelay: 60, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

package/dist-es/waiters/waitForFHIRDatastoreDeleted.js

@@ -0,0 +1,31 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeFHIRDatastoreCommand, } from "../commands/DescribeFHIRDatastoreCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeFHIRDatastoreCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.DatastoreProperties.DatastoreStatus;
+            };
+            if (returnComparator() === "DELETED") {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForFHIRDatastoreDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 120, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilFHIRDatastoreDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 120, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

package/dist-es/waiters/waitForFHIRExportJobCompleted.js

@@ -0,0 +1,67 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeFHIRExportJobCommand, } from "../commands/DescribeFHIRExportJobCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeFHIRExportJobCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.ExportJobProperties.JobStatus;
+            };
+            if (returnComparator() === "COMPLETED") {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.ExportJobProperties.JobStatus;
+            };
+            if (returnComparator() === "COMPLETED_WITH_ERRORS") {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.ExportJobProperties.JobStatus;
+            };
+            if (returnComparator() === "CANCEL_COMPLETED") {
+                return { state: WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.ExportJobProperties.JobStatus;
+            };
+            if (returnComparator() === "FAILED") {
+                return { state: WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.ExportJobProperties.JobStatus;
+            };
+            if (returnComparator() === "CANCEL_FAILED") {
+                return { state: WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForFHIRExportJobCompleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 120, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilFHIRExportJobCompleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 120, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

package/dist-es/waiters/waitForFHIRImportJobCompleted.js

@@ -0,0 +1,49 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeFHIRImportJobCommand, } from "../commands/DescribeFHIRImportJobCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeFHIRImportJobCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.ImportJobProperties.JobStatus;
+            };
+            if (returnComparator() === "COMPLETED") {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.ImportJobProperties.JobStatus;
+            };
+            if (returnComparator() === "COMPLETED_WITH_ERRORS") {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.ImportJobProperties.JobStatus;
+            };
+            if (returnComparator() === "FAILED") {
+                return { state: WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForFHIRImportJobCompleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 120, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilFHIRImportJobCompleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 120, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

package/dist-types/HealthLake.d.ts

@@ -95,8 +95,9 @@ export interface HealthLake {
     untagResource(args: UntagResourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UntagResourceCommandOutput) => void): void;
 }
 /**
- * <p>AWS HealthLake is a HIPAA eligibile service that allows customers to store,
- *          transform, query, and analyze their FHIR-formatted data in a consistent fashion in the cloud.</p>
+ * <p>This is the <i>AWS HealthLake API Reference</i>. For an introduction to
+ *          the service, see <a href="https://docs.aws.amazon.com/healthlake/latest/devguide/what-is.html">What is AWS HealthLake?</a> in the <i>AWS HealthLake Developer
+ *             Guide</i>.</p>
  * @public
  */
 export declare class HealthLake extends HealthLakeClient implements HealthLake {

package/dist-types/HealthLakeClient.d.ts

@@ -182,8 +182,9 @@ export type HealthLakeClientResolvedConfigType = __SmithyResolvedConfiguration<_
 export interface HealthLakeClientResolvedConfig extends HealthLakeClientResolvedConfigType {
 }
 /**
- * <p>AWS HealthLake is a HIPAA eligibile service that allows customers to store,
- *          transform, query, and analyze their FHIR-formatted data in a consistent fashion in the cloud.</p>
+ * <p>This is the <i>AWS HealthLake API Reference</i>. For an introduction to
+ *          the service, see <a href="https://docs.aws.amazon.com/healthlake/latest/devguide/what-is.html">What is AWS HealthLake?</a> in the <i>AWS HealthLake Developer
+ *             Guide</i>.</p>
  * @public
  */
 export declare class HealthLakeClient extends __Client<__HttpHandlerOptions, ServiceInputTypes, ServiceOutputTypes, HealthLakeClientResolvedConfig> {

package/dist-types/commands/CreateFHIRDatastoreCommand.d.ts

@@ -27,7 +27,7 @@ declare const CreateFHIRDatastoreCommand_base: {
     getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
 };
 /**
- * <p>Creates a data store that can ingest and export FHIR formatted data.</p>
+ * <p>Create a FHIR-enabled data store.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript
@@ -81,7 +81,7 @@ declare const CreateFHIRDatastoreCommand_base: {
  *  <p>Access is denied. Your account is not authorized to perform this operation.</p>
  *
  * @throws {@link InternalServerException} (server fault)
- *  <p>Unknown error occurs in the service.</p>
+ *  <p>An unknown internal error occurred in the service.</p>
  *
  * @throws {@link ThrottlingException} (client fault)
  *  <p>The user has exceeded their maximum number of allowed calls to the given API. </p>

package/dist-types/commands/DeleteFHIRDatastoreCommand.d.ts

@@ -27,7 +27,7 @@ declare const DeleteFHIRDatastoreCommand_base: {
     getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
 };
 /**
- * <p>Deletes a data store. </p>
+ * <p>Delete a FHIR-enabled data store.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript
@@ -58,13 +58,14 @@ declare const DeleteFHIRDatastoreCommand_base: {
  *  <p>Access is denied. Your account is not authorized to perform this operation.</p>
  *
  * @throws {@link ConflictException} (client fault)
- *  <p>The data store is in a transition state and the user requested action can not be performed.</p>
+ *  <p>The data store is in a transition state and the user requested action cannot be
+ *          performed.</p>
  *
  * @throws {@link InternalServerException} (server fault)
- *  <p>Unknown error occurs in the service.</p>
+ *  <p>An unknown internal error occurred in the service.</p>
  *
  * @throws {@link ResourceNotFoundException} (client fault)
- *  <p> The requested data store was not found.</p>
+ *  <p>The requested data store was not found.</p>
  *
  * @throws {@link ThrottlingException} (client fault)
  *  <p>The user has exceeded their maximum number of allowed calls to the given API. </p>

package/dist-types/commands/DescribeFHIRDatastoreCommand.d.ts

@@ -27,8 +27,7 @@ declare const DescribeFHIRDatastoreCommand_base: {
     getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
 };
 /**
- * <p>Gets the properties associated with the FHIR data store, including the data store ID,
- *          data store ARN, data store name, data store status, when the data store was created, data store type version, and the data store's endpoint.</p>
+ * <p>Get properties for a FHIR-enabled data store.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript
@@ -80,10 +79,10 @@ declare const DescribeFHIRDatastoreCommand_base: {
  * @see {@link HealthLakeClientResolvedConfig | config} for HealthLakeClient's `config` shape.
  *
  * @throws {@link InternalServerException} (server fault)
- *  <p>Unknown error occurs in the service.</p>
+ *  <p>An unknown internal error occurred in the service.</p>
  *
  * @throws {@link ResourceNotFoundException} (client fault)
- *  <p> The requested data store was not found.</p>
+ *  <p>The requested data store was not found.</p>
  *
  * @throws {@link ThrottlingException} (client fault)
  *  <p>The user has exceeded their maximum number of allowed calls to the given API. </p>

package/dist-types/commands/DescribeFHIRExportJobCommand.d.ts

@@ -27,7 +27,7 @@ declare const DescribeFHIRExportJobCommand_base: {
     getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
 };
 /**
- * <p>Displays the properties of a FHIR export job, including the ID, ARN, name, and the status of the job.</p>
+ * <p>Get FHIR export job properties.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript
@@ -68,10 +68,10 @@ declare const DescribeFHIRExportJobCommand_base: {
  * @see {@link HealthLakeClientResolvedConfig | config} for HealthLakeClient's `config` shape.
  *
  * @throws {@link InternalServerException} (server fault)
- *  <p>Unknown error occurs in the service.</p>
+ *  <p>An unknown internal error occurred in the service.</p>
  *
  * @throws {@link ResourceNotFoundException} (client fault)
- *  <p> The requested data store was not found.</p>
+ *  <p>The requested data store was not found.</p>
  *
  * @throws {@link ThrottlingException} (client fault)
  *  <p>The user has exceeded their maximum number of allowed calls to the given API. </p>