emissions-api-sdk 1.0.0 → 1.0.2

package/dist/types/api/Calculation.d.ts

@@ -1,28 +1,71 @@
 import { CalculationRequest } from "../interfaces/Api";
+import { AreaResponse } from "../interfaces/response/AreaResponse";
+import { EmissionResponse } from "../interfaces/response/EmissionResponse";
+import { EmissionResponseWithDetails } from "../interfaces/response/EmissionResponseWithDetails";
+import { TypeResponse } from "../interfaces/response/TypeResponse";
+import { UnitResponse } from "../interfaces/response/UnitResponse";
 /**
  * Performs emission calculations by making a POST request to the generic calculation API endpoint.
  *
  * @export
  * @param {CalculationRequest} payload - The calculation request data to be sent to the API
- * @return {Promise<string>} A promise that resolves to the calculation result string returned by the API
+ * @return {Promise<EmissionResponse | EmissionResponseWithDetails>} A promise that resolves to the emission calculation result. Returns EmissionResponseWithDetails if includeDetails is true, otherwise EmissionResponse
  * @throws {Error} May throw an error if the API request fails
  *
  * @example
  * const calculationRequest = {
-             "time" : {
-                "date": "2025-01-04"
-            },
-            "location": {
-                "country": "usa",
-                                "stateProvince": "new york"
-            },
-            "activity": {
-                            "type":"Waste Combusted - Steel Cans:Default factor",
-                            "unit": "kg",
-                            "value": 1223123.121
-            },
-            "includeDetails": true
-        };
+    "time" : {
+      "date": "2025-01-04"
+    },
+    "location": {
+      "country": "usa",
+      "stateProvince": "new york"
+    },
+    "activity": {
+      "type":"Waste Combusted - Steel Cans:Default factor",
+      "unit": "kg",
+      "value": 1223123.121
+    },
+    "includeDetails": true
+  };
  * const result = await calculate(calculationRequest);
  */
-export declare function calculate(payload: CalculationRequest): Promise<string>;
+export declare function calculate(payload: CalculationRequest): Promise<EmissionResponse | EmissionResponseWithDetails>;
+/**
+ * Retrieves available calculation types by making a GET request to the calculation types API endpoint.
+ *
+ * @export
+ * @return {Promise<TypeResponse>} A promise that resolves to a TypeResponse containing the available calculation types
+ * @throws {Error} May throw an error if the API request fails
+ *
+ * @example
+ * const types = await getTypes();
+ */
+export declare function getTypes(): Promise<TypeResponse>;
+/**
+ * Retrieves information about geographical areas supported by the calculation API.
+ *
+ * @export
+ * @return {Promise<AreaResponse>} A promise that resolves to an AreaResponse containing the supported geographical areas
+ * @throws {Error} May throw an error if the API request fails
+ *
+ * @example
+ * const areas = await getArea();
+ */
+export declare function getArea(): Promise<AreaResponse>;
+/**
+ * Retrieves available units for a specific calculation type.
+ *
+ * @export
+ * @param {string} type - The calculation type to get units for
+ * @return {Promise<UnitResponse>} A promise that resolves to a UnitResponse containing the available units
+ * @throws {Error} May throw an error if the API request fails
+ *
+ * @example
+ * // Get units for the "Natural Gas - Scope 3:AAA" emission calculation type with subtype
+ * const units = await getUnits("Natural Gas - Scope 3:AAA");
+
+ * // Get units for the "HFC-263fb" emission calculation type without subtype
+ * const units = await getUnits("HFC-263fb");
+ */
+export declare function getUnits(type: string): Promise<UnitResponse>;

package/dist/types/api/Factor.d.ts

@@ -1,44 +1,48 @@
 import { FactorRequest, SearchRequest } from "../interfaces/Api";
+import { AreaResponse } from "../interfaces/response/AreaResponse";
+import { FactorResponse } from "../interfaces/response/FactorResponse";
+import { SearchResponse } from "../interfaces/response/SearchResponse";
+import { TypeResponse } from "../interfaces/response/TypeResponse";
+import { UnitResponse } from "../interfaces/response/UnitResponse";
 /**
  * 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
+ * @return {Promise<FactorResponse>} A promise that resolves to the FactorResponse returned by the API
  * @throws {Error} May throw an error if the API request fails
  *
  * @example
  * const factorRequest = {
-    
     "activity": {
-         "factorId": 12345
+      "factorId": 12345
     }
   };
   
-  or
+  OR
 
   const factorRequest = {
-             "time" : {
-                "date": "2025-01-04"
-            },
-            "location": {
-                "country": "usa",
-                                "stateProvince": "new york"
-            },
-            "activity": {
-                            "type":"natural gas"
-            },
-            "includeDetails": true
-        };
+    "time" : {
+      "date": "2025-01-04"
+    },
+    "location": {
+      "country": "usa",
+      "stateProvince": "new york"
+    },
+    "activity": {
+      "type":"natural gas"
+    },
+    "includeDetails": true
+  };
  * const factor = await retrieveFactor(factorRequest);
  */
