vayu-ts 0.0.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 weft-finance
+
+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,202 @@
+# Vayu API Client Library ![client version](https://img.shields.io/npm/v/vayu-ts?label=Latest%20Version)
+
+## Overview
+
+The Vayu API client library in TypeScript allows you to submit events for processing and storage, manage billing-related entities, and perform various other operations seamlessly.
+
+## Installation
+
+Install the Vayu API client library using npm:
+
+```bash
+npm i vayu-ts
+```
+
+## Usage
+
+### Initialization
+
+Initialize the Vayu API client. The `baseUrl` parameter is optional and defaults to Vayu's public API servers.
+
+```typescript
+import { Vayu } from 'vayu-ts';
+
+const vayu = new Vayu(
+  'your-access-token',
+);
+```
+
+### Authentication
+
+#### Login and authenticate
+
+```typescript
+await vayu.login();
+```
+
+### Events
+
+#### Sending Events
+
+To send a batch of events for processing and storage:
+
+```typescript
+const events: Event[] = [
+  {
+    name: 'api_call',  // The distinctive label assigned to an event
+    timestamp: new Date().toISOString(),  // The exact moment of event occurrence in ISO 8601 format
+    customerAlias: 'customer_12345',  // A unique identifier assigned to each customer
+    ref: '4f6cf35x-2c4y-483z-a0a9-158621f77a21',  // A universally unique identifier for each event
+    data: {
+      key1: 'processing_duration',  // Example additional data
+      key2: 'api_url'  // Example additional data
+    }
+  }
+];
+
+const response = await vayu.events.send(events);
+
+console.log(response.validEvents);
+console.log(response.invalidEvents);
+```
+
+#### Querying Events
+
+To fetch events occurring within a specified timestamp range:
+
+```typescript
+const response = await vayu.events.query({
+  startTime: '2023-09-01T00:00:00.000Z',
+  endTime: '2023-09-30T23:59:59.999Z',
+  eventName: 'api_call',
+  limit: 10
+});
+
+console.log(response.events);
+```
+
+#### Getting Event by Ref ID
+
+To get a specific event using its reference ID:
+
+```typescript
+const response = await vayu.events.get('4f6cf35x-2c4y-483z-a0a9-158621f77a21');
+
+console.log(response.event);
+```
+
+#### Deleting Event by Ref ID
+
+To delete a specific event using its reference ID:
+
+```typescript
+const response = await vayu.events.delete('4f6cf35x-2c4y-483z-a0a9-158621f77a21');
+
+console.log(response.event);
+```
+
+### Customers
+
+#### Creating a Customer
+
+To create a new customer:
+
+```typescript
+const response = await vayu.customers.create({
+  name: 'John Doe',
+  alias: 'customer_12345'
+});
+
+console.log(response.customer);
+```
+
+#### Updating a Customer
+
+To update an existing customer by ID:
+
+```typescript
+const response = await vayu.customers.update('customer-id', {
+  name: 'Jane Doe',
+  alias: 'customer_67890'
+});
+
+console.log(response.customer);
+```
+
+#### Deleting a Customer
+
+To delete a customer by ID:
+
+```typescript
+const response = await vayu.customers.delete('customer-id');
+
+console.log(response.customer);
+```
+
+### Meters
+
+Meters are entities that track and aggregate usage data based on events. They are crucial for billing and monitoring purposes.
+
+#### Listing Meters
+
+To get a list of meters:
+
+```typescript
+const response = await vayu.meters.list({
+  limit: 10,
+  cursor: 'next-cursor'
+});
+
+console.log(response.meters);
+console.log(response.total);
+console.log(response.hasMore);
+console.log(response.nextCursor);
+```
+
+## Features
+
+The Vayu API client library provides access to the following features:
+
+- **Auth**
+  - `auth.login()`
+- **Events**
+  - `events.sendEvents()`
+  - `events.queryEvents()`
+  - `events.getEventByRefId()`
+  - `events.deleteEventByRefId()`
+  - `events.sendEventsDryRun()`
+- **Customers**
+  - `customers.createCustomer()`
+  - `customers.updateCustomer()`
+  - `customers.deleteCustomer()`
+  - `customers.listCustomers()`
+  - `customers.getCustomer()`
+- **Meters**
+  - `meters.getMeter()`
+  - `meters.updateMeter()`
+  - `meters.deleteMeter()`
+  - `meters.listMeters()`
+- **Plans**
+  - `plans.getPlan()`
+  - `plans.deletePlan()`
+  - `plans.listPlans()`
+- **Contracts**
+  - `contracts.createContract()`
+  - `contracts.deleteContract()`
+  - `contracts.listContracts()`
+  - `contracts.getContract()`
+- **Invoices**
+  - `invoices.getInvoice()`
+  - `invoices.listInvoices()`
+
+## Support
+
+If you have any questions or need further assistance, please contact Vayu at `team@withvayu.com`.
+
+## License
+
+This project is licensed under the MIT License.
+
+---
+
+This README provides an overview and usage examples for the Vayu API client library. For more detailed information on each method, please refer to the official Vayu API documentation.

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './sdk';

