@medrunner/api-client 0.0.1-rc.1

package/dist/index.mjs

@@ -0,0 +1,607 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/api/endpoints/ApiEndpoint.ts
+import axios, { AxiosError } from "axios";
+var ApiEndpoint = class {
+  constructor(baseUrl, tokenManager, log, headerProvider) {
+    this.baseUrl = baseUrl;
+    this.tokenManager = tokenManager;
+    this.log = log;
+    this.headerProvider = headerProvider;
+  }
+  endpointUrl() {
+    return `${this.baseUrl}/${this.endpoint()}`;
+  }
+  async headersForRequest(noAuthentication) {
+    const config = {
+      baseURL: this.baseUrl,
+      headers: {}
+    };
+    if (config.headers !== void 0) {
+      if (!noAuthentication) {
+        const accessToken = await this.tokenManager.getAccessToken();
+        if (accessToken !== void 0) {
+          config.headers.Authorization = `Bearer ${accessToken}`;
+        }
+      }
+      if (this.headerProvider !== void 0) {
+        for (const header of Object.entries(await this.headerProvider())) {
+          config.headers[header[0]] = header[1];
+        }
+      }
+    }
+    return config;
+  }
+  async getRequest(endpoint, queryParams, noAuthentication) {
+    return await this.makeRequestWithoutBody(endpoint, "GET", axios.get, queryParams, noAuthentication);
+  }
+  async postRequest(endpoint, data, noAuthentication) {
+    return await this.makeRequestWithBody(endpoint, "POST", axios.post, data, noAuthentication);
+  }
+  async putRequest(endpoint, data, noAuthentication) {
+    return await this.makeRequestWithBody(endpoint, "PUT", axios.put, data, noAuthentication);
+  }
+  async patchRequest(endpoint, data, noAuthentication) {
+    return await this.makeRequestWithBody(endpoint, "PATCH", axios.patch, data, noAuthentication);
+  }
+  async deleteRequest(endpoint, queryParams, noAuthentication) {
+    return await this.makeRequestWithoutBody(endpoint, "DELETE", axios.delete, queryParams, noAuthentication);
+  }
+  async makeRequestWithBody(endpoint, requestType, axiosRequest, data, noAuthentication) {
+    const wrappedRequest = /* @__PURE__ */ __name(async (requestUrl, config) => await axiosRequest(requestUrl, data, config), "wrappedRequest");
+    return await this.makeRequest(endpoint, requestType, wrappedRequest, void 0, noAuthentication);
+  }
+  async makeRequestWithoutBody(endpoint, requestType, axiosRequest, queryParams, noAuthentication) {
+    const wrappedRequest = /* @__PURE__ */ __name(async (requestUrl, config) => await axiosRequest(requestUrl, config), "wrappedRequest");
+    return await this.makeRequest(endpoint, requestType, wrappedRequest, queryParams, noAuthentication);
+  }
+  buildUrl(endpoint) {
+    const baseUrl = this.endpointUrl();
+    if (baseUrl.endsWith("/")) {
+      if (endpoint.startsWith("/")) {
+        return `${baseUrl}${endpoint.substring(1)}`;
+      }
+      return `${baseUrl}${endpoint}`;
+    }
+    if (endpoint.startsWith("/")) {
+      return `${baseUrl}${endpoint}`;
+    }
+    return `${baseUrl}/${endpoint}`;
+  }
+  async makeRequest(endpoint, requestType, request, queryParams, noAuthentication = false) {
+    const requestUrl = this.buildUrl(endpoint);
+    this.log?.debug(`sending ${requestType} request to ${requestUrl}`);
+    try {
+      const config = await this.headersForRequest(noAuthentication);
+      if (queryParams !== void 0) {
+        config.params = queryParams;
+      }
+      const result = await request(requestUrl, config);
+      return {
+        success: true,
+        data: result.data
+      };
+    } catch (e) {
+      this.log?.warn(`Error for ${requestType} request to ${requestUrl}: ${e}`);
+      return {
+        success: false,
+        errorMessage: e instanceof AxiosError ? e.response?.data : void 0,
+        statusCode: e instanceof AxiosError ? e.response?.status : void 0
+      };
+    }
+  }
+};
+__name(ApiEndpoint, "ApiEndpoint");
+
+// src/api/endpoints/auth/AuthEndpoint.ts
+var AuthEndpoint = class extends ApiEndpoint {
+  constructor(baseUrl, tokenManager, log, headerProvider) {
+    super(baseUrl, tokenManager, log, headerProvider);
+  }
+  endpoint() {
+    return "auth";
+  }
+  /**
+   * Invalidate a refresh token.
+   *
+   * @param oldToken - Token to be invalidated
+   *
+   * @virtual
+   * */
+  async signOut(oldToken) {
+    return await this.postRequest("/signOut", oldToken);
+  }
+  /**
+   * Gets all api tokens for the user.
+   *
+   * */
+  async getApiTokens() {
+    return await this.getRequest(`/apiTokens`);
+  }
+  /**
+   * Creates an api token.
+   *
+   * @param newToken - Emergency details for the new emergency
+   * @returns The newly-created api token
+   *
+   * @virtual
+   * */
+  async createApiToken(newToken) {
+    return await this.postRequest("/apiTokens", {
+      name: newToken.name,
+      expirationDate: newToken.expirationDate?.toISOString()
+    });
+  }
+  /**
+   * Delete an api token.
+   *
+   * @param id - The id of the api token to delete
+   *
+   * */
+  async deleteApiToken(id) {
+    return await this.deleteRequest(`/apiTokens/${id}`);
+  }
+};
+__name(AuthEndpoint, "AuthEndpoint");
+
+// src/api/endpoints/auth/TokenManager.ts
+var TokenManager = class extends ApiEndpoint {
+  constructor(config, refreshCallback, log, headerProvider) {
+    super(config.baseUrl, null, log, headerProvider);
+    this.refreshCallback = refreshCallback;
+    this.accessToken = config.accessToken;
+    this.refreshToken = config.refreshToken;
+  }
+  accessToken;
+  refreshToken;
+  endpoint() {
+    return "auth";
+  }
+  async getAccessToken() {
+    if (this.accessToken !== void 0) {
+      const exp = TokenManager.getJwtFromAccessToken(this.accessToken).exp;
+      if (exp > Date.now() / 1e3 - 60 * 5)
+        return this.accessToken;
+    }
+    if (this.refreshToken === void 0)
+      return this.accessToken;
+    const tokens = await this.fetchToken(this.refreshToken);
+    if (this.refreshCallback !== void 0) {
+      await this.refreshCallback(tokens);
+    }
+    this.accessToken = tokens.accessToken;
+    this.refreshToken = tokens.refreshToken;
+    return tokens.accessToken;
+  }
+  async fetchToken(refreshToken) {
+    const result = await this.postRequest("/exchange", { refreshToken }, true);
+    if (!result.success || result.data === void 0) {
+      throw Error(result.statusCode?.toString());
+    }
+    return result.data;
+  }
+  static getJwtFromAccessToken(accessToken) {
+    return JSON.parse(atob(accessToken.split(".")[1]));
+  }
+};
+__name(TokenManager, "TokenManager");
+
+// src/api/endpoints/chatMessage/ChatMessageEndpoint.ts
+var ChatMessageEndpoint = class extends ApiEndpoint {
+  constructor(baseUrl, tokenManager, log, headerProvider) {
+    super(baseUrl, tokenManager, log, headerProvider);
+  }
+  endpoint() {
+    return "chatMessage";
+  }
+  /**
+   * Gets the specified amount of chat messages for a given emergency.
+   *
+   * @param emergencyId - The emergency for which to fetch the chat history
+   * @param limit - The number of emergencies to get
+   * @param paginationToken - The number to use for pagination
+   * */
+  async getHistory(emergencyId, limit, paginationToken) {
+    return await this.getRequest(`/${emergencyId}`, { limit, paginationToken });
+  }
+  /**
+   * Sends a new chat message
+   *
+   * @param message - The message to send
+   * @returns The newly-created chat message
+   *
+   * */
+  async sendMessage(message) {
+    return await this.postRequest("", message);
+  }
+};
+__name(ChatMessageEndpoint, "ChatMessageEndpoint");
+
+// src/api/endpoints/client/ClientEndpoint.ts
+var ClientEndpoint = class extends ApiEndpoint {
+  constructor(baseUrl, tokenManager, log, headerProvider) {
+    super(baseUrl, tokenManager, log, headerProvider);
+  }
+  endpoint() {
+    return "client";
+  }
+  /**
+   * Gets the current client.
+   * */
+  async get() {
+    return await this.getRequest("");
+  }
+  /**
+   * Gets the specified amount of emergencies the client has created.
+   * @param limit - The number of emergencies to get
+   * @param paginationToken - The number to use for pagination
+   * */
+  async getHistory(limit, paginationToken) {
+    return await this.getRequest("/history", { limit, paginationToken });
+  }
+  /**
+   * Links the current user to a rsiHandle.
+   *
+   * @param rsiHandle - The RSI handle of the client
+   *
+   * */
+  async linkClient(rsiHandle) {
+    return await this.postRequest("/link", { rsiHandle });
+  }
+  /**
+   * Updates the settings of the current user for the Client Portal.
+   *
+   * @param settings - The object settings to add or update
+   * @returns The updated settings object
+   *
+   * */
+  async setSettings(settings) {
+    return await this.patchRequest("/settings/clientPortal", settings);
+  }
+};
+__name(ClientEndpoint, "ClientEndpoint");
+
+// src/api/endpoints/emergency/EmergencyEndpoint.ts
+var EmergencyEndpoint = class extends ApiEndpoint {
+  constructor(baseUrl, tokenManager, log, headerProvider) {
+    super(baseUrl, tokenManager, log, headerProvider);
+  }
+  endpoint() {
+    return "emergency";
+  }
+  /**
+   * Gets an emergency by id.
+   *
+   * @param id - The id of the emergency to retrieve
+   * */
+  async getEmergency(id) {
+    return await this.getRequest(`/${id}`);
+  }
+  /**
+   * Bulk fetches emergencies by id.
+   *
+   * @param ids - a list of emergencies to retrieve
+   * */
+  async getEmergencies(ids) {
+    return await this.getRequest(`/bulk?id=${ids.join("&id=")}`);
+  }
+  /**
+   * Creates a new emergency.
+   *
+   * @param newEmergency - Emergency details for the new emergency
+   * @returns The newly-created emergency
+   *
+   * @virtual
+   * */
+  async createEmergency(newEmergency) {
+    return await this.postRequest("create", newEmergency);
+  }
+  /**
+   * Cancels an existing emergency.
+   *
+   * @remarks
+   * Emergency must still be in the {@link MissionStatus.RECEIVED} state in order to be canceled.
+   *
+   * @param id - The id of the emergency to cancel
+   * @param reason - The reason the emergency was canceled
+   * */
+  async cancelEmergencyWithReason(id, reason) {
+    return await this.postRequest(`/${id}/cancelWithReason`, {
+      reason
+    });
+  }
+  /**
+   * Allows the client to rate their emergency.
+   *
+   * @param id - The id of the emergency to rate
+   * @param rating - The rating to give the services provided
+   * @param remarks - Additional remarks provided by the client
+   *
+   * @internal
+   * */
+  async rateServices(id, rating, remarks) {
+    return await this.postRequest(`/${id}/rate/`, {
+      rating,
+      remarks
+    });
+  }
+  /**
+   * Fetches additional details about the responding team for an alert.
+   *
+   * @param id - The id of the emergency to get team details about
+   * */
+  async teamDetails(id) {
+    return await this.getRequest(`/${id}/teamDetails`);
+  }
+  /**
+   * Gets a tree of valid locations from which an emergency may be submitted.
+   * */
+  async emergencyLocations() {
+    return await this.getRequest("/meta/locations");
+  }
+};
+__name(EmergencyEndpoint, "EmergencyEndpoint");
+
+// src/api/endpoints/staff/StaffEndpoint.ts
+var StaffEndpoint = class extends ApiEndpoint {
+  constructor(baseUrl, tokenManager, log, headerProvider) {
+    super(baseUrl, tokenManager, log, headerProvider);
+  }
+  endpoint() {
+    return "staff";
+  }
+  /**
+   * Gets detailed information about medals.
+   * */
+  async medalsInformation() {
+    return await this.getRequest("/meta/medals");
+  }
+};
+__name(StaffEndpoint, "StaffEndpoint");
+
+// src/api/endpoints/websocket/WebsocketManager.ts
+import { HubConnectionBuilder, LogLevel } from "@microsoft/signalr";
+var WebsocketManager = class {
+  constructor(baseUrl, tokenManager) {
+    this.baseUrl = baseUrl;
+    this.tokenManager = tokenManager;
+  }
+  tokenManager;
+  async establishConnection() {
+    return new HubConnectionBuilder().withAutomaticReconnect({
+      nextRetryDelayInMilliseconds: (retryContext) => retryContext.previousRetryCount > 5 ? null : 2e3
+    }).withUrl(`${this.baseUrl}/hub/emergency`, {
+      accessTokenFactory: async () => await this.tokenManager.getAccessToken() ?? ""
+    }).configureLogging(LogLevel.None).build();
+  }
+};
+__name(WebsocketManager, "WebsocketManager");
+
+// src/api/endpoints/websocket/WebsocketEndpoint.ts
+var WebsocketEndpoint = class extends ApiEndpoint {
+  constructor(baseUrl, tokenManager, log, headerProvider) {
+    super(baseUrl, tokenManager, log, headerProvider);
+  }
+  websocketManager = new WebsocketManager(this.baseUrl, this.tokenManager);
+  endpoint() {
+    return "websocket";
+  }
+  /**
+   * Gets realtime updates.
+   *
+   * */
+  async initialize() {
+    if (this.websocketManager === void 0) {
+      throw new Error("WebsocketManager is undefined");
+    }
+    return await this.websocketManager.establishConnection();
+  }
+};
+__name(WebsocketEndpoint, "WebsocketEndpoint");
+
+// src/api/MedrunnerApiClient.ts
+var MedrunnerApiClient = class {
+  constructor(emergency, client, staff, chatMessage, auth, websocket) {
+    this.emergency = emergency;
+    this.client = client;
+    this.staff = staff;
+    this.chatMessage = chatMessage;
+    this.auth = auth;
+    this.websocket = websocket;
+  }
+  /**
+   * Constructs a new API client.
+   *
+   * @param config - The API configuration
+   * @param refreshCallback - a callback function called whenever a refresh token exchange is performed
+   * @param log - A logger which logs request details
+   * */
+  static buildClient(config, refreshCallback, log) {
+    const tokenManager = new TokenManager(config, refreshCallback, log);
+    return new MedrunnerApiClient(
+      new EmergencyEndpoint(config.baseUrl, tokenManager, log),
+      new ClientEndpoint(config.baseUrl, tokenManager, log),
+      new StaffEndpoint(config.baseUrl, tokenManager, log),
+      new ChatMessageEndpoint(config.baseUrl, tokenManager, log),
+      new AuthEndpoint(config.baseUrl, tokenManager, log),
+      new WebsocketEndpoint(config.baseUrl, tokenManager, log)
+    );
+  }
+};
+__name(MedrunnerApiClient, "MedrunnerApiClient");
+
+// src/api/endpoints/emergency/response/LocationDetail.ts
+var LocationType = /* @__PURE__ */ ((LocationType2) => {
+  LocationType2[LocationType2["UNKNOWN"] = 0] = "UNKNOWN";
+  LocationType2[LocationType2["SYSTEM"] = 1] = "SYSTEM";
+  LocationType2[LocationType2["PLANET"] = 2] = "PLANET";
+  LocationType2[LocationType2["MOON"] = 3] = "MOON";
+  return LocationType2;
+})(LocationType || {});
+
+// src/models/CancellationReason.ts
+var CancellationReason = /* @__PURE__ */ ((CancellationReason2) => {
+  CancellationReason2[CancellationReason2["NONE"] = 0] = "NONE";
+  CancellationReason2[CancellationReason2["OTHER"] = 1] = "OTHER";
+  CancellationReason2[CancellationReason2["SUCCUMBED_TO_WOUNDS"] = 2] = "SUCCUMBED_TO_WOUNDS";
+  CancellationReason2[CancellationReason2["SERVER_ERROR"] = 3] = "SERVER_ERROR";
+  CancellationReason2[CancellationReason2["RESPAWNED"] = 4] = "RESPAWNED";
+  CancellationReason2[CancellationReason2["RESCUED"] = 5] = "RESCUED";
+  return CancellationReason2;
+})(CancellationReason || {});
+
+// src/models/Class.ts
+var Class = /* @__PURE__ */ ((Class2) => {
+  Class2[Class2["NONE"] = 0] = "NONE";
+  Class2[Class2["MEDIC"] = 1] = "MEDIC";
+  Class2[Class2["SECURITY"] = 2] = "SECURITY";
+  Class2[Class2["PILOT"] = 3] = "PILOT";
+  Class2[Class2["LEAD"] = 4] = "LEAD";
+  Class2[Class2["DISPATCH"] = 5] = "DISPATCH";
+  Class2[Class2["DISPATCH_LEAD"] = 6] = "DISPATCH_LEAD";
+  Class2[Class2["DISPATCH_TRAINEE"] = 7] = "DISPATCH_TRAINEE";
+  Class2[Class2["DISPATCH_OBSERVER"] = 8] = "DISPATCH_OBSERVER";
+  Class2[Class2["QRF"] = 9] = "QRF";
+  Class2[Class2["LOGISTICS"] = 10] = "LOGISTICS";
+  return Class2;
+})(Class || {});
+
+// src/models/Emergency.ts
+var MissionServices = /* @__PURE__ */ ((MissionServices2) => {
+  MissionServices2[MissionServices2["NONE"] = 0] = "NONE";
+  MissionServices2[MissionServices2["PVE"] = 1] = "PVE";
+  MissionServices2[MissionServices2["PVP"] = 2] = "PVP";
+  MissionServices2[MissionServices2["REVIVED_HEALED"] = 4] = "REVIVED_HEALED";
+  MissionServices2[MissionServices2["HEALED_IN_SHIP"] = 8] = "HEALED_IN_SHIP";
+  MissionServices2[MissionServices2["EXTRACT_SAFE_ZONE"] = 16] = "EXTRACT_SAFE_ZONE";
+  return MissionServices2;
+})(MissionServices || {});
+var Origin = /* @__PURE__ */ ((Origin2) => {
+  Origin2[Origin2["UNKNOWN"] = 0] = "UNKNOWN";
+  Origin2[Origin2["REPORT"] = 1] = "REPORT";
+  Origin2[Origin2["BEACON"] = 2] = "BEACON";
+  Origin2[Origin2["EVALUATION"] = 3] = "EVALUATION";
+  return Origin2;
+})(Origin || {});
+var SubmissionSource = /* @__PURE__ */ ((SubmissionSource2) => {
+  SubmissionSource2[SubmissionSource2["UNKNOWN"] = 0] = "UNKNOWN";
+  SubmissionSource2[SubmissionSource2["API"] = 1] = "API";
+  SubmissionSource2[SubmissionSource2["BOT"] = 2] = "BOT";
+  return SubmissionSource2;
+})(SubmissionSource || {});
+
+// src/models/MissionStatus.ts
+var MissionStatus = /* @__PURE__ */ ((MissionStatus2) => {
+  MissionStatus2[MissionStatus2["CREATED"] = 0] = "CREATED";
+  MissionStatus2[MissionStatus2["RECEIVED"] = 1] = "RECEIVED";
+  MissionStatus2[MissionStatus2["IN_PROGRESS"] = 2] = "IN_PROGRESS";
+  MissionStatus2[MissionStatus2["SUCCESS"] = 3] = "SUCCESS";
+  MissionStatus2[MissionStatus2["FAILED"] = 4] = "FAILED";
+  MissionStatus2[MissionStatus2["NO_CONTACT"] = 5] = "NO_CONTACT";
+  MissionStatus2[MissionStatus2["CANCELED"] = 6] = "CANCELED";
+  MissionStatus2[MissionStatus2["REFUSED"] = 7] = "REFUSED";
+  MissionStatus2[MissionStatus2["ABORTED"] = 8] = "ABORTED";
+  MissionStatus2[MissionStatus2["SERVER_ERROR"] = 9] = "SERVER_ERROR";
+  return MissionStatus2;
+})(MissionStatus || {});
+
+// src/models/Person.ts
+var UserRoles = /* @__PURE__ */ ((UserRoles2) => {
+  UserRoles2[UserRoles2["CLIENT"] = 1] = "CLIENT";
+  UserRoles2[UserRoles2["STAFF"] = 2] = "STAFF";
+  UserRoles2[UserRoles2["DEVELOPER"] = 524288] = "DEVELOPER";
+  UserRoles2[UserRoles2["BOT"] = 1048576] = "BOT";
+  return UserRoles2;
+})(UserRoles || {});
+var PersonType = /* @__PURE__ */ ((PersonType2) => {
+  PersonType2[PersonType2["CLIENT"] = 0] = "CLIENT";
+  PersonType2[PersonType2["STAFF"] = 1] = "STAFF";
+  PersonType2[PersonType2["BOT"] = 2] = "BOT";
+  return PersonType2;
+})(PersonType || {});
+var AccountDeactivationReason = /* @__PURE__ */ ((AccountDeactivationReason2) => {
+  AccountDeactivationReason2[AccountDeactivationReason2["NONE"] = 0] = "NONE";
+  AccountDeactivationReason2[AccountDeactivationReason2["CLIENT_DRIVEN_DELETION"] = 1] = "CLIENT_DRIVEN_DELETION";
+  AccountDeactivationReason2[AccountDeactivationReason2["TERMINATED"] = 2] = "TERMINATED";
+  AccountDeactivationReason2[AccountDeactivationReason2["BLOCKED"] = 3] = "BLOCKED";
+  return AccountDeactivationReason2;
+})(AccountDeactivationReason || {});
+
+// src/models/Level.ts
+var Level = /* @__PURE__ */ ((Level2) => {
+  Level2[Level2["None"] = 0] = "None";
+  Level2[Level2["Tier1Section1"] = 101] = "Tier1Section1";
+  Level2[Level2["Tier1Section2"] = 102] = "Tier1Section2";
+  Level2[Level2["Tier1Section3"] = 103] = "Tier1Section3";
+  Level2[Level2["Tier2Section1"] = 201] = "Tier2Section1";
+  Level2[Level2["Tier2Section2"] = 202] = "Tier2Section2";
+  Level2[Level2["Tier2Section3"] = 203] = "Tier2Section3";
+  Level2[Level2["Tier3Section1"] = 301] = "Tier3Section1";
+  Level2[Level2["Tier3Section2"] = 302] = "Tier3Section2";
+  Level2[Level2["Tier3Section3"] = 303] = "Tier3Section3";
+  Level2[Level2["Tier4Section1"] = 401] = "Tier4Section1";
+  Level2[Level2["Tier4Section2"] = 402] = "Tier4Section2";
+  Level2[Level2["Tier4Section3"] = 403] = "Tier4Section3";
+  Level2[Level2["Tier5Section1"] = 501] = "Tier5Section1";
+  Level2[Level2["Tier5Section2"] = 502] = "Tier5Section2";
+  Level2[Level2["Tier5Section3"] = 503] = "Tier5Section3";
+  Level2[Level2["Tier6Section1"] = 601] = "Tier6Section1";
+  Level2[Level2["Tier6Section2"] = 602] = "Tier6Section2";
+  Level2[Level2["Tier6Section3"] = 603] = "Tier6Section3";
+  Level2[Level2["Tier7Section1"] = 701] = "Tier7Section1";
+  Level2[Level2["Tier7Section2"] = 702] = "Tier7Section2";
+  Level2[Level2["Tier7Section3"] = 703] = "Tier7Section3";
+  Level2[Level2["Tier8Section1"] = 801] = "Tier8Section1";
+  Level2[Level2["Tier8Section2"] = 802] = "Tier8Section2";
+  Level2[Level2["Tier8Section3"] = 803] = "Tier8Section3";
+  Level2[Level2["Tier9Section1"] = 901] = "Tier9Section1";
+  Level2[Level2["Tier9Section2"] = 902] = "Tier9Section2";
+  Level2[Level2["Tier9Section3"] = 903] = "Tier9Section3";
+  Level2[Level2["Tier10Section1"] = 1001] = "Tier10Section1";
+  Level2[Level2["Tier10Section2"] = 1002] = "Tier10Section2";
+  Level2[Level2["Tier10Section3"] = 1003] = "Tier10Section3";
+  return Level2;
+})(Level || {});
+
+// src/models/ResponseRating.ts
+var ResponseRating = /* @__PURE__ */ ((ResponseRating2) => {
+  ResponseRating2[ResponseRating2["NONE"] = 0] = "NONE";
+  ResponseRating2[ResponseRating2["GOOD"] = 1] = "GOOD";
+  ResponseRating2[ResponseRating2["BAD"] = 2] = "BAD";
+  return ResponseRating2;
+})(ResponseRating || {});
+
+// src/models/ThreatLevel.ts
+var ThreatLevel = /* @__PURE__ */ ((ThreatLevel2) => {
+  ThreatLevel2[ThreatLevel2["UNKNOWN"] = 0] = "UNKNOWN";
+  ThreatLevel2[ThreatLevel2["LOW"] = 1] = "LOW";
+  ThreatLevel2[ThreatLevel2["MEDIUM"] = 2] = "MEDIUM";
+  ThreatLevel2[ThreatLevel2["HIGH"] = 3] = "HIGH";
+  return ThreatLevel2;
+})(ThreatLevel || {});
+export {
+  AccountDeactivationReason,
+  ApiEndpoint,
+  AuthEndpoint,
+  CancellationReason,
+  ChatMessageEndpoint,
+  Class,
+  ClientEndpoint,
+  EmergencyEndpoint,
+  Level,
+  LocationType,
+  MedrunnerApiClient,
+  MissionServices,
+  MissionStatus,
+  Origin,
+  PersonType,
+  ResponseRating,
+  StaffEndpoint,
+  SubmissionSource,
+  ThreatLevel,
+  TokenManager,
+  UserRoles,
+  WebsocketEndpoint
+};
+//# sourceMappingURL=index.mjs.map