-export declare function retrieveFactor(payload: FactorRequest): Promise<string>;
+export declare function retrieveFactor(payload: FactorRequest): Promise<FactorResponse>;
 /**
  * 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
+ * @return {Promise<SearchResponse>} A promise that resolves to the search results returned by the API
  * @throws {Error} May throw an error if the API request fails
  *
  * @example
@@ -48,10 +52,59 @@ export declare function retrieveFactor(payload: FactorRequest): Promise<string>;
     },
     "activity": {
       "search" : "travel"},
-  "location": {
+    "location": {
       "country": "USA"
     }
   };
  * const results = await search(searchRequest);
  */
-export declare function search(payload: SearchRequest): Promise<string>;
+export declare function search(payload: SearchRequest): Promise<SearchResponse>;
+/**
+ * Retrieves available emission factor types by making a GET request to the API endpoint.
+ *
+ * @export
+ * @return {Promise<TypeResponse>} A promise that resolves to a TypeResponse containing the available emission factor types
+ * @throws {Error} May throw an error if the API request fails
+ *
+ * @example
+ * const types = await getTypes();
+ */
+export declare function getTypes(): Promise<TypeResponse>;
+/**
+ * Retrieves information about geographical areas supported by the factor search API.
+ *
+ * @export
+ * @return {Promise<AreaResponse>} A promise that resolves to an AreaResponse containing the supported geographical areas
+ * @throws {Error} May throw an error if the API request fails
+ *
+ * @example
+ * const areas = await getSearchArea();
+ */
+export declare function getSearchArea(): Promise<AreaResponse>;
+/**
+ * Retrieves information about geographical areas supported by the factor API.
+ *
+ * @export
+ * @return {Promise<AreaResponse>} A promise that resolves to an AreaResponse containing the supported geographical areas
+ * @throws {Error} May throw an error if the API request fails
+ *
+ * @example
+ * const areas = await getArea();
+ */
+export declare function getArea(): Promise<AreaResponse>;
+/**
+ * Retrieves available units for a specific emission factor type.
+ *
+ * @export
+ * @param {string} type - The emission factor type to get units for (e.g., "Natural Gas - Scope 3:AAA")
+ * @return {Promise<UnitResponse>} A promise that resolves to a UnitResponse containing the available units
+ * @throws {Error} May throw an error if the API request fails
+ *
+ * @example
+ * // Get units for the "Natural Gas - Scope 3:AAA" emission factor type with subtype
+ * const units = await getUnits("Natural Gas - Scope 3:AAA");
+
+ * // Get units for the "HFC-263fb" emission factor type without subtype
+ * const units = await getUnits("HFC-263fb");
+ */
+export declare function getUnits(type: string): Promise<UnitResponse>;

package/dist/types/api/FactorSets.d.ts

@@ -1,11 +1,12 @@
+import { FactorSetResponse } from "../interfaces/response/FactorSetResponse";
 /**
  * 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
+ * @return {Promise<FactorSetResponse>} A promise that resolves to the  FactorSetResponse returned by the API
  * @throws {Error} May throw an error if the API request fails
  *
  * @example
  * const factorSets = await get();
  */
-export declare function get(): Promise<string>;
+export declare function get(): Promise<FactorSetResponse>;

package/dist/types/api/Fugitive.d.ts

@@ -1,27 +1,70 @@
 import { CommonRequest } from "../interfaces/Api";
+import { AreaResponse } from "../interfaces/response/AreaResponse";
+import { EmissionResponse } from "../interfaces/response/EmissionResponse";
+import { EmissionResponseWithDetails } from "../interfaces/response/EmissionResponseWithDetails";
+import { TypeResponse } from "../interfaces/response/TypeResponse";
+import { UnitResponse } from "../interfaces/response/UnitResponse";
 /**
  * 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
+ * @return {Promise<EmissionResponse | EmissionResponseWithDetails>} A promise that resolves to the emission calculation result. Returns EmissionResponseWithDetails if includeDetails is true, otherwise EmissionResponse
  * @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
+    "time": {
+      "date": "2025-01-04"
+    },
+    "location": {
+      "country": "usa"
+    },
+    "activity": {
+      "type": "R134A",
+      "value": 150,
+      "unit": "kg"
+    },
+    "includeDetails": false
   };
  * const result = await calculate(request);
  */