package/dist/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./sdk"), exports);

package/dist/openapi/apis/AuthApi.d.ts

@@ -0,0 +1,26 @@
+import { BaseAPIRequestFactory } from './baseapi';
+import { Configuration } from '../configuration';
+import { RequestContext, ResponseContext, HttpInfo } from '../http/http';
+import { LoginRequest } from '../models/LoginRequest';
+import { LoginResponse } from '../models/LoginResponse';
+/**
+ * no description
+ */
+export declare class AuthApiRequestFactory extends BaseAPIRequestFactory {
+    /**
+     * This endpoint is designed to acquire a temporary access token.     Submit the auth token in the request body to obtain a new access token.     Use this new token for subsequent API calls. Token is set to expire every hour.
+     * Login by obtaining a new access token
+     * @param loginRequest
+     */
+    login(loginRequest: LoginRequest, _options?: Configuration): Promise<RequestContext>;
+}
+export declare class AuthApiResponseProcessor {
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to login
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    loginWithHttpInfo(response: ResponseContext): Promise<HttpInfo<LoginResponse>>;
+}

package/dist/openapi/apis/AuthApi.js

@@ -0,0 +1,93 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthApiResponseProcessor = exports.AuthApiRequestFactory = void 0;
+// TODO: better import syntax?
+const baseapi_1 = require("./baseapi");
+const http_1 = require("../http/http");
+const ObjectSerializer_1 = require("../models/ObjectSerializer");
+const exception_1 = require("./exception");
+const util_1 = require("../util");
+/**
+ * no description
+ */
+class AuthApiRequestFactory extends baseapi_1.BaseAPIRequestFactory {
+    /**
+     * This endpoint is designed to acquire a temporary access token.     Submit the auth token in the request body to obtain a new access token.     Use this new token for subsequent API calls. Token is set to expire every hour.
+     * Login by obtaining a new access token
+     * @param loginRequest
+     */
+    login(loginRequest, _options) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            let _config = _options || this.configuration;
+            // verify required parameter 'loginRequest' is not null or undefined
+            if (loginRequest === null || loginRequest === undefined) {
+                throw new baseapi_1.RequiredError("AuthApi", "login", "loginRequest");
+            }
+            // Path Params
+            const localVarPath = '/login';
+            // Make Request Context
+            const requestContext = _config.baseServer.makeRequestContext(localVarPath, http_1.HttpMethod.POST);
+            requestContext.setHeaderParam("Accept", "application/json, */*;q=0.8");
+            // Body Params
+            const contentType = ObjectSerializer_1.ObjectSerializer.getPreferredMediaType([
+                "application/json"
+            ]);
+            requestContext.setHeaderParam("Content-Type", contentType);
+            const serializedBody = ObjectSerializer_1.ObjectSerializer.stringify(ObjectSerializer_1.ObjectSerializer.serialize(loginRequest, "LoginRequest", ""), contentType);
+            requestContext.setBody(serializedBody);
+            const defaultAuth = ((_a = _options === null || _options === void 0 ? void 0 : _options.authMethods) === null || _a === void 0 ? void 0 : _a.default) || ((_c = (_b = this.configuration) === null || _b === void 0 ? void 0 : _b.authMethods) === null || _c === void 0 ? void 0 : _c.default);
+            if (defaultAuth === null || defaultAuth === void 0 ? void 0 : defaultAuth.applySecurityAuthentication) {
+                yield (defaultAuth === null || defaultAuth === void 0 ? void 0 : defaultAuth.applySecurityAuthentication(requestContext));
+            }
+            return requestContext;
+        });
+    }
+}
+exports.AuthApiRequestFactory = AuthApiRequestFactory;
+class AuthApiResponseProcessor {
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to login
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    loginWithHttpInfo(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contentType = ObjectSerializer_1.ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+            if ((0, util_1.isCodeInRange)("200", response.httpStatusCode)) {
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "LoginResponse", "");
+                return new http_1.HttpInfo(response.httpStatusCode, response.headers, response.body, body);
+            }
+            if ((0, util_1.isCodeInRange)("400", response.httpStatusCode)) {
+                throw new exception_1.ApiException(response.httpStatusCode, "Bad Request", undefined, response.headers);
+            }
+            if ((0, util_1.isCodeInRange)("401", response.httpStatusCode)) {
+                throw new exception_1.ApiException(response.httpStatusCode, "Unauthorized", undefined, response.headers);
+            }
+            if ((0, util_1.isCodeInRange)("429", response.httpStatusCode)) {
+                throw new exception_1.ApiException(response.httpStatusCode, "Too Many Requests", undefined, response.headers);
+            }
+            if ((0, util_1.isCodeInRange)("500", response.httpStatusCode)) {
+                throw new exception_1.ApiException(response.httpStatusCode, "Internal Server Error", undefined, response.headers);
+            }
+            // Work around for missing responses in specification, e.g. for petstore.yaml
+            if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "LoginResponse", "");
+                return new http_1.HttpInfo(response.httpStatusCode, response.headers, response.body, body);
+            }
+            throw new exception_1.ApiException(response.httpStatusCode, "Unknown API Status Code!", yield response.getBodyAsAny(), response.headers);
+        });
+    }
+}
+exports.AuthApiResponseProcessor = AuthApiResponseProcessor;

