emissions-api-sdk 1.0.0 → 1.0.1

package/src/api/Mobile.ts

@@ -1,5 +1,5 @@
 import { makeApiRequest } from "../request";
-import { MOBILE_API_PATH, POST } from "../Constants";
+import { GET, MOBILE_API_AREA, MOBILE_API_PATH, MOBILE_API_TYPES, MOBILE_API_UNITS, POST } from "../Constants";
 import { CommonRequest } from "../interfaces/Api";
 import { Client } from "../Client";
 
@@ -43,3 +43,77 @@ export async function calculate(
     data: payload,
   });
 }
+
+
+/**
+ * Retrieves available mobile emission calculation types by making a GET request to the API endpoint.
+ *
+ * @export
+ * @return {Promise<string>} A promise that resolves to a string containing the available mobile emission types
+ * @throws {Error} May throw an error if the API request fails
+ *
+ * @example
+ * // Get all available mobile emission types
+ * const types = await getTypes();
+ * const typesData = JSON.parse(types);
+ * console.log("Available mobile emission types:", typesData);
+ */
+export async function getTypes(
+): Promise<string> {
+  const client = Client.getInstance();
+  const url = client.getDomain() + MOBILE_API_TYPES;
+
+  return makeApiRequest<string>({
+    method: GET,
+    url
+  });
+}
+
+/**
+ * Retrieves information about geographical areas supported by the mobile emissions API.
+ *
+ * @export
+ * @return {Promise<string>} A promise that resolves to a string containing the supported geographical areas
+ * @throws {Error} May throw an error if the API request fails
+ *
+ * @example
+ * const areas = await getArea();
+ */
+export async function getArea(
+): Promise<string> {
+  const client = Client.getInstance();
+  const url = client.getDomain() + MOBILE_API_AREA;
+
+  return makeApiRequest<string>({
+    method: GET,
+    url
+  });
+}
+
+/**
+ * Retrieves available units for a specific mobile emission type.
+ *
+ * @export
+ * @param {string} type - The mobile emission type to get units for (e.g., "Diesel Fuel")
+ * @return {Promise<string>} A promise that resolves to a string containing the available units
+ * @throws {Error} May throw an error if the API request fails
+ *
+ * @example
+ * Get units for the "Cars:B20:(NE)" emission mobile type with subtype
+ * const units = await getUnits("Cars:B20:(NE)");
+
+ * Get units for the "Cars by Size - Large Car - Hybrid" emission mobile type without subtype
+ * const units = await getUnits("Cars by Size - Large Car - Hybrid");
+ */
+export async function getUnits(
+  type : string
+): Promise<string> {
+  const client = Client.getInstance();
+  const url = client.getDomain() + MOBILE_API_UNITS;
+
+  return makeApiRequest<string>({
+    method: GET,
+    url,
+    params : { type }
+  });
+}

package/src/api/Stationary.ts

@@ -1,5 +1,5 @@
 import { Client } from "../Client";
-import { POST, STATIONARY_API_PATH } from "../Constants";
+import { GET, POST, STATIONARY_API_AREA, STATIONARY_API_PATH, STATIONARY_API_TYPES, STATIONARY_API_UNITS } from "../Constants";
 import { CommonRequest } from "../interfaces/Api";
 import { makeApiRequest } from "../request";
 
@@ -14,20 +14,20 @@ import { makeApiRequest } from "../request";
  * 
  * @example
  * const request = {
-             "time" : {
-                "date": "2025-01-04"
-            },
-            "location": {
-                "country": "usa",
-								"stateProvince": "new york"
-            },
-            "activity": {
-							"type":"Coal - Lignite",
-							"unit": "KJ",
-							"value": 3
-            },
-            "includeDetails": true
-      };
+    "time" : {
+      "date": "2025-01-04"
+    },
+    "location": {
+      "country": "usa",
+      "stateProvince": "new york"
+    },
+    "activity": {
+      "type":"Coal - Lignite",
+      "unit": "KJ",
+      "value": 3
+    },
+    "includeDetails": true
+  };
  * const result = await calculate(request);
  */
 
@@ -43,3 +43,73 @@ export async function calculate(
     data: payload,
   });
 }
