@cra-risk-management/sdk 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,33 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.0] - 2025-12-30
+
+### Added
+- Initial release of CRA Risk Management SDK for JavaScript
+- Client class with authentication support (username/password and token-based)
+- HTTP methods: GET, POST, PATCH, DELETE
+- Resource clients for:
+  - Municipalities
+  - Critical Points (with nested attributes: Event Zones, Event Types, Observations)
+  - Users
+- Automatic token management and re-authentication
+- Request retry logic with exponential backoff
+- Configurable timeout and retry settings
+- Comprehensive test suite with Jest
+- Full API documentation in README
+
+### Features
+- Token-based authentication with automatic expiration handling
+- Username/password authentication
+- Request timeout handling with AbortController
+- Automatic retry on transient failures (5xx errors)
+- Automatic re-authentication on 401 errors
+- Support for query parameters in GET requests
+- Structured error handling with status codes
+
+[1.0.0]: https://github.com/CRA-Risk-Management/sdk-js/releases/tag/v1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 CRA Risk Management
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,413 @@
+# CRA Risk Management SDK for JavaScript
+
+A comprehensive JavaScript SDK for interacting with the CRA Risk Management API. This SDK provides a simple and intuitive interface for managing municipalities, critical points, users, and related resources.
+
+## Installation
+
+Install the package via npm:
+
+```bash
+npm install @cra-risk-management/sdk-js
+```
+
+## Quick Start
+
+### CommonJS
+
+```javascript
+const Client = require('@cra-risk-management/sdk-js');
+
+// Initialize the client
+const client = new Client({
+  baseURL: 'https://your-api-url.com',
+  username: 'your-username',
+  password: 'your-password'
+});
+
+// Authenticate (happens automatically when needed)
+await client.login('username', 'password');
+
+// Use resource clients
+const municipalities = await client.municipalities.list();
+console.log(municipalities);
+```
+
+### ES Modules
+
+```javascript
+import Client from '@cra-risk-management/sdk-js';
+
+// Initialize the client
+const client = new Client({
+  baseURL: 'https://your-api-url.com',
+  username: 'your-username',
+  password: 'your-password'
+});
+
+// Authenticate (happens automatically when needed)
+await client.login('username', 'password');
+
+// Use resource clients
+const municipalities = await client.municipalities.list();
+console.log(municipalities);
+```
+
+## Authentication
+
+The SDK supports two authentication methods:
+
+### 1. Username and Password
+
+```javascript
+const client = new Client({
+  baseURL: 'https://your-api-url.com',
+  username: 'your-username',
+  password: 'your-password'
+});
+
+// Login explicitly
+await client.login('username', 'password');
+
+// Or set credentials and let the SDK authenticate automatically
+client.setCredentials('username', 'password');
+```
+
+### 2. Token-based Authentication
+
+```javascript
+const client = new Client({
+  baseURL: 'https://your-api-url.com'
+});
+
+// Set token directly (if you already have one)
+client.setToken('your-access-token', 3600); // token and expiry in seconds
+```
+
+The SDK automatically handles token expiration and re-authentication when using username/password credentials.
+
+## Configuration Options
+
+When creating a new client instance, you can provide the following options:
+
+```javascript
+const client = new Client({
+  baseURL: 'https://your-api-url.com',    // Required: Base URL of the API
+  username: 'user',                        // Optional: Username for authentication
+  password: 'pass',                        // Optional: Password for authentication
+  authEndpoint: '/users/token',           // Optional: Custom auth endpoint (default: /users/token)
+  timeout: 30000,                          // Optional: Request timeout in ms (default: 30000)
+  maxRetries: 1                            // Optional: Max retry attempts (default: 1)
+});
+```
+
+## API Reference
+
+### Client Methods
+
+#### Authentication Methods
+
+- **`login(username, password)`** - Authenticate with username and password
+  ```javascript
+  const token = await client.login('username', 'password');
+  ```
+
+- **`logout()`** - Clear credentials and token
+  ```javascript
+  client.logout();
+  ```
+
+- **`setCredentials(username, password)`** - Set credentials without authenticating
+  ```javascript
+  client.setCredentials('username', 'password');
+  ```
+
+- **`setToken(token, expiresIn)`** - Set token directly
+  ```javascript
+  client.setToken('your-token', 3600);
+  ```
+
+- **`isAuthenticated()`** - Check if client has a valid token
+  ```javascript
+  if (client.isAuthenticated()) {
+    // Client is authenticated
+  }
+  ```
+
+#### HTTP Methods
+
+- **`get(endpoint, params)`** - Make a GET request
+  ```javascript
+  const data = await client.get('/municipalities/items', { limit: 10 });
+  ```
+
+- **`post(endpoint, data)`** - Make a POST request
+  ```javascript
+  const result = await client.post('/municipalities', { name: 'New Municipality' });
+  ```
+
+- **`patch(endpoint, data)`** - Make a PATCH request
+  ```javascript
+  const updated = await client.patch('/municipalities/items/1', { name: 'Updated Name' });
+  ```
+
+- **`delete(endpoint)`** - Make a DELETE request
+  ```javascript
+  await client.delete('/municipalities/items/1');
+  ```
+
+- **`confirm(endpoint, id)`** - Confirm a resource
+  ```javascript
+  await client.confirm('/critical_points', 123);
+  ```
+
+### Resource Clients
+
+#### Municipalities
+
+Access via `client.municipalities`:
+
+- **`list(params)`** - List all municipalities
+  ```javascript
+  const municipalities = await client.municipalities.list({ limit: 10 });
+  ```
+
+- **`get(id, params)`** - Get a municipality by ID
+  ```javascript
+  const municipality = await client.municipalities.get(1);
+  ```
+
+- **`create(data)`** - Create a new municipality
+  ```javascript
+  const newMunicipality = await client.municipalities.create({
+    name: 'New Municipality',
+    code: 'NM001'
+  });
+  ```
+
+- **`update(id, data)`** - Update a municipality
+  ```javascript
+  const updated = await client.municipalities.update(1, { name: 'Updated Name' });
+  ```
+
+- **`delete(id)`** - Delete a municipality
+  ```javascript
+  await client.municipalities.delete(1);
+  ```
+
+#### Critical Points
+
+Access via `client.criticalPoints`:
+
+- **`list(params)`** - List all critical points
+  ```javascript
+  const points = await client.criticalPoints.list({
+    event_type_id: 1,
+    municipality_id: 5,
+    confirmed: true
+  });
+  ```
+
+- **`get(id, params)`** - Get a critical point by ID
+  ```javascript
+  const point = await client.criticalPoints.get(123);
+  ```
+
+- **`create(data)`** - Create a new critical point
+  ```javascript
+  const newPoint = await client.criticalPoints.create({
+    name: 'Critical Point 1',
+    latitude: 40.7128,
+    longitude: -74.0060
+  });
+  ```
+
+- **`update(id, data)`** - Update a critical point
+  ```javascript
+  const updated = await client.criticalPoints.update(123, { confirmed: true });
+  ```
+
+- **`delete(id)`** - Delete a critical point
+  ```javascript
+  await client.criticalPoints.delete(123);
+  ```
+
+##### Critical Point Attributes
+
+Access nested attribute resources via `client.criticalPoints.attributes`:
+
+**Event Zones** - `client.criticalPoints.attributes.eventZones`
+- `list(params)` - List event zones
+- `get(id, params)` - Get event zone by ID
+- `create(data)` - Create event zone
+- `update(id, data)` - Update event zone
+- `delete(id)` - Delete event zone
+
+**Event Types** - `client.criticalPoints.attributes.eventTypes`
+- `list(params)` - List event types
+- `get(id, params)` - Get event type by ID
+- `create(data)` - Create event type
+- `update(id, data)` - Update event type
+- `delete(id)` - Delete event type
+
+**Observations** - `client.criticalPoints.attributes.observations`
+- `list(params)` - List observations
+- `get(id, params)` - Get observation by ID
+- `create(data)` - Create observation
+- `update(id, data)` - Update observation
+- `delete(id)` - Delete observation
+
+#### Users
+
+Access via `client.users`:
+
+- **`list(params)`** - List all users
+  ```javascript
+  const users = await client.users.list();
+  ```
+
+- **`get(id, params)`** - Get a user by ID
+  ```javascript
+  const user = await client.users.get(1);
+  ```
+
+- **`create(data)`** - Create a new user
+  ```javascript
+  const newUser = await client.users.create({
+    username: 'newuser',
+    email: 'newuser@example.com'
+  });
+  ```
+
+- **`update(id, data)`** - Update a user
+  ```javascript
+  const updated = await client.users.update(1, { email: 'newemail@example.com' });
+  ```
+
+- **`delete(id)`** - Delete a user
+  ```javascript
+  await client.users.delete(1);
+  ```
+
+## Examples
+
+### Complete Usage Example
+
+```javascript
+const Client = require('@cra-risk-management/sdk-js');
+
+async function main() {
+  // Initialize client
+  const client = new Client({
+    baseURL: 'https://api.example.com',
+    username: 'your-username',
+    password: 'your-password',
+    timeout: 30000
+  });
+
+  try {
+    // Authenticate
+    await client.login('username', 'password');
+    console.log('Authenticated successfully');
+
+    // List municipalities
+    const municipalities = await client.municipalities.list({ limit: 5 });
+    console.log('Municipalities:', municipalities);
+
+    // Create a critical point
+    const newPoint = await client.criticalPoints.create({
+      name: 'Flood Risk Area',
+      latitude: 40.7128,
+      longitude: -74.0060,
+      event_type_id: 1,
+      municipality_id: 5
+    });
+    console.log('Created critical point:', newPoint);
+
+    // Update the critical point
+    const updated = await client.criticalPoints.update(newPoint.id, {
+      confirmed: true
+    });
+    console.log('Updated critical point:', updated);
+
+    // List event zones
+    const eventZones = await client.criticalPoints.attributes.eventZones.list();
+    console.log('Event zones:', eventZones);
+
+  } catch (error) {
+    console.error('Error:', error.message);
+  } finally {
+    // Logout when done
+    client.logout();
+  }
+}
+
+main();
+```
+
+### Error Handling
+
+```javascript
+try {
+  const municipalities = await client.municipalities.list();
+} catch (error) {
+  if (error.status === 404) {
+    console.error('Resource not found');
+  } else if (error.status === 401) {
+    console.error('Authentication failed');
+  } else if (error.status >= 500) {
+    console.error('Server error');
+  } else {
+    console.error('Error:', error.message);
+  }
+}
+```
+
+### Using Query Parameters
+
+```javascript
+// List with filtering
+const filteredPoints = await client.criticalPoints.list({
+  event_type_id: 1,
+  municipality_id: 5,
+  confirmed: true,
+  from_datetime: '2025-01-01',
+  to_datetime: '2025-12-31'
+});
+
+// List with pagination
+const paginatedMunicipalities = await client.municipalities.list({
+  limit: 20,
+  offset: 40
+});
+```
+
+## Requirements
+
+- Node.js >= 14.0.0
+- npm or yarn package manager
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+### Development Setup
+
+1. Clone the repository
+2. Install dependencies: `npm install`
+3. Run tests: `npm test`
+4. Run tests in watch mode: `npm run test:watch`
+5. Generate coverage report: `npm run test:coverage`
+
+## Support
+
+For issues, questions, or contributions, please visit:
+- GitHub Issues: https://github.com/CRA-Risk-Management/sdk-js/issues
+- GitHub Repository: https://github.com/CRA-Risk-Management/sdk-js
+
+---
+
+Made with ❤️ by CRA Risk Management

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@cra-risk-management/sdk",
+  "version": "1.0.0",
+  "description": "Software Development Kit for JS apps - CRA Risk Management API Client",
+  "main": "src/client.js",
+  "keywords": [
+    "sdk",
+    "api",
+    "client",
+    "cra",
+    "risk-management"
+  ],
+  "author": "CRA Risk Management",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/CRA-Risk-Management/sdk-js.git"
+  },
+  "bugs": {
+    "url": "https://github.com/CRA-Risk-Management/sdk-js/issues"
+  },
+  "homepage": "https://github.com/CRA-Risk-Management/sdk-js#readme",
+  "files": [
+    "src/",
+    "LICENSE",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "node-fetch": "^2.7.0"
+  }
+}