-export declare function calculate(payload: CommonRequest): Promise<string>;
+export declare function calculate(payload: CommonRequest): Promise<EmissionResponse | EmissionResponseWithDetails>;
+/**
+ * Retrieves available fugitive emission calculation types by making a GET request to the API endpoint.
+ *
+ * @export
+ * @return {Promise<TypeResponse>} A promise that resolves to a TypeResponse containing the available fugitive emission types
+ * @throws {Error} May throw an error if the API request fails
+ *
+ * @example
+ * const types = await getTypes();
+ */
+export declare function getTypes(): Promise<TypeResponse>;
+/**
+ * Retrieves information about geographical areas supported by the fugitive emissions API.
+ *
+ * @export
+ * @return {Promise<AreaResponse>} A promise that resolves to an AreaResponse containing the supported geographical areas
+ * @throws {Error} May throw an error if the API request fails
+ *
+ * @example
+ * const areas = await getArea();
+ */
+export declare function getArea(): Promise<AreaResponse>;
+/**
+ * Retrieves available units for a specific fugitive emission type.
+ *
+ * @export
+ * @param {string} type - The fugitive emission type to get units for (e.g., "R134A")
+ * @return {Promise<UnitResponse>} A promise that resolves to a UnitResponse containing the available units
+ * @throws {Error} May throw an error if the API request fails
+ *
+ * @example
+ * // Get units for the "Natural Gas - Scope 3:AAA" emission fugitive type with subtype
+ * const units = await getUnits("Natural Gas - Scope 3:AAA");
+
+ * // Get units for the "R-426A" emission fugitive type without subtype
+ * const units = await getUnits("R-426A");
+ */
+export declare function getUnits(type: string): Promise<UnitResponse>;

package/dist/types/api/Location.d.ts

@@ -1,28 +1,69 @@
 import { LocationRequest } from "../interfaces/Api";
+import { AreaResponse } from "../interfaces/response/AreaResponse";
+import { EmissionResponse } from "../interfaces/response/EmissionResponse";
+import { EmissionResponseWithDetails } from "../interfaces/response/EmissionResponseWithDetails";
+import { TypeResponse } from "../interfaces/response/TypeResponse";
+import { UnitResponse } from "../interfaces/response/UnitResponse";
 /**
  * Performs scope 2 purchased energy Emission calculations by making a POST request to the location API endpoint.
  *
  * @export
  * @param {LocationRequest} payload - The location request data to be sent to the API
- * @return {Promise<string>} A promise that resolves to the purchased energy emission result string returned by the API
+ * @return {Promise<EmissionResponse | EmissionResponseWithDetails>} A promise that resolves to the emission calculation result. Returns EmissionResponseWithDetails if includeDetails is true, otherwise EmissionResponse
  * @throws {Error} May throw an error if the API request fails
  *
  * @example
  * const calculationRequest = {
-             "time" : {
-                "date": "2025-01-04"
-            },
-            "location": {
-                "country": "usa",
-                                "stateProvince": "new york"
-            },
-            "activity": {
-                            "type":"electricity",
-                            "unit": "kwh",
-                            "value": 14123143
-            },
-            "includeDetails": true
-        };
+    "time" : {
+      "date": "2025-01-04"
+    },
+    "location": {
+      "country": "usa",
+      "stateProvince": "new york"
+    },
+    "activity": {
+      "type":"electricity",
+      "unit": "kwh",
+      "value": 14123143
+    },
+    "includeDetails": true
+  };
  * const result = await calculate(calculationRequest);
  */