package/dist/openapi/apis/ContractsApi.d.ts

@@ -0,0 +1,72 @@
+import { BaseAPIRequestFactory } from './baseapi';
+import { Configuration } from '../configuration';
+import { RequestContext, ResponseContext, HttpInfo } from '../http/http';
+import { CreateContractRequest } from '../models/CreateContractRequest';
+import { CreateContractResponse } from '../models/CreateContractResponse';
+import { DeleteContractResponse } from '../models/DeleteContractResponse';
+import { GetContractResponse } from '../models/GetContractResponse';
+import { ListContractsResponse } from '../models/ListContractsResponse';
+/**
+ * no description
+ */
+export declare class ContractsApiRequestFactory extends BaseAPIRequestFactory {
+    /**
+     * Create a new Contract.
+     * Create Contract
+     * @param createContractRequest
+     */
+    createContract(createContractRequest: CreateContractRequest, _options?: Configuration): Promise<RequestContext>;
+    /**
+     * Delete a Contract by id.
+     * Delete Contract
+     * @param contractId
+     */
+    deleteContract(contractId: string, _options?: Configuration): Promise<RequestContext>;
+    /**
+     * Get a Contract by id.
+     * Get Contract
+     * @param contractId
+     */
+    getContract(contractId: string, _options?: Configuration): Promise<RequestContext>;
+    /**
+     * Get a list of Contracts.
+     * List Contracts
+     * @param limit
+     * @param cursor
+     */
+    listContracts(limit?: number, cursor?: string, _options?: Configuration): Promise<RequestContext>;
+}
+export declare class ContractsApiResponseProcessor {
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to createContract
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    createContractWithHttpInfo(response: ResponseContext): Promise<HttpInfo<CreateContractResponse>>;
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to deleteContract
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    deleteContractWithHttpInfo(response: ResponseContext): Promise<HttpInfo<DeleteContractResponse>>;
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to getContract
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    getContractWithHttpInfo(response: ResponseContext): Promise<HttpInfo<GetContractResponse>>;
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to listContracts
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    listContractsWithHttpInfo(response: ResponseContext): Promise<HttpInfo<ListContractsResponse>>;
+}