@healthcloudai/hc-login-connector 0.1.0 → 0.2.0

package/dist/index.cjs

@@ -20,443 +20,411 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  AuthError: () => AuthError,
-  ConfigError: () => ConfigError,
+  APIError: () => import_hc_http2.APIError,
+  ConfigError: () => import_hc_http2.ConfigError,
   HCLoginClient: () => HCLoginClient,
-  HttpError: () => HttpError
+  HCServiceError: () => import_hc_http2.HCServiceError,
+  NetworkError: () => import_hc_http2.NetworkError,
+  ValidationError: () => import_hc_http2.ValidationError,
+  errorFromHttpStatus: () => import_hc_http2.errorFromHttpStatus
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/errors.ts
-var ConfigError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "ConfigError";
-  }
-};
-var AuthError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "AuthError";
-  }
-};
-var HttpError = class extends Error {
-  constructor(status, message) {
-    super(message);
-    this.name = "HttpError";
-    this.status = status;
-  }
-};
-
 // src/client.ts
-var ENV_PREFIX = {
-  dev: "dev-api-healthcheck",
-  uat: "uat-api-healthcheck",
-  prod: "api-healthcheck"
+var import_hc_http = require("@healthcloudai/hc-http");
+var API_BASE_URLS = {
+  dev: "https://dev-api-healthcheck.healthcloud-services.com",
+  uat: "https://uat-api-healthcheck.healthcloud-services.com",
+  prod: "https://api-healthcheck.healthcloud-services.com"
 };
-function buildBaseUrl(tenantID, environment, region) {
-  const regionSuffix = region ? `-${region}` : "";
-  return `https://${ENV_PREFIX[environment]}${regionSuffix}.healthcloud-services.com/api`;
+function buildBaseUrl(environment, region) {
+  const base = API_BASE_URLS[environment];
+  if (!region) {
+    return base;
+  }
+  return base.replace(
+    "https://",
+    `https://${region}-`
+  );
 }
 var HCLoginClient = class {
   constructor(httpClient) {
     this.http = httpClient;
   }
+  // =========================================================================
+  // Configuration
+  // =========================================================================
   configure(tenantID, environment, region) {
     const trimmedTenantID = tenantID == null ? void 0 : tenantID.trim();
     if (!trimmedTenantID) {
-      throw new ConfigError("tenantID is required.");
+      throw new import_hc_http.ConfigError(
+        "tenantID is required."
+      );
     }
-    if (!ENV_PREFIX[environment]) {
-      throw new ConfigError("Invalid environment.");
+    const baseUrl = API_BASE_URLS[environment];
+    if (!baseUrl) {
+      throw new import_hc_http.ConfigError(
+        `Unsupported environment: "${environment}"`
+      );
     }
     this.config = {
       tenantID: trimmedTenantID,
       environment,
       region,
-      baseUrl: buildBaseUrl(trimmedTenantID, environment, region)
+      baseUrl: buildBaseUrl(
+        environment,
+        region
+      )
     };
   }
   setApiKey(headerName, value) {
     const trimmedHeaderName = headerName == null ? void 0 : headerName.trim();
     const trimmedValue = value == null ? void 0 : value.trim();
     if (!trimmedHeaderName) {
-      throw new ConfigError("API key header name is required.");
+      throw new import_hc_http.ConfigError(
+        "API key header name is required."
+      );
     }
     if (!trimmedValue) {
-      throw new ConfigError("API key value is required.");
+      throw new import_hc_http.ConfigError(
+        "API key value is required."
+      );
     }
     this.apiKeyHeaderName = trimmedHeaderName;
     this.apiKeyValue = trimmedValue;
   }
   getEnvironment() {
-    if (!this.config) {
-      throw new ConfigError("Login client must be configured first.");
-    }
+    this.ensureConfigured();
     return this.config.environment;
   }
-  async register(email, password, firstName = "Unknown", lastName = "Unknown", options = {}) {
-    var _a, _b;
+  getBaseUrl() {
     this.ensureConfigured();
-    const config = this.config;
-    const userEmail = (_a = options.email) != null ? _a : email;
-    const attributes = {
-      ...(_b = options.attributes) != null ? _b : {},
-      ...options.verifyEmailCode === true ? { VERIFY_EMAIL_CODE: "true" } : {}
-    };
-    const requestPayload = {
-      Data: {
-        TenantID: config.tenantID,
-        Credentials: {
-          Email: email,
-          Password: password
-        },
-        User: {
-          FirstName: firstName || "Unknown",
-          LastName: lastName || "Unknown",
-          Email: userEmail,
-          Phone: options.phone,
-          BirthDate: options.birthDate,
-          Gender: options.gender,
-          Attributes: attributes
-        }
-      }
-    };
-    return this.http.post(
-      `${config.baseUrl}/patient/register`,
-      requestPayload,
-      {
-        "Content-Type": "application/json",
-        "X-Tenant-ID": config.tenantID,
-        ...this.getApiKeyHeader()
-      }
-    );
+    return this.config.baseUrl;
   }
-  async registerFull(options = {}) {
-    var _a, _b, _c, _d, _e;
+  getTenantId() {
     this.ensureConfigured();
-    const config = this.config;
-    const attributes = {
-      ...(_a = options.attributes) != null ? _a : {},
-      ...options.verifyEmailCode === true ? { VERIFY_EMAIL_CODE: "true" } : {}
-    };
-    const requestPayload = {
-      Data: {
-        TenantID: config.tenantID,
-        Credentials: {
-          Email: (_b = options.email) != null ? _b : "",
-          Password: (_c = options.password) != null ? _c : "",
-          TenantID: config.tenantID,
-          ...options.language ? { Language: options.language } : {}
-        },
-        User: {
-          FirstName: (_d = options.firstName) != null ? _d : "Unknown",
-          LastName: (_e = options.lastName) != null ? _e : "Unknown",
-          ...options.email ? { Email: options.email } : {},
-          ...options.phone ? { Phone: options.phone } : {},
-          ...options.birthDate ? { BirthDate: options.birthDate } : {},
-          ...options.gender ? { Gender: options.gender } : {},
-          ...options.middleName ? { MiddleName: options.middleName } : {},
-          ...options.race ? { Race: options.race } : {},
-          ...options.ethnicity ? { Ethnicity: options.ethnicity } : {},
-          ...options.sex ? { Sex: options.sex } : {},
-          ...options.genderIdentity ? { GenderIdentity: options.genderIdentity } : {},
-          ...options.status !== void 0 ? { Status: options.status } : {},
-          ...options.address ? { Address: options.address } : {},
-          Attributes: attributes
-        }
-      }
-    };
-    return this.http.post(
-      `${config.baseUrl}/patient/register`,
-      requestPayload,
-      {
-        "Content-Type": "application/json",
-        "X-Tenant-ID": config.tenantID,
-        ...this.getApiKeyHeader()
-      }
-    );
-  }
-  async verifyEmail(email, code, language = "en", options = { verifyEmailCode: false }) {
-    return this.submitOnboardingStep(
-      "EMAIL_VERIFY",
-      this.buildEmailVerificationInput(email, options),
-      code,
-      language
-    );
-  }
-  async resendEmailVerify(email, language = "en", options = { verifyEmailCode: false }) {
-    return this.submitOnboardingStep(
-      "RESEND_EMAIL_VERIFY",
-      this.buildEmailVerificationInput(email, options),
-      "",
-      language
-    );
-  }
-  async resendSmsVerify(email, phone, language = "en") {
-    return this.submitOnboardingStep(
-      "RESEND_SMS_VERIFY",
-      {
-        Email: email,
-        Phone: phone
-      },
-      "",
-      language
-    );
+    return this.config.tenantID;
   }
-  async verifySms(email, phone, code, language = "en") {
-    return this.submitOnboardingStep(
-      "SMS_VERIFY",
-      {
-        Email: email,
-        Phone: phone
-      },
-      code,
-      language
-    );
+  getTokens() {
+    return this.tokens;
   }
-  async saveHealthProfile(profile, language = "en") {
-    return this.submitOnboardingStep(
-      "SAVE_HEALTH_PROFILE",
-      profile,
-      "",
-      language
-    );
+  getAccessToken() {
+    var _a;
+    return (_a = this.tokens) == null ? void 0 : _a.accessToken;
   }
-  async saveAddress(email, address, language = "en") {
-    return this.submitOnboardingStep(
-      "SAVE_ADDRESS",
-      {
-        Email: email,
-        Address: address
-      },
-      "",
-      language
-    );
+  getIDToken() {
+    var _a;
+    return (_a = this.tokens) == null ? void 0 : _a.idToken;
   }
-  async login(email, password) {
+  getAuthHeader() {
     var _a;
     this.ensureConfigured();
-    const requestPayload = {
-      Data: {
-        Email: email,
-        Password: password,
-        TenantID: this.config.tenantID
-      }
-    };
-    const resp = await this.http.post(
-      `${this.config.baseUrl}/patient/login`,
-      requestPayload,
-      {
-        "X-Tenant-ID": this.config.tenantID,
-        ...this.getApiKeyHeader()
-      }
-    );
-    const data = (_a = resp.Data) != null ? _a : resp;
-    const tokens = {
-      accessToken: data.AccessToken,
-      refreshToken: data.RefreshToken,
-      idToken: data.IDToken,
-      expiresIn: new Date(data.Expiration).getTime()
+    if (!((_a = this.tokens) == null ? void 0 : _a.idToken)) {
+      throw new import_hc_http.APIError({
+        message: "User is not authenticated.",
+        code: "UNAUTHORIZED",
+        statusCode: 401
+      });
+    }
+    return {
+      Authorization: `Bearer ${this.tokens.idToken}`,
+      "X-Tenant-ID": this.config.tenantID,
+      ...this.getApiKeyHeader()
     };
-    this.tokens = tokens;
-    return tokens;
   }
-  async refreshToken() {
-    var _a, _b;
-    this.ensureConfigured();
-    if (!((_a = this.tokens) == null ? void 0 : _a.refreshToken)) {
-      throw new AuthError("No refresh token available");
+  logout() {
+    this.tokens = void 0;
+  }
+  // =========================================================================
+  // Authentication
+  // =========================================================================
+  async login(email, password, context = "PATIENT") {
+    if (!(email == null ? void 0 : email.trim())) {
+      throw new import_hc_http.ValidationError({
+        message: "Email is required.",
+        code: "INVALID_INPUT"
+      });
     }
-    const requestPayload = {
-      Data: {
-        RefreshToken: this.tokens.refreshToken,
-        TenantID: this.config.tenantID
-      }
-    };
-    const resp = await this.http.post(
-      `${this.config.baseUrl}/patient/refresh`,
-      requestPayload,
-      {
-        "X-Tenant-ID": this.config.tenantID,
-        ...this.getApiKeyHeader()
+    if (!(password == null ? void 0 : password.trim())) {
+      throw new import_hc_http.ValidationError({
+        message: "Password is required.",
+        code: "INVALID_INPUT"
+      });
+    }
+    this.ensureConfigured();
+    return this.execute(
+      "login",
+      async () => {
+        const response = await this.http.post(
+          `${this.config.baseUrl}/api/${this.resolveContextPath(context)}/login`,
+          {
+            Data: {
+              Email: email,
+              Password: password,
+              TenantID: this.config.tenantID
+            }
+          },
+          this.headers()
+        );
+        if (!response.Data) {
+          throw new import_hc_http.APIError({
+            message: "login: identity authorization data is missing",
+            code: "INVALID_RESPONSE",
+            details: response
+          });
+        }
+        this.storeAuthTokens(
+          response.Data
+        );
+        return response;
       }
     );
-    const data = (_b = resp.Data) != null ? _b : resp;
-    const tokens = {
-      accessToken: data.AccessToken,
-      refreshToken: data.RefreshToken,
-      idToken: data.IDToken,
-      expiresIn: new Date(data.Expiration).getTime()
-    };
-    this.tokens = tokens;
-    return tokens;
   }
-  async resetPassword(email, isPasswordResetWithOTP = false) {
-    var _a;
+  async refreshToken(refreshToken, context = "PATIENT") {
+    var _a, _b;
+    const token = (_b = refreshToken == null ? void 0 : refreshToken.trim()) != null ? _b : (_a = this.tokens) == null ? void 0 : _a.refreshToken;
+    if (!(token == null ? void 0 : token.trim())) {
+      throw new import_hc_http.ValidationError({
+        message: "Refresh token is required.",
+        code: "INVALID_INPUT"
+      });
+    }
     this.ensureConfigured();
-    const requestPayload = {
-      Data: {
-        Email: email,
-        TenantID: this.config.tenantID,
-        ...isPasswordResetWithOTP === true ? { IsPasswordResetWithOTP: true } : {}
-      }
-    };
-    await this.http.post(
-      `${this.config.baseUrl}/patient/resetpassword`,
-      requestPayload,
-      {
-        "Content-Type": "application/json",
-        "X-Tenant-ID": this.config.tenantID,
-        ...this.getApiKeyHeader(),
-        ...((_a = this.tokens) == null ? void 0 : _a.idToken) ? { Authorization: `Bearer ${this.tokens.idToken}` } : {}
+    return this.execute(
+      "refreshToken",
+      async () => {
+        const requestPayload = {
+          Data: {
+            RefreshToken: token,
+            TenantID: this.config.tenantID
+          }
+        };
+        const response = await this.http.post(
+          `${this.config.baseUrl}/api/${this.resolveContextPath(context)}/refresh`,
+          requestPayload,
+          this.headers()
+        );
+        if (!response.Data) {
+          throw new import_hc_http.APIError({
+            message: "refreshToken: identity authorization data is missing",
+            code: "INVALID_RESPONSE",
+            details: response
+          });
+        }
+        this.storeAuthTokens(
+          response.Data
+        );
+        return response;
       }
     );
   }
-  async resetPasswordConfirm(payload) {
-    var _a;
-    this.ensureConfigured();
-    const isOtpFlow = payload.Data.IsPasswordResetWithOTP === true;
-    if (isOtpFlow && !payload.Data.Code) {
-      throw new ConfigError("Code is required for OTP password reset confirmation.");
+  async register(email, password, firstName = "Unknown", lastName = "Unknown", options = {}) {
+    if (!(email == null ? void 0 : email.trim())) {
+      throw new import_hc_http.ValidationError({
+        message: "Email is required.",
+        code: "INVALID_INPUT"
+      });
     }
-    if (!isOtpFlow && !payload.Data.Token) {
-      throw new ConfigError("Token is required for link-based password reset confirmation.");
+    if (!(password == null ? void 0 : password.trim())) {
+      throw new import_hc_http.ValidationError({
+        message: "Password is required.",
+        code: "INVALID_INPUT"
+      });
     }
-    await this.http.post(
-      `${this.config.baseUrl}/patient/password`,
-      {
-        Data: {
-          ...payload.Data,
-          TenantID: this.config.tenantID
-        }
-      },
-      {
-        "Content-Type": "application/json",
-        "X-Tenant-ID": this.config.tenantID,
-        ...this.getApiKeyHeader(),
-        ...((_a = this.tokens) == null ? void 0 : _a.idToken) ? { Authorization: `Bearer ${this.tokens.idToken}` } : {}
+    this.ensureConfigured();
+    return this.execute(
+      "register",
+      () => {
+        var _a, _b;
+        return this.http.post(
+          `${this.config.baseUrl}/api/patient/register`,
+          {
+            Data: {
+              TenantID: this.config.tenantID,
+              Credentials: {
+                Email: email,
+                Password: password
+              },
+              User: {
+                FirstName: firstName,
+                LastName: lastName,
+                Email: (_a = options.email) != null ? _a : email,
+                Phone: options.phone,
+                BirthDate: options.birthDate,
+                Gender: options.gender,
+                Attributes: {
+                  ...(_b = options.attributes) != null ? _b : {},
+                  ...options.verifyEmailCode === true ? {
+                    VERIFY_EMAIL_CODE: "true"
+                  } : {}
+                }
+              }
+            }
+          },
+          this.headers()
+        );
       }
     );
   }
-  getAccessToken() {
-    var _a;
-    return (_a = this.tokens) == null ? void 0 : _a.accessToken;
-  }
-  getIDToken() {
-    var _a;
-    return (_a = this.tokens) == null ? void 0 : _a.idToken;
-  }
-  async getUserInfo() {
-    var _a;
-    this.ensureConfigured();
-    if (!((_a = this.tokens) == null ? void 0 : _a.idToken)) {
-      throw new AuthError("No ID token available");
+  async requestPasswordReset(email, context = "PATIENT", isOTP = false) {
+    if (!(email == null ? void 0 : email.trim())) {
+      throw new import_hc_http.ValidationError({
+        message: "Email is required.",
+        code: "INVALID_INPUT"
+      });
     }
-    return this.http.get(
-      `${this.config.baseUrl}/patient/header`,
-      this.getAuthHeader()
+    this.ensureConfigured();
+    return this.execute(
+      "requestPasswordReset",
+      () => this.http.post(
+        `${this.config.baseUrl}/api/${this.resolveContextPath(context)}/resetpassword`,
+        {
+          Data: {
+            Email: email,
+            TenantID: this.config.tenantID,
+            IsPasswordResetWithOTP: isOTP
+          }
+        },
+        this.headers()
+      )
     );
   }
-  ensureConfigured() {
-    if (!this.config) {
-      throw new ConfigError("HCLogin is not configured. Call configure() first.");
+  async confirmPasswordReset(email, password, code, context = "PATIENT") {
+    if (!(email == null ? void 0 : email.trim())) {
+      throw new import_hc_http.ValidationError({
+        message: "Email is required.",
+        code: "INVALID_INPUT"
+      });
     }
-  }
-  buildOnboardingUser(step, user) {
-    var _a;
-    switch (step) {
-      case "EMAIL_VERIFY":
-      case "RESEND_EMAIL_VERIFY":
-        return {
-          Email: user.Email,
-          TenantID: this.config.tenantID,
-          ...user.Attributes ? { Attributes: user.Attributes } : {}
-        };
-      case "RESEND_SMS_VERIFY":
-      case "SMS_VERIFY":
-        return {
-          Email: user.Email,
-          TenantID: this.config.tenantID,
-          Phone: user.Phone
-        };
-      case "SAVE_HEALTH_PROFILE":
-        return {
-          Email: user.Email,
-          TenantID: this.config.tenantID,
-          FirstName: user.FirstName,
-          LastName: user.LastName,
-          BirthDate: user.BirthDate,
-          Gender: user.Gender,
-          Sex: user.Sex,
-          Status: (_a = user.Status) != null ? _a : 0,
-          Phone: user.Phone,
-          ...user.Race !== void 0 ? { Race: user.Race } : {},
-          ...user.Ethnicity !== void 0 ? { Ethnicity: user.Ethnicity } : {}
-        };
-      case "SAVE_ADDRESS":
-        return {
-          Email: user.Email,
-          TenantID: this.config.tenantID,
-          Address: user.Address ? {
-            StreetAndNumber: user.Address.StreetAndNumber,
-            Extension: user.Address.Extension,
-            City: user.Address.City,
-            State: user.Address.State,
-            PostalCode: user.Address.PostalCode,
-            Country: user.Address.Country
-          } : void 0
-        };
+    if (!(password == null ? void 0 : password.trim())) {
+      throw new import_hc_http.ValidationError({
+        message: "Password is required.",
+        code: "INVALID_INPUT"
+      });
     }
-  }
-  buildEmailVerificationInput(email, options) {
-    const attributes = this.buildEmailVerificationAttributes(options);
-    return {
-      Email: email,
-      ...attributes ? { Attributes: attributes } : {}
-    };
-  }
-  buildEmailVerificationAttributes(options) {
-    var _a;
-    const attributes = {
-      ...(_a = options.attributes) != null ? _a : {}
-    };
-    if (options.verifyEmailCode === true) {
-      attributes.VERIFY_EMAIL_CODE = "true";
+    if (!(code == null ? void 0 : code.trim())) {
+      throw new import_hc_http.ValidationError({
+        message: "Reset code is required.",
+        code: "INVALID_INPUT"
+      });
     }
-    return Object.keys(attributes).length > 0 ? attributes : void 0;
+    this.ensureConfigured();
+    return this.execute(
+      "confirmPasswordReset",
+      () => this.http.post(
+        `${this.config.baseUrl}/api/${this.resolveContextPath(context)}/password`,
+        {
+          Data: {
+            Email: email,
+            Password: password,
+            Code: code,
+            TenantID: this.config.tenantID
+          }
+        },
+        this.headers()
+      )
+    );
   }
-  submitOnboardingStep(step, user, data = "", language = "en") {
+  async getPatientHeader() {
     this.ensureConfigured();
-    const payload = {
-      Data: {
-        Data: data,
-        Step: step,
-        User: this.buildOnboardingUser(step, user),
-        Language: language
+    return this.execute(
+      "getPatientHeader",
+      () => this.http.get(
+        `${this.config.baseUrl}/api/patient/header`,
+        this.authHeaders()
+      )
+    );
+  }
+  // =========================================================================
+  // Private
+  // =========================================================================
+  async execute(operation, request) {
+    let response;
+    try {
+      response = await request();
+    } catch (err) {
+      if (err instanceof import_hc_http.APIError) {
+        throw err;
       }
-    };
-    return this.http.post(
-      `${this.config.baseUrl}/patient/onboard`,
-      payload,
-      {
-        "Content-Type": "application/json",
-        "X-Tenant-ID": this.config.tenantID,
-        ...this.getApiKeyHeader()
+      if (err instanceof TypeError) {
+        throw new import_hc_http.NetworkError({
+          message: `${operation}: network request failed`,
+          code: "NETWORK_ERROR",
+          details: err
+        });
+      }
+      if (err instanceof DOMException) {
+        if (err.name === "AbortError") {
+          throw new import_hc_http.NetworkError({
+            message: `${operation}: request aborted`,
+            code: "REQUEST_ABORTED",
+            details: err
+          });
+        }
+      }
+      if (err instanceof Error) {
+        throw new import_hc_http.APIError({
+          message: `${operation}: ${err.message}`,
+          code: "UNKNOWN_ERROR",
+          details: err
+        });
       }
+      throw new import_hc_http.APIError({
+        message: `${operation}: unexpected runtime failure`,
+        code: "UNKNOWN_ERROR",
+        details: err
+      });
+    }
+    if (response == null) {
+      throw new import_hc_http.APIError({
+        message: `${operation}: empty response received`,
+        code: "EMPTY_RESPONSE",
+        details: response
+      });
+    }
+    if (!this.isApiResponse(response)) {
+      throw new import_hc_http.APIError({
+        message: `${operation}: invalid API response structure`,
+        code: "INVALID_RESPONSE",
+        details: response
+      });
+    }
+    if (!response.IsOK) {
+      throw this.mapBackendError(
+        operation,
+        response
+      );
+    }
+    return response;
+  }
+  mapBackendError(operation, response) {
+    return new import_hc_http.HCServiceError(
+      operation,
+      response.ErrorMessage || "Unknown backend error",
+      response
     );
   }
-  getAuthHeader() {
-    var _a;
-    if (!((_a = this.tokens) == null ? void 0 : _a.idToken)) {
-      throw new AuthError("No ID token available");
+  isApiResponse(value) {
+    if (!value || typeof value !== "object") {
+      return false;
     }
+    const response = value;
+    return "IsOK" in response && typeof response.IsOK === "boolean" && "Data" in response && "ErrorMessage" in response;
+  }
+  headers() {
     return {
-      Authorization: `Bearer ${this.tokens.idToken}`,
+      Accept: "application/json",
+      "Content-Type": "application/json",
       "X-Tenant-ID": this.config.tenantID,
       ...this.getApiKeyHeader()
     };
   }
+  authHeaders() {
+    return {
+      ...this.headers(),
+      ...this.getAuthHeader()
+    };
+  }
   getApiKeyHeader() {
     if (!this.apiKeyHeaderName || !this.apiKeyValue) {
       return {};
@@ -465,24 +433,59 @@ var HCLoginClient = class {
       [this.apiKeyHeaderName]: this.apiKeyValue
     };
   }
-  getBaseUrl() {
+  resolveContextPath(context) {
+    switch (context) {
+      case "PATIENT":
+        return "patient";
+      case "PROVIDER":
+        return "provider";
+      case "KB":
+        return "kb";
+      case "ADMIN_PLATFORM":
+        return "admin/platform";
+      default:
+        return "patient";
+    }
+  }
+  ensureConfigured() {
     if (!this.config) {
-      throw new ConfigError("Not configured");
+      throw new import_hc_http.ConfigError(
+        "Login client must be configured before use."
+      );
     }
-    return this.config.baseUrl;
   }
-  getTenantId() {
+  storeAuthTokens(raw) {
+    var _a;
+    this.tokens = {
+      accessToken: raw.AccessToken,
+      refreshToken: raw.RefreshToken,
+      idToken: (_a = raw.IDToken) != null ? _a : null,
+      expiresAt: this.resolveExpiration(
+        raw
+      )
+    };
+  }
+  resolveExpiration(raw) {
     var _a;
-    if (!((_a = this.config) == null ? void 0 : _a.tenantID)) {
-      throw new ConfigError("Not configured");
+    if (raw.Expiration) {
+      const parsed = new Date(
+        raw.Expiration
+      ).getTime();
+      return Number.isNaN(parsed) ? 0 : parsed;
     }
-    return this.config.tenantID;
+    return (_a = raw.ExpiresIn) != null ? _a : 0;
   }
 };
+
+// src/errors.ts
+var import_hc_http2 = require("@healthcloudai/hc-http");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  AuthError,
+  APIError,
   ConfigError,
   HCLoginClient,
-  HttpError
+  HCServiceError,
+  NetworkError,
+  ValidationError,
+  errorFromHttpStatus
 });