-export declare function calculate(payload: LocationRequest): Promise<string>;
+export declare function calculate(payload: LocationRequest): Promise<EmissionResponse | EmissionResponseWithDetails>;
+/**
+ * Retrieves available location-based calculation types by making a GET request to the location types API endpoint.
+ *
+ * @export
+ * @return {Promise<TypeResponse>} A promise that resolves to a TypeResponse containing the available location-based calculation types
+ * @throws {Error} May throw an error if the API request fails
+ *
+ * @example
+ *
+ * const types = await getTypes();
+ */
+export declare function getTypes(): Promise<TypeResponse>;
+/**
+ * Retrieves information about geographical areas supported by the location-based calculation API.
+ *
+ * @export
+ * @return {Promise<AreaResponse>} A promise that resolves to an AreaResponse containing the supported geographical areas
+ * @throws {Error} May throw an error if the API request fails
+ *
+ * @example
+ * const areas = await getArea();
+ */
+export declare function getArea(): Promise<AreaResponse>;
+/**
+ * Retrieves available units for a specific location-based calculation type.
+ *
+ * @export
+ * @param {string} type - The location-based calculation type to get units for (e.g., "electricity")
+ * @return {Promise<UnitResponse>} A promise that resolves to a UnitResponse containing the available units
+ * @throws {Error} May throw an error if the API request fails
+ *
+ * @example
+ * // Get units for the "electricity" location type
+ * const units = await getUnits("electricity");
+ */
+export declare function getUnits(type: string): Promise<UnitResponse>;

package/dist/types/api/Mobile.d.ts

@@ -1,10 +1,15 @@
 import { CommonRequest } from "../interfaces/Api";
+import { AreaResponse } from "../interfaces/response/AreaResponse";
+import { EmissionResponse } from "../interfaces/response/EmissionResponse";
+import { EmissionResponseWithDetails } from "../interfaces/response/EmissionResponseWithDetails";
+import { TypeResponse } from "../interfaces/response/TypeResponse";
+import { UnitResponse } from "../interfaces/response/UnitResponse";
 /**
  * Performs Scope 1 mobile emissions related calculations by making a POST request to the mobile API endpoint.
  *
  * @export
  * @param {CommonRequest} payload - The request data to be sent to the mobile API
- * @return {Promise<string>} A promise that resolves to the calculation result string returned by the API
+ * @return {Promise<EmissionResponse | EmissionResponseWithDetails>} A promise that resolves to the emission calculation result. Returns EmissionResponseWithDetails if includeDetails is true, otherwise EmissionResponse
  * @throws {Error} May throw an error if the API request fails
  *
  * @example
@@ -25,4 +30,43 @@ import { CommonRequest } from "../interfaces/Api";
   };
  * const result = await calculate(request);
  */
-export declare function calculate(payload: CommonRequest): Promise<string>;
+export declare function calculate(payload: CommonRequest): Promise<EmissionResponse | EmissionResponseWithDetails>;
+/**
+ * Retrieves available mobile emission calculation types by making a GET request to the API endpoint.
+ *
+ * @export
+ * @return {Promise<TypeResponse>} A promise that resolves to a TypeResponse 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();
+ */
+export declare function getTypes(): Promise<TypeResponse>;
+/**
+ * Retrieves information about geographical areas supported by the mobile emissions API.
+ *
+ * @export
+ * @return {Promise<AreaResponse>} A promise that resolves to an AreaResponse containing the supported geographical areas
+ * @throws {Error} May throw an error if the API request fails
+ *
+ * @example
+ * const areas = await getArea();
+ */
+export declare function getArea(): Promise<AreaResponse>;
+/**
+ * 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<UnitResponse>} A promise that resolves to a UnitResponse 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 declare function getUnits(type: string): Promise<UnitResponse>;

package/dist/types/api/Stationary.d.ts

@@ -1,28 +1,71 @@
 import { CommonRequest } from "../interfaces/Api";
+import { AreaResponse } from "../interfaces/response/AreaResponse";
+import { EmissionResponse } from "../interfaces/response/EmissionResponse";
+import { EmissionResponseWithDetails } from "../interfaces/response/EmissionResponseWithDetails";
+import { TypeResponse } from "../interfaces/response/TypeResponse";
+import { UnitResponse } from "../interfaces/response/UnitResponse";
 /**
  * Performs Scope 1 stationary calculations by making a POST request to the stationary API endpoint.
  *
  * @export
  * @param {CommonRequest} payload - The request data to be sent to the stationary API
- * @return {Promise<string>} A promise that resolves to the calculation result string returned by the API
+ * @return {Promise<EmissionResponse | EmissionResponseWithDetails>} A promise that resolves to the emission calculation result. Returns EmissionResponseWithDetails if includeDetails is true, otherwise EmissionResponse
  * @throws {Error} May throw an error if the API request fails
  *
  * @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);
  */