+
+/**
+ * Retrieves available stationary emission calculation types by making a GET request to the API endpoint.
+ *
+ * @export
+ * @return {Promise<string>} A promise that resolves to a string containing the available stationary emission types
+ * @throws {Error} May throw an error if the API request fails
+ *
+ * @example
+ * const types = await getTypes();
+ */
+export async function getTypes(
+): Promise<string> {
+  const client = Client.getInstance();
+  const url = client.getDomain() + STATIONARY_API_TYPES;
+
+  return makeApiRequest<string>({
+    method: GET,
+    url
+  });
+}
+
+/**
+ * Retrieves information about geographical areas supported by the stationary emissions API.
+ *
+ * @export
+ * @return {Promise<string>} A promise that resolves to a string containing the supported geographical areas
+ * @throws {Error} May throw an error if the API request fails
+ *
+ * @example
+ * const areas = await getArea();
+ */
+export async function getArea(
+): Promise<string> {
+  const client = Client.getInstance();
+  const url = client.getDomain() + STATIONARY_API_AREA;
+
+  return makeApiRequest<string>({
+    method: GET,
+    url
+  });
+}
+
+/**
+ * Retrieves available units for a specific stationary emission type.
+ *
+ * @export
+ * @param {string} type - The stationary emission type to get units for (e.g., "Coal - Lignite")
+ * @return {Promise<string>} A promise that resolves to a string containing the available units
+ * @throws {Error} May throw an error if the API request fails
+ *
+ * @example
+ * Get units for the "Petroleum Based Greases - NC:A" emission stationary type with subtype
+ * const units = await getUnits("Petroleum Based Greases - NC:A");
+
+ * Get units for the "Jet Kerosene" emission stationary type without subtype
+ * const units = await getUnits("Jet Kerosene");
+ */
+export async function getUnits(
+  type : string
+): Promise<string> {
+  const client = Client.getInstance();
+  const url = client.getDomain() + STATIONARY_API_UNITS;
+
+  return makeApiRequest<string>({
+    method: GET,
+    url,
+    params : { type }
+  });
+}

package/src/api/TransportationAndDistribution.ts

@@ -1,5 +1,5 @@
 import { Client } from "../Client";
-import { TRANSPORTATION_AND_DISTRIBUTION_API_PATH, POST } from "../Constants";
+import { TRANSPORTATION_AND_DISTRIBUTION_API_PATH, POST, TRANSPORTATION_AND_DISTRIBUTION_API_TYPES, GET, TRANSPORTATION_AND_DISTRIBUTION_API_AREA, TRANSPORTATION_AND_DISTRIBUTION_API_UNITS } from "../Constants";
 import { CalculationRequest } from "../interfaces/Api";
 import { makeApiRequest } from "../request";
 
@@ -13,18 +13,18 @@ import { makeApiRequest } from "../request";
  * 
  * @example
  * const request = {
-             "time" : {
-                "date": "2025-01-04"
-            },
-            "location": {
-                "country": "usa"
-            },
-            "activity": {
-            	"type": "Freight - Cargo Ship - Bulk Carrier - 0-9999 dwt",
-							"unit": ["t","km"],
-							"value": [1.0,1.0]
-            },
-            "includeDetails": true
+    "time" : {
+      "date": "2025-01-04"
+    },
+    "location": {
+      "country": "usa"
+    },
+    "activity": {
+      "type": "Freight - Cargo Ship - Bulk Carrier - 0-9999 dwt",
+      "unit": ["t","km"],
+      "value": [1.0,1.0]
+    },
+    "includeDetails": true
   };
  * const result = await calculate(request);
  */
@@ -40,3 +40,74 @@ export async function calculate(
     data: payload,
   });
 }