package/src/client.js

@@ -0,0 +1,281 @@
+const UsersClient = require("../src/resources/users");
+const MunicipalitiesClient = require("../src/resources/municipalities");
+const CriticalPointsClient = require("../src/resources/criticalPoints");
+
+class Client {
+  /**
+   * @param {Object} options
+   * @param {string} options.baseURL
+   * @param {number} [options.timeout]
+   * @param {string} [options.username]
+   * @param {string} [options.password]
+   * @param {string} [options.authEndpoint]
+   * @param {number} [options.maxRetries]
+   */
+
+  constructor(options = {}) {
+    this.baseURL = options.baseURL;
+    this.authEndpoint = options.authEndpoint || "/users/token"
+    this.timeout = options.timeout || 30000;
+    this.maxRetries = options.maxRetries || 1;
+
+    this.username = options.username || null;
+    this.password = options.password || null;
+
+    this.token = null;
+    this.tokenExpiry = null;
+
+    this.defaultHeaders = {
+      "Content-Type": "application/json",
+    };
+
+    this.municipalities = new MunicipalitiesClient(this);
+    this.criticalPoints = new CriticalPointsClient(this);
+    this.users = new UsersClient(this);
+  }
+
+  /**
+   * Authenticate
+   * @returns {Promise<string>} Access Token
+   */
+  async authenticate() {
+    if (!this.username || !this.password) {
+      throw new Error("Username and password are required");
+    }
+
+    try {
+      const response = await fetch(`${this.baseURL}${this.authEndpoint}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+      },
+      body: new URLSearchParams({
+        username: this.username,
+        password: this.password,
+      }),
+    });
+      
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({}));
+        throw new Error(error.message || "Authentication failed");
+      }
+
+      const data = await response.json();
+      this.token = data.access_token || data.token;
+      if (!this.token) {
+        throw new Error("No token received from authentication endpoint");
+      }
+
+      const expiresIn = data.expires_in || 3600;
+      this.tokenExpiry = Date.now() + (expiresIn * 1000);
+      
+      return this.token;
+    } catch (error) {
+      throw new Error(`Authentication error ${error.message}`);
+    }
+  }
+
+  /**
+   * Check if token is valid.
+   * @returns {boolean}
+   */
+  isAuthenticated() {
+    if (!this.token) return false;
+    if (!this.tokenExpiry) return true;
+    return Date.now() < this.tokenExpiry;
+  }
+
+  /**
+   * Ensures client is authenticated.
+   * @private
+   */
+  async ensureAuthenticated() {
+    if (!this.isAuthenticated()) {
+      await this.authenticate();
+    }
+  }
+
+  /**
+   * HTTP request
+   * @private 
+   */
+  async _request(endpoint, options = {}, retryCount = 0) {
+    let url = `${this.baseURL}${endpoint}`
+    const config = {
+      method: options.method || "GET",
+      headers: {
+        ...this.defaultHeaders,
+        ...options.headers,
+      }
+    }
+
+    if (options.body) {
+      config.body = options.body;
+    }
+
+    const requiresAuth = ['POST', 'PATCH', 'DELETE'].includes(options.method);
+    if (requiresAuth) {
+      await this.ensureAuthenticated();
+      config.headers["Authorization"] = `Bearer ${this.token}`;
+    }
+
+    if (options.params) {
+      const queryString = new URLSearchParams(options.params).toString();
+      url = queryString ? `${url}?${queryString}` : url;
+    }
+
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    config.signal = controller.signal;
+
+    try {
+      const response = await fetch(url, config);
+      clearTimeout(timeoutId);
+
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({}));
+        if (response.status === 401 && requiresAuth && retryCount < this.maxRetries) {
+          this.token = null;
+          await this.ensureAuthenticated();
+          config.headers["Authorization"] = `Bearer ${this.token}`;
+
+          return this._request(endpoint, options, retryCount + 1);
+        }
+
+        throw this._createError(response.status, error.message || response.statusText, error);
+      }
+
+      return await response.json();
+    } catch (error) {
+      if (error.name === "AbortError") {
+        throw new Error("Request timeout");
+      }
+      if (retryCount < this.maxRetries && this._isRetryableError(error)) {
+        await this._delay(Math.pow(2, retryCount) * 1000);
+        return this._request(endpoint, options, retryCount + 1);
+      }
+      
+      throw error;
+    }
+  }
+
+  /**
+   * Create structured error
+   * @private 
+   */
+  _createError(status, message, data) {
+    const error = new Error(message);
+    error.status = status;
+    error.data = data;
+    return error;
+  }
+
+  /**
+   * Check if error is retryable
+   * @private
+   */
+  _isRetryableError(error) {
+    return (
+      error.name === "AbortError" ||
+      error.message.includes("fetch") ||
+      (error.status >= 500 && error.status < 600)
+    );
+  }
+
+  /**
+   * Delay helper for retry backoff
+   * @private
+   */
+  _delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+
+  /**
+   * Login with username and password
+   * @param {string} username
+   * @param {string} password
+   * @returns {Promise<string>} Access token
+   */
+  async login(username, password) {
+    this.username = username;
+    this.password = password;
+    return await this.authenticate();
+  }
+
+  /**
+   * Logout (clear credentials and token)
+   */
+  logout() {
+    this.username = null;
+    this.password = null;
+    this.token = null;
+    this.tokenExpiry = null;
+  }
+
+  /**
+   * Set credentials without authenticating
+   * @param {string} username
+   * @param {string} password
+   */
+  setCredentials(username, password) {
+    this.username = username;
+    this.password = password;
+  }
+
+  /**
+   * Set token directly (if you already have one)
+   * @param {string} token
+   * @param {number} [expiresIn] - Expiry in seconds
+   */
+  setToken(token, expiresIn = 3600) {
+    this.token = token;
+    this.tokenExpiry = Date.now() + (expiresIn * 1000);
+  }
+
+  /**
+   * GET request
+   * @param {string} endpoint
+   * @param {Object} [params]
+   */
+  async get(endpoint, params = {}) {
+    return this._request(endpoint, {method: "GET", params});
+  }
+
+  /**
+   * POST request
+   * @param {string} endpoint
+   * @param {Object} [params]
+   */
+  async post(endpoint, data) {
+    return this._request(`${endpoint}/`, {method: "POST", body: JSON.stringify(data)})
+  }
+
+  /**
+   * PATCH request
+   * @param {string} endpoint
+   * @param {Object} data
+   */
+  async patch(endpoint, data) {
+    return this._request(endpoint, {method: "PATCH", body: JSON.stringify(data)})
+  }
+
+  /**
+   * DELETE request
+   * @param {string} endpoint
+   */
+  async delete(endpoint) {
+    return this._request(endpoint, {method: "DELETE"});
+  }
+
+  /**
+   * Special request to confirm data
+   * @param {string} endpoint 
+   * @param {number} id 
+   */
+  async confirm(endpoint, id) {
+    let url = `${endpoint}/items/${id}/confirm`;
+    return this._request(url, {method: "PATCH"});
+  }
+}
+
+module.exports = Client;

package/src/models/criticalPoints.js

@@ -0,0 +1,39 @@
+/**
+ * @typedef {Object} CriticalPointCreate
+ * @property {string} description
+ * @property {number} municipality_id
+ * @property {number} event_type_id
+ * @property {number} event_zone_id
+ * @property {number} [user_id]
+ * @property {string} [image_id]
+ * @property {Date} [datetime]
+ * @property {number} [confirmed=0]
+ * @property {string} geometry
+ */
+
+/**
+ * @typedef {Object} CriticalPoint
+ * @property {number} id
+ * @property {string} description
+ * @property {number} municipality_id
+ * @property {number} event_type_id
+ * @property {number} event_zone_id
+ * @property {number} user_id
+ * @property {string} image_id
+ * @property {Date} datetime
+ * @property {number} confirmed
+ * @property {string} geometry
+ */
+
+/**
+ * @typedef {Object} CriticalPointUpdate
+ * @property {string} [description]
+ * @property {number} [municipality_id]
+ * @property {number} [event_type_id]
+ * @property {number} [event_zone_id]
+ * @property {number} [user_id]
+ * @property {string} [image_id]
+ * @property {Date} [datetime]
+ * @property {number} [confirmed]
+ * @property {string} [geometry]
+ */

package/src/models/eventTypes.js

@@ -0,0 +1,23 @@
+/**
+ * @typedef {Object} EventTypeCreate
+ * @property {string} event_type
+ * @property {string} icon
+ * @property {string} color
+ */
+
+/**
+ * @typedef {Object} EventType
+ * @property {number} id
+ * @property {string} event_type
+ * @property {string} icon
+ * @property {string} color
+ */
+
+/**
+ * @typedef {Object} EventTypeUpdate
+  * @property {string} [event_type]
+ * @property {string} [icon]
+ * @property {string} [color]
+ */
+
+module.exports = {}

package/src/models/eventZones.js

@@ -0,0 +1,23 @@
+/**
+ * @typedef {Object} EventZoneCreate
+ * @property {string} event_zone
+ * @property {string} icon
+ * @property {string} color
+ */
+
+/**
+ * @typedef {Object} EventZone
+ * @property {number} id
+ * @property {string} event_zone
+ * @property {string} icon
+ * @property {string} color
+ */
+
+/**
+ * @typedef {Object} EventZoneUpdate
+  * @property {string} [event_zone]
+ * @property {string} [icon]
+ * @property {string} [color]
+ */
+
+module.exports = {}

package/src/models/municipalities.js

@@ -0,0 +1,20 @@
+/**
+ * @typedef {Object} MunicipalityCreate
+ * @property {string} name
+ * @property {string} geometry
+ */
+
+/**
+ * @typedef {Object} Municipality
+ * @property {number} id
+ * @property {string} name
+ * @property {string} geometry
+ */
+
+/**
+ * @typedef {Object} MunicipalityUpdate
+ * @property {string} [name]
+ * @property {string} [geometry]
+ */
+
+module.exports = {}

package/src/models/observations.js

@@ -0,0 +1,29 @@
+/**
+ * @typedef {Object} ObservationCreate
+ * @property {string} information
+ * @property {string} critical_point_id
+ * @property {string} [image_id]
+ * @property {Date} [datetime]
+ * @property {number} [confirmed=0]
+ */
+
+/**
+ * @typedef {Object} Observation
+ * @property {number} id
+ * @property {string} information
+ * @property {string} critical_point_id
+ * @property {string} image_id
+ * @property {Date} datetime
+ * @property {number} confirmed
+ */
+
+/**
+ * @typedef {Object} ObservationUpdate
+ * @property {string} [information]
+ * @property {string} [critical_point_id]
+ * @property {string} [image_id]
+ * @property {Date} [datetime]
+ * @property {number} [confirmed]
+ */
+
+module.exports = {}

package/src/models/users.js

@@ -0,0 +1,23 @@
+/**
+ * @typedef UserCreate
+ * @param {string} username
+ * @param {string} password
+ * @param {string} type
+ */
+
+/**
+ * @typedef User
+ * @param {number} id
+ * @param {string} username
+ * @param {string} password
+ * @param {string} type
+ */
+
+/**
+ * @typedef UserUpdate
+ * @param {string} [username]
+ * @param {string} [password]
+ * @param {string} [type]
+ */
+
+module.exports = {}

package/src/resources/criticalPoints.js

@@ -0,0 +1,236 @@
+class CriticalPoints {
+  constructor(client) {
+    this.client = client;
+    this.endpoint = "/critical_points";
+    this.attributes = new CriticalPointAttributes(client);
+  }
+
+  /**
+   * List all critical points.
+   * @param {Object} [params]
+   * @param {number} [params.event_type_id]
+   * @param {number} [params.event_zone_id]
+   * @param {number} [params.municipality_id]
+   * @param {number} [params.user_id]
+   * @param {boolean} [params.confirmed]
+   * @param {Date} [params.from_datetime]
+   * @param {Date} [params.to_datetime]
+   * @returns {Promise<import("../models/criticalPoints").CriticalPoint[]>}
+   */
+  async list(params = {}) {
+    return this.client.get(`${this.endpoint}/items`, params);
+  }
+
+  /**
+   * Get one critical point by its ID.
+   * @param {number} id 
+   * @param {Object} params 
+   * @returns {Promise<import("../models/criticalPoints").CriticalPoint>}
+   */
+  async get(id, params = {}) {
+    return this.client.get(`${this.endpoint}/items/${id}`, params);
+  }
+
+  /**
+   * Create a critical point instance.  
+   * @param {import("../models/criticalPoints").CriticalPointCreate} data 
+   * @returns {Promise<import("../models/criticalPoints").CriticalPoint>}
+   */
+  async create(data) {
+    return this.client.post(this.endpoint, data);
+  }
+
+  /**
+   * Patch critical point.
+   * @param {number} id 
+   * @param {import("../models/criticalPoints").CriticalPointUpdate} data 
+   * @returns {Promise<import("../models/criticalPoints").CriticalPoint>}
+   */
+  async update(id, data) {
+    return this.client.patch(`${this.endpoint}/items/${id}`, data);
+  }
+
+  /**
+   * Delete a critical point.
+   * @param {number} id 
+   * @returns {Promise<void>}
+   */
+  async delete(id) {
+    return this.client.delete(`${this.endpoint}/items/${id}`);
+  }
+}
+
+class CriticalPointAttributes {
+  constructor(client) {
+    this.client = client;
+    this.endpoint = "/critical_points/attributes";
+    this.eventZones = new EventZoneAttribute(client, this.endpoint);
+    this.eventTypes = new EventTypeAttribute(client, this.endpoint);
+    this.observations = new ObservationAttribute(client, this.endpoint);
+  }
+}
+
+class EventZoneAttribute {
+  constructor(client, parentEndpoint) {
+    this.client = client;
+    this.endpoint = `${parentEndpoint}/event_zones`;
+  }
+
+  /**
+   * Get all event zones.
+   * @param {Object} [params] 
+   * @returns {promise<import("../models/eventZones").EventZone[]>}
+   */
+  async list(params = {}) {
+    return this.client.get(`${this.endpoint}/items`, params);
+  }
+
+  /**
+   * Get one event zone by its ID.
+   * @param {number} id 
+   * @param {object} [params] 
+   * @returns {Promise<import("../models/eventZones").EventZone>}
+   */
+  async get(id, params = {}) {
+    return this.client.get(`${this.endpoint}/items/${id}`, params);
+  }
+
+  /**
+   * Create an event zone instance.
+   * @param {import("../models/eventZones").EventZoneCreate} data 
+   * @returns {Promise<import("../models/eventZones").EventZone>}
+   */
+  async create(data) {
+    return this.client.post(this.endpoint, data);
+  }
+
+  /**
+   * Update event zone.
+   * @param {number} id 
+   * @param {import("../models/eventZones").EventZoneUpdate} data 
+   * @returns {Promise<import("../models/eventZones").EventZone>}
+   */
+  async update(id, data) {
+    return this.client.patch(`${this.endpoint}/items/${id}`, data);
+  }
+
+  /**
+   * Delete event zone by ID.
+   * @param {number} id 
+   * @returns {Promise<void>}
+   */
+  async delete(id) {
+    return this.client.delete(`${this.endpoint}/items/${id}`);
+  }
+}
+
+class EventTypeAttribute {
+  constructor(client, parentEndpoint) {
+    this.client = client;
+    this.endpoint = `${parentEndpoint}/event_types`;
+  }
+
+  /**
+   * List all event types.
+   * @param {Object} [params] 
+   * @returns {Promise<import("../models/eventTypes").EventType[]>}
+   */
+  async list(params = {}) {
+    return this.client.get(`${this.endpoint}/items`, params);
+  }
+
+  /**
+   * Get one event type by its ID.
+   * @param {number} id 
+   * @param {Object} [params] 
+   * @returns {Promise<import("../models/eventTypes").EventType>}
+   */
+  async get(id, params = {}) {
+    return this.client.get(`${this.endpoint}/items/${id}`, params);
+  }
+
+  /**
+   * Create event type instance.
+   * @param {import("../models/eventTypes").EventTypeCreate} data 
+   * @returns {Promise<import("../models/eventTypes").EventType>}
+   */
+  async create(data) {
+    return this.client.post(this.endpoint, data);
+  }
+
+  /**
+   * Update event type.
+   * @param {number} id 
+   * @param {import("../models/eventTypes").EventTypeUpdate} data 
+   * @returns {Promise<import("../models/eventTypes").EventType>}
+   */
+  async update(id, data) {
+    return this.client.patch(`${this.endpoint}/items/${id}`, data);
+  }
+
+  /**
+   * Delete event type instance.
+   * @param {number} id 
+   * @returns {Promise<void>}
+   */
+  async delete(id) {
+    return this.client.delete(`${this.endpoint}/items/${id}`);
+  }
+}
+
+class ObservationAttribute {
+  constructor(client, parentEndpoint) {
+    this.client = client;
+    this.endpoint = `${parentEndpoint}/observations`;
+  }
+
+  /**
+   * List observations.
+   * @param {Object} [params]
+   * @param {number} [params.critical_point_id] 
+   * @returns {Promise<import("../models/observations").Observation[]>}
+   */
+  async list(params = {}) {
+    return this.client.get(`${this.endpoint}/items`, params);
+  }
+
+  /**
+   * Get one observation by ID.
+   * @param {number} id 
+   * @param {Object} [params] 
+   * @returns {Promise<import("../models/observations").Observation>}
+   */
+  async get(id, params = {}) {
+    return this.client.get(`${this.endpoint}/items/${id}`, params);
+  }
+
+  /**
+   * Create observation instance.
+   * @param {import("../models/observations").ObservationCreate} data 
+   * @returns {Promise<import("../models/observations").Observation>}
+   */
+  async create(data) {
+    return this.client.post(this.endpoint, data);
+  }
+
+  /**
+   * Update observation instance.
+   * @param {number} id 
+   * @param {import("../models/observations").ObservationUpdate} data 
+   * @returns {Promise<import("../models/observations").Observation>}
+   */
+  async update(id, data) {
+    return this.client.patch(`${this.endpoint}/items/${id}`, data);
+  }
+
+  /**
+   * Delete observation.
+   * @param {number} id 
+   * @returns {Promise<void>}
+   */
+  async delete(id) {
+    return this.client.delete(`${this.endpoint}/items/${id}`);
+  }
+}
+
+module.exports = CriticalPoints;

package/src/resources/municipalities.js

@@ -0,0 +1,58 @@
+class Municipalities {
+  /**
+   * @param {import("../client")} client
+   */
+  constructor(client) {
+    this.client = client;
+    this.endpoint = "/cartography/municipalities";
+  }
+
+  /**
+   * List all municipalities.
+   * @param {Object} [params]
+   * @returns {Promise<import("../models/municipalities").Municipality[]>}
+   */
+  async list(params = {}) {
+    return this.client.get(`${this.endpoint}/items`, params);
+  }
+
+  /**
+   * Get a municipality instance by id.
+   * @param {number} id
+   * @param {Object} [params]
+   * @returns {Promise<import("../models/municipalities").Municipality>}
+   */
+  async get(id, params = {}) {
+    return this.client.get(`${this.endpoint}/items/${id}`, params)
+  }
+
+  /**
+   * Create a municipality instance.
+   * @param {import("../models/municipalities").MunicipalityCreate} data
+   * @returns {Promise<import("../models/municipalities").Municipality>}
+   */
+  async create(data) {
+    return this.client.post(this.endpoint, data)
+  }
+
+  /**
+   * Update a municipality instance.
+   * @param {number} id
+   * @param {import("../models/municipalities").MunicipalityUpdate} data
+   * @returns {Promise<import("../models/municipalities").Municipality>}
+   */
+  async update(id, data) {
+    return this.client.patch(`${this.endpoint}/items/${id}`, data)
+  }
+
+  /**
+   * Delete municipality instance.
+   * @param {number} id
+   * @returns {Promise<void>}
+   */
+  async delete(id) {
+    return this.client.delete(`${this.endpoint}/items/${id}`)
+  }
+}
+
+module.exports = Municipalities;

package/src/resources/users.js

@@ -0,0 +1,58 @@
+class Users {
+  /**
+   * @param {import("../client")} client
+   */
+  constructor(client) {
+    this.client = client;
+    this.endpoint = "/users";
+  }
+
+  /**
+   * Get all Users.
+   * @param {Object} params 
+   * @returns {Promise<import("../models/users").User[]>}
+   */
+  async list(params = {}) {
+    return this.client.get(`${this.endpoint}/items`, params);
+  }
+
+  /**
+   * Get one User by ID.
+   * @param {number} id 
+   * @param {Object} params 
+   * @returns {Promise<import("../models/users").User>}
+   */
+  async get(id, params = {}) {
+    return this.client.get(`${this.endpoint}/items/${id}`, params);
+  }
+
+  /**
+   * Create an User instance
+   * @param {import("../models/users").UserCreate} data 
+   * @returns {Promise<import("../models/users").User>}
+   */
+  async create(data) {
+    return this.client.post(this.endpoint, data);
+  }
+
+  /**
+   * Update User instance.
+   * @param {number} id 
+   * @param {import("../models/users").UserUpdate} data 
+   * @returns {Promise<import("../models/users").User}
+   */
+  async update(id, data) {
+    return this.client.patch(`${this.endpoint}/items/${id}`, data);
+  }
+
+  /**
+   * Delete user instance.
+   * @param {number} id
+   * @returns {Promise<void>}
+   */
+  async delete(id) {
+    return this.client.delete(`${this.endpoint}/items/${id}`);
+  }
+}
+
+module.exports = Users;