-export declare function calculate(payload: CommonRequest): Promise<string>;
+export declare function calculate(payload: CommonRequest): Promise<EmissionResponse | EmissionResponseWithDetails>;
+/**
+ * Retrieves available stationary emission calculation types by making a GET request to the API endpoint.
+ *
+ * @export
+ * @return {Promise<TypeResponse>} A promise that resolves to a TypeResponse containing the available stationary emission types
+ * @throws {Error} May throw an error if the API request fails
+ *
+ * @example
+ * const types = await getTypes();
+ */
+export declare function getTypes(): Promise<TypeResponse>;
+/**
+ * Retrieves information about geographical areas supported by the stationary emissions API.
+ *
+ * @export
+ * @return {Promise<AreaResponse>} A promise that resolves to an AreaResponse containing the supported geographical areas
+ * @throws {Error} May throw an error if the API request fails
+ *
+ * @example
+ * const areas = await getArea();
+ */
+export declare function getArea(): Promise<AreaResponse>;
+/**
+ * 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<UnitResponse>} A promise that resolves to a UnitResponse 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 declare function getUnits(type: string): Promise<UnitResponse>;

package/dist/types/api/TransportationAndDistribution.d.ts

@@ -1,27 +1,70 @@
 import { CalculationRequest } from "../interfaces/Api";
+import { AreaResponse } from "../interfaces/response/AreaResponse";
+import { EmissionResponse } from "../interfaces/response/EmissionResponse";
+import { EmissionResponseWithDetails } from "../interfaces/response/EmissionResponseWithDetails";
+import { TypeResponse } from "../interfaces/response/TypeResponse";
+import { UnitResponse } from "../interfaces/response/UnitResponse";
 /**
- * Performs Scope 2 transportation and distribution emission calculations by making a POST request to the transportation and distribution API endpoint.
+ * Performs Scope 3 transportation and distribution emission calculations by making a POST request to the transportation and distribution API endpoint.
  *
  * @export
  * @param {CalculationRequest} payload - The calculation request data for transportation and distribution operations
- * @return {Promise<string>} A promise that resolves to the calculation result string returned by the API
+ * @return {Promise<EmissionResponse | EmissionResponseWithDetails>} A promise that resolves to the emission calculation result. Returns EmissionResponseWithDetails if includeDetails is true, otherwise EmissionResponse
  * @throws {Error} May throw an error if the API request fails
  *
  * @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);
  */
-export declare function calculate(payload: CalculationRequest): Promise<string>;
+export declare function calculate(payload: CalculationRequest): Promise<EmissionResponse | EmissionResponseWithDetails>;
+/**
+ * Retrieves available transportation and distribution calculation types by making a GET request to the API endpoint.
+ *
+ * @export
+ * @return {Promise<TypeResponse>} A promise that resolves to a TypeResponse 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 declare function getTypes(): Promise<TypeResponse>;
+/**
+ * Retrieves information about geographical areas supported by the transportation and distribution API.
+ *
+ * @export
+ * @return {Promise<AreaResponse>} A promise that resolves to an AreaResponse containing the supported geographical areas
+ * @throws {Error} May throw an error if the API request fails
+ *
+ * @example
+ * const areas = await getArea();
+ */
+export declare function getArea(): Promise<AreaResponse>;
+/**
+ * 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<UnitResponse>} A promise that resolves to a UnitResponse 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 declare function getUnits(type: string): Promise<UnitResponse>;

package/dist/types/index.d.ts

@@ -8,3 +8,11 @@ export * as TransportationAndDistribution from './api/TransportationAndDistribut
 export * as Factor from './api/Factor';
 export * as FactorSets from './api/FactorSets';
 export { ClientConfig } from './interfaces/Config';
+export { AreaResponse, Location as LocationInfo } from './interfaces/response/AreaResponse';
+export { EmissionResponse } from './interfaces/response/EmissionResponse';
+export { EmissionResponseWithDetails, UnitInfo, AreaInfo, AreaType, FactorDataTypeCategory, FactorSetInfo, FactorSelectionDefault, FactorDataTypeCode, FactorSetVersion, FactorValue, FactorMetaData, UnitConversion, EmissionData } from './interfaces/response/EmissionResponseWithDetails';
+export { FactorResponse } from './interfaces/response/FactorResponse';
+export { FactorSetResponse, FactorSet } from './interfaces/response/FactorSetResponse';
+export { SearchResponse, Pagination, PaginationBody, SearchLink } from './interfaces/response/SearchResponse';
+export { TypeResponse } from './interfaces/response/TypeResponse';
+export { UnitResponse } from './interfaces/response/UnitResponse';