+
+
+/**
+ * Retrieves available transportation and distribution calculation types by making a GET request to the API endpoint.
+ *
+ * @export
+ * @return {Promise<string>} A promise that resolves to a string containing the available transportation and distribution calculation types
+ * @throws {Error} May throw an error if the API request fails
+ *
+ * @example
+ * const types = await getTypes();
+ */
+export async function getTypes(
+): Promise<string> {
+  const client = Client.getInstance();
+  const url = client.getDomain() + TRANSPORTATION_AND_DISTRIBUTION_API_TYPES;
+
+  return makeApiRequest<string>({
+    method: GET,
+    url
+  });
+}
+
+/**
+ * Retrieves information about geographical areas supported by the transportation and distribution API.
+ *
+ * @export
+ * @return {Promise<string>} A promise that resolves to a string containing the supported geographical areas
+ * @throws {Error} May throw an error if the API request fails
+ *
+ * @example
+ * const areas = await getArea();
+ */
+export async function getArea(
+): Promise<string> {
+  const client = Client.getInstance();
+  const url = client.getDomain() + TRANSPORTATION_AND_DISTRIBUTION_API_AREA;
+
+  return makeApiRequest<string>({
+    method: GET,
+    url
+  });
+}
+
+/**
+ * Retrieves available units for a specific transportation and distribution calculation type.
+ *
+ * @export
+ * @param {string} type - The transportation and distribution calculation type to get units for (e.g., "Freight - Cargo Ship")
+ * @return {Promise<string>} A promise that resolves to a string containing the available units
+ * @throws {Error} May throw an error if the API request fails
+ *
+ * @example
+ * // Get units for the "Business Travel - Cars:Diesel - Small" transportation and distribution type without subtype
+ * const units = await getUnits("Business Travel - Cars:Diesel - Small");
+ * 
+ * // Get units for the "Business Travel - Cars" transportation and distribution type with subtype
+ * const units = await getUnits("Business Travel - Cars");
+ */
+export async function getUnits(
+  type : string
+): Promise<string> {
+  const client = Client.getInstance();
+  const url = client.getDomain() + TRANSPORTATION_AND_DISTRIBUTION_API_UNITS;
+
+  return makeApiRequest<string>({
+    method: GET,
+    url,
+    params : { type }
+  });
+}

package/test/apiTest.test.ts

@@ -18,6 +18,28 @@ import {
   FACTOR_API_PATH,
   FACTOR_SET_API_PATH,
   SEARCH_API_PATH,
+  LOCATION_TYPES,
+  FUGITIVE_API_TYPES,
+  MOBILE_API_TYPES,
+  STATIONARY_API_TYPES,
+  CALCULATION_TYPES,
+  FACTOR_API_TYPES,
+  TRANSPORTATION_AND_DISTRIBUTION_API_TYPES,
+  LOCATION_API_AREA,
+  FUGITIVE_API_AREA,
+  MOBILE_API_AREA,
+  STATIONARY_API_AREA,
+  GENERAL_API_AREA,
+  FACTOR_API_AREA,
+  TRANSPORTATION_AND_DISTRIBUTION_API_AREA,
+  LOCATION_API_UNITS,
+  SEARCH_API_AREA,
+  FUGITIVE_API_UNITS,
+  MOBILE_API_UNITS,
+  STATIONARY_API_UNITS,
+  GENERAL_API_UNITS,
+  FACTOR_API_UNITS,
+  TRANSPORTATION_AND_DISTRIBUTION_API_UNITS,
 } from "../src/Constants";
 import locationPayload from "./mocks/LocationRequest";
 import commonpayload from "./mocks/CommonRequest";
@@ -32,6 +54,7 @@ type ApiTestCase = {
   path: string;
   payload?: any;
   pathParams?: string | string[];
+  queryParams?: Record<string, string>;
   method: "GET" | "POST";
 };
 
@@ -100,6 +123,145 @@ const testCases: ApiTestCase[] = [
     payload: SearchPayload,
     method: "POST",
   },
+  {
+    name: "Location API - getTypes",
+    func: locationApi.getTypes,
+    path: LOCATION_TYPES,
+    method: "GET",
+  },
+  {
+    name: "Fugitive API - getTypes",
+    func: fugitiveApi.getTypes,
+    path: FUGITIVE_API_TYPES,
+    method: "GET",
+  },
+  {
+    name: "Mobile API - getTypes",
+    func: mobileApi.getTypes,
+    path: MOBILE_API_TYPES,
+    method: "GET",
+  },
+  {
+    name: "Stationary API - getTypes",
+    func: stationaryApi.getTypes,
+    path: STATIONARY_API_TYPES,
+    method: "GET",
+  },
+  {
+    name: "GenericCalculation API - getTypes",
+    func: GenericCalculation.getTypes,
+    path: CALCULATION_TYPES,
+    method: "GET",
+  },
+  {
+    name: "Factor API - getTypes",
+    func: Factors.getTypes,
+    path: FACTOR_API_TYPES,
+    method: "GET",
+  },
+  {
+    name: "Transportation and Distribution API - getTypes",
+    func: TransportationDistributionApi.getTypes,
+    path: TRANSPORTATION_AND_DISTRIBUTION_API_TYPES,
+    method: "GET",
+  },
+  {
+    name: "Location API - getArea",
+    func: locationApi.getArea,
+    path: LOCATION_API_AREA,
+    method: "GET",
+  },
+  {
+    name: "Fugitive API - getArea",
+    func: fugitiveApi.getArea,
+    path: FUGITIVE_API_AREA,
+    method: "GET",
+  },
+  {
+    name: "Mobile API - getArea",
+    func: mobileApi.getArea,
+    path: MOBILE_API_AREA,
+    method: "GET",
+  },
+  {
+    name: "Stationary API - getArea",
+    func: stationaryApi.getArea,
+    path: STATIONARY_API_AREA,
+    method: "GET",
+  },
+  {
+    name: "GenericCalculation API - getArea",
+    func: GenericCalculation.getArea,
+    path: GENERAL_API_AREA,
+    method: "GET",
+  },
+  {
+    name: "Factor API - getArea",
+    func: Factors.getArea,
+    path: FACTOR_API_AREA,
+    method: "GET",
+  },
+  {
+    name: "Factor SEARCH API - getArea",
+    func: Factors.getSearchArea,
+    path: SEARCH_API_AREA,
+    method: "GET",
+  },
+  {
+    name: "Transportation and Distribution API - getArea",
+    func: TransportationDistributionApi.getArea,
+    path: TRANSPORTATION_AND_DISTRIBUTION_API_AREA,
+    method: "GET",
+  },
+  {
+    name: "Location API - getUnits",
+    func: locationApi.getUnits,
+    path: LOCATION_API_UNITS,
+    queryParams: { type: "electricity" },
+    method: "GET",
+  },
+  {
+    name: "Fugitive API - getUnits",
+    func: fugitiveApi.getUnits,
+    path: FUGITIVE_API_UNITS,
+    queryParams: { type: "Natural Gas - Scope 3:AAA" },
+    method: "GET",
+  },
+  {
+    name: "Mobile API - getUnits",
+    func: mobileApi.getUnits,
+    path: MOBILE_API_UNITS,
+    queryParams: { type: "Cars:B20:(NE)" },
+    method: "GET",
+  },
+  {
+    name: "Stationary API - getUnits",
+    func: stationaryApi.getUnits,
+    path: STATIONARY_API_UNITS,
+    queryParams: { type: "Jet Kerosene" },
+    method: "GET",
+  },
+  {
+    name: "GenericCalculation API - getUnits",
+    func: GenericCalculation.getUnits,
+    path: GENERAL_API_UNITS,
+    queryParams: { type: "Natural Gas - Scope 3:AAA" },
+    method: "GET",
+  },
+  {
+    name: "Factor API - getUnits",
+    func: Factors.getUnits,
+    path: FACTOR_API_UNITS,
+    queryParams: { type: "HFC-263fb" },
+    method: "GET",
+  },
+  {
+    name: "Transportation and Distribution API - getUnits",
+    func: TransportationDistributionApi.getUnits,
+    path: TRANSPORTATION_AND_DISTRIBUTION_API_UNITS,
+    queryParams: { type: "Business Travel - Cars:Diesel - Small" },
+    method: "GET",
+  },
 ];
 
 describe("API Test calculate functions", () => {
@@ -132,16 +294,20 @@ describe("API Test calculate functions", () => {
   });
   describe.each(testCases)(
     "$name",
-    ({ func, path, payload, pathParams, method }) => {
+    ({ func, path, payload, pathParams, queryParams, method }) => {
       it("Should call makeApiRequest with API url", async () => {
         let result;
         if (method === "POST") {
           result = await func(payload);
         } else {
-          result =
-            pathParams !== undefined
-              ? await func(pathParams)
-              : await func();
+          // For GET requests with queryParams, pass the type value
+          if (queryParams) {
+            result = await func(queryParams.type);
+          } else if (pathParams !== undefined) {
+            result = await func(pathParams);
+          } else {
+            result = await func();
+          }
         }
         const clientDomain = Client.getInstance().getDomain();
 
@@ -160,6 +326,7 @@ describe("API Test calculate functions", () => {
           url: expectedUrl,
         };
         if (method === "POST") expectedRequest.data = payload;
+        if (method === "GET" && queryParams) expectedRequest.params = queryParams;
         expect(spy).toHaveBeenCalledWith(expectedRequest);
         expect(result).toBe(mockResp);
       });

package/dist/api/Factors.js

@@ -1,98 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.retrieveFactor = retrieveFactor;
-exports.getFactorSets = getFactorSets;
-exports.Search = Search;
-const Client_1 = require("../Client");
-const Constants_1 = require("../Constants");
-const request_1 = require("../request");
-/**
- * Retrieves a factor details by making a POST request to the factor API endpoint.
- *
- * @export
- * @param {FactorRequest} payload - The factor request data to be sent to the API
- * @return {Promise<string>} A promise that resolves to the factor string returned by the API
- * @throws {Error} May throw an error if the API request fails
- *
- * @example
- * const factorRequest = {
-    
-    "activity": {
-         "factorId": 12345
-    }
-  };
-  
-  or
-
-  const factorRequest = {
-             "time" : {
-                "date": "2025-01-04"
-            },
-            "location": {
-                "country": "usa",
-                                "stateProvince": "new york"
-            },
-            "activity": {
-                            "type":"natural gas"
-            },
-            "includeDetails": true
-        };
- * const factor = await retrieveFactor(factorRequest);
- */
-async function retrieveFactor(payload) {
-    const client = Client_1.Client.getInstance();
-    const url = client.getDomain() + Constants_1.FACTOR_API_PATH;
-    return (0, request_1.makeApiRequest)({
-        method: Constants_1.POST,
-        url,
-        data: payload,
-    });
-}
-/**
- * Retrieves factor sets by making a GET request to the factor set API endpoint.
- *
- * @export
- * @return {Promise<string>} A promise that resolves to the factor sets string returned by the API
- * @throws {Error} May throw an error if the API request fails
- *
- * @example
- * const factorSets = await getFactorSets();
- */
-async function getFactorSets() {
-    const client = Client_1.Client.getInstance();
-    const url = client.getDomain() + Constants_1.FACTOR_SET_API_PATH;
-    return (0, request_1.makeApiRequest)({
-        method: Constants_1.GET,
-        url
-    });
-}
-/**
- * Performs a search operation by making a POST request to the search API endpoint.
- *
- * @export
- * @param {SearchRequest} payload - The search request data to be sent to the API
- * @return {Promise<string>} A promise that resolves to the search results string returned by the API
- * @throws {Error} May throw an error if the API request fails
- *
- * @example
- * const searchRequest = {
-    "time":{
-      "date": "2020-06-10"
-    },
-    "activity": {
-      "search" : "travel"},
-  "location": {
-      "country": "USA"
-    }
-  };
- * const results = await Search(searchRequest);
- */
-async function Search(payload) {
-    const client = Client_1.Client.getInstance();
-    const url = client.getDomain() + Constants_1.SEARCH_API_PATH;
-    return (0, request_1.makeApiRequest)({
-        method: Constants_1.POST,
-        url,
-        data: payload,
-    });
-}

package/dist/api/FugitiveEmission.js

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculate = calculate;
-const Client_1 = require("../Client");
-const Constants_1 = require("../Constants");
-const request_1 = require("../request");
-/**
- * Performs scope 1 fugitve emission calculations by making a POST request to the fugitive API endpoint.
- *
- * @export
- * @param {CommonRequest} payload - The request data to be sent to the API
- * @return {Promise<string>} A promise that resolves to the calculation result string returned by the API
- * @throws {Error} May throw an error if the API request fails
- *
- * @example
- * const request = {
-      "time": {
-        "date": "2025-01-04"
-      },
-      "location": {
-        "country": "usa"
-      },
-      "activity": {
-        "type": "R134A",
-        "value": 150,
-        "unit": "kg"
-      },
-      "includeDetails": false
-  };
- * const result = await calculate(request);
- */
-async function calculate(payload) {
-    const client = Client_1.Client.getInstance();
-    const url = client.getDomain() + Constants_1.FUGITIVE_API_PATH;
-    return (0, request_1.makeApiRequest)({
-        method: Constants_1.POST,
-        url,
-        data: payload,
-    });
-}