vayu-ts 0.1.4 → 0.2.3

package/dist/openapi-v2/http/http.d.ts

@@ -0,0 +1,142 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import * as FormData from "form-data";
+import { URLSearchParams } from 'url';
+import * as http from 'http';
+import * as https from 'https';
+import { Observable } from '../rxjsStub';
+export * from './isomorphic-fetch';
+/**
+ * Represents an HTTP method.
+ */
+export declare enum HttpMethod {
+    GET = "GET",
+    HEAD = "HEAD",
+    POST = "POST",
+    PUT = "PUT",
+    DELETE = "DELETE",
+    CONNECT = "CONNECT",
+    OPTIONS = "OPTIONS",
+    TRACE = "TRACE",
+    PATCH = "PATCH"
+}
+/**
+ * Represents an HTTP file which will be transferred from or to a server.
+ */
+export type HttpFile = {
+    data: Buffer;
+    name: string;
+};
+export declare class HttpException extends Error {
+    constructor(msg: string);
+}
+/**
+ * Represents the body of an outgoing HTTP request.
+ */
+export type RequestBody = undefined | string | FormData | URLSearchParams;
+/**
+ * Represents an HTTP request context
+ */
+export declare class RequestContext {
+    private httpMethod;
+    private headers;
+    private body;
+    private url;
+    private agent;
+    /**
+     * Creates the request context using a http method and request resource url
+     *
+     * @param url url of the requested resource
+     * @param httpMethod http method
+     */
+    constructor(url: string, httpMethod: HttpMethod);
+    getUrl(): string;
+    /**
+     * Replaces the url set in the constructor with this url.
+     *
+     */
+    setUrl(url: string): void;
+    /**
+     * Sets the body of the http request either as a string or FormData
+     *
+     * Note that setting a body on a HTTP GET, HEAD, DELETE, CONNECT or TRACE
+     * request is discouraged.
+     * https://httpwg.org/http-core/draft-ietf-httpbis-semantics-latest.html#rfc.section.7.3.1
+     *
+     * @param body the body of the request
+     */
+    setBody(body: RequestBody): void;
+    getHttpMethod(): HttpMethod;
+    getHeaders(): {
+        [key: string]: string;
+    };
+    getBody(): RequestBody;
+    setQueryParam(name: string, value: string): void;
+    /**
+     * Sets a cookie with the name and value. NO check  for duplicate cookies is performed
+     *
+     */
+    addCookie(name: string, value: string): void;
+    setHeaderParam(key: string, value: string): void;
+    setAgent(agent: http.Agent | https.Agent): void;
+    getAgent(): http.Agent | https.Agent | undefined;
+}
+export interface ResponseBody {
+    text(): Promise<string>;
+    binary(): Promise<Buffer>;
+}
+/**
+ * Helper class to generate a `ResponseBody` from binary data
+ */
+export declare class SelfDecodingBody implements ResponseBody {
+    private dataSource;
+    constructor(dataSource: Promise<Buffer>);
+    binary(): Promise<Buffer>;
+    text(): Promise<string>;
+}
+export declare class ResponseContext {
+    httpStatusCode: number;
+    headers: {
+        [key: string]: string;
+    };
+    body: ResponseBody;
+    constructor(httpStatusCode: number, headers: {
+        [key: string]: string;
+    }, body: ResponseBody);
+    /**
+     * Parse header value in the form `value; param1="value1"`
+     *
+     * E.g. for Content-Type or Content-Disposition
+     * Parameter names are converted to lower case
+     * The first parameter is returned with the key `""`
+     */
+    getParsedHeader(headerName: string): {
+        [parameter: string]: string;
+    };
+    getBodyAsFile(): Promise<HttpFile>;
+    /**
+     * Use a heuristic to get a body of unknown data structure.
+     * Return as string if possible, otherwise as binary.
+     */
+    getBodyAsAny(): Promise<string | Buffer | undefined>;
+}
+export interface HttpLibrary {
+    send(request: RequestContext): Observable<ResponseContext>;
+}
+export interface PromiseHttpLibrary {
+    send(request: RequestContext): Promise<ResponseContext>;
+}
+export declare function wrapHttpLibrary(promiseHttpLibrary: PromiseHttpLibrary): HttpLibrary;
+export declare class HttpInfo<T> extends ResponseContext {
+    httpStatusCode: number;
+    headers: {
+        [key: string]: string;
+    };
+    body: ResponseBody;
+    data: T;
+    constructor(httpStatusCode: number, headers: {
+        [key: string]: string;
+    }, body: ResponseBody, data: T);
+}

package/dist/openapi-v2/http/http.js

@@ -0,0 +1,229 @@
+"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);
+};
+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.HttpInfo = exports.wrapHttpLibrary = exports.ResponseContext = exports.SelfDecodingBody = exports.RequestContext = exports.HttpException = exports.HttpMethod = void 0;
+const url_1 = require("url");
+const rxjsStub_1 = require("../rxjsStub");
+__exportStar(require("./isomorphic-fetch"), exports);
+/**
+ * Represents an HTTP method.
+ */
+var HttpMethod;
+(function (HttpMethod) {
+    HttpMethod["GET"] = "GET";
+    HttpMethod["HEAD"] = "HEAD";
+    HttpMethod["POST"] = "POST";
+    HttpMethod["PUT"] = "PUT";
+    HttpMethod["DELETE"] = "DELETE";
+    HttpMethod["CONNECT"] = "CONNECT";
+    HttpMethod["OPTIONS"] = "OPTIONS";
+    HttpMethod["TRACE"] = "TRACE";
+    HttpMethod["PATCH"] = "PATCH";
+})(HttpMethod = exports.HttpMethod || (exports.HttpMethod = {}));
+class HttpException extends Error {
+    constructor(msg) {
+        super(msg);
+    }
+}
+exports.HttpException = HttpException;
+function ensureAbsoluteUrl(url) {
+    if (url.startsWith("http://") || url.startsWith("https://")) {
+        return url;
+    }
+    throw new Error("You need to define an absolute base url for the server.");
+}
+/**
+ * Represents an HTTP request context
+ */
+class RequestContext {
+    /**
+     * Creates the request context using a http method and request resource url
+     *
+     * @param url url of the requested resource
+     * @param httpMethod http method
+     */
+    constructor(url, httpMethod) {
+        this.httpMethod = httpMethod;
+        this.headers = {};
+        this.body = undefined;
+        this.agent = undefined;
+        this.url = new url_1.URL(ensureAbsoluteUrl(url));
+    }
+    /*
+     * Returns the url set in the constructor including the query string
+     *
+     */
+    getUrl() {
+        return this.url.toString().endsWith("/") ?
+            this.url.toString().slice(0, -1)
+            : this.url.toString();
+    }
+    /**
+     * Replaces the url set in the constructor with this url.
+     *
+     */
+    setUrl(url) {
+        this.url = new url_1.URL(ensureAbsoluteUrl(url));
+    }
+    /**
+     * Sets the body of the http request either as a string or FormData
+     *
+     * Note that setting a body on a HTTP GET, HEAD, DELETE, CONNECT or TRACE
+     * request is discouraged.
+     * https://httpwg.org/http-core/draft-ietf-httpbis-semantics-latest.html#rfc.section.7.3.1
+     *
+     * @param body the body of the request
+     */
+    setBody(body) {
+        this.body = body;
+    }
+    getHttpMethod() {
+        return this.httpMethod;
+    }
+    getHeaders() {
+        return this.headers;
+    }
+    getBody() {
+        return this.body;
+    }
+    setQueryParam(name, value) {
+        this.url.searchParams.set(name, value);
+    }
+    /**
+     * Sets a cookie with the name and value. NO check  for duplicate cookies is performed
+     *
+     */
+    addCookie(name, value) {
+        if (!this.headers["Cookie"]) {
+            this.headers["Cookie"] = "";
+        }
+        this.headers["Cookie"] += name + "=" + value + "; ";
+    }
+    setHeaderParam(key, value) {
+        this.headers[key] = value;
+    }
+    setAgent(agent) {
+        this.agent = agent;
+    }
+    getAgent() {
+        return this.agent;
+    }
+}
+exports.RequestContext = RequestContext;
+/**
+ * Helper class to generate a `ResponseBody` from binary data
+ */
+class SelfDecodingBody {
+    constructor(dataSource) {
+        this.dataSource = dataSource;
+    }
+    binary() {
+        return this.dataSource;
+    }
+    text() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield this.dataSource;
+            return data.toString();
+        });
+    }
+}
+exports.SelfDecodingBody = SelfDecodingBody;
+class ResponseContext {
+    constructor(httpStatusCode, headers, body) {
+        this.httpStatusCode = httpStatusCode;
+        this.headers = headers;
+        this.body = body;
+    }
+    /**
+     * Parse header value in the form `value; param1="value1"`
+     *
+     * E.g. for Content-Type or Content-Disposition
+     * Parameter names are converted to lower case
+     * The first parameter is returned with the key `""`
+     */
+    getParsedHeader(headerName) {
+        const result = {};
+        if (!this.headers[headerName]) {
+            return result;
+        }
+        const parameters = this.headers[headerName].split(";");
+        for (const parameter of parameters) {
+            let [key, value] = parameter.split("=", 2);
+            key = key.toLowerCase().trim();
+            if (value === undefined) {
+                result[""] = key;
+            }
+            else {
+                value = value.trim();
+                if (value.startsWith('"') && value.endsWith('"')) {
+                    value = value.substring(1, value.length - 1);
+                }
+                result[key] = value;
+            }
+        }
+        return result;
+    }
+    getBodyAsFile() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield this.body.binary();
+            const fileName = this.getParsedHeader("content-disposition")["filename"] || "";
+            return { data, name: fileName };
+        });
+    }
+    /**
+     * Use a heuristic to get a body of unknown data structure.
+     * Return as string if possible, otherwise as binary.
+     */
+    getBodyAsAny() {
+        try {
+            return this.body.text();
+        }
+        catch (_a) { }
+        try {
+            return this.body.binary();
+        }
+        catch (_b) { }
+        return Promise.resolve(undefined);
+    }
+}
+exports.ResponseContext = ResponseContext;
+function wrapHttpLibrary(promiseHttpLibrary) {
+    return {
+        send(request) {
+            return (0, rxjsStub_1.from)(promiseHttpLibrary.send(request));
+        }
+    };
+}
+exports.wrapHttpLibrary = wrapHttpLibrary;
+class HttpInfo extends ResponseContext {
+    constructor(httpStatusCode, headers, body, data) {
+        super(httpStatusCode, headers, body);
+        this.httpStatusCode = httpStatusCode;
+        this.headers = headers;
+        this.body = body;
+        this.data = data;
+    }
+}
+exports.HttpInfo = HttpInfo;

package/dist/openapi-v2/http/isomorphic-fetch.d.ts

@@ -0,0 +1,5 @@
+import { HttpLibrary, RequestContext, ResponseContext } from './http';
+import { Observable } from '../rxjsStub';
+export declare class IsomorphicFetchHttpLibrary implements HttpLibrary {
+    send(request: RequestContext): Observable<ResponseContext>;
+}

package/dist/openapi-v2/http/isomorphic-fetch.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsomorphicFetchHttpLibrary = void 0;
+const http_1 = require("./http");
+const rxjsStub_1 = require("../rxjsStub");
+const node_fetch_1 = __importDefault(require("node-fetch"));
+class IsomorphicFetchHttpLibrary {
+    send(request) {
+        let method = request.getHttpMethod().toString();
+        let body = request.getBody();
+        const resultPromise = (0, node_fetch_1.default)(request.getUrl(), {
+            method: method,
+            body: body,
+            headers: request.getHeaders(),
+            agent: request.getAgent(),
+        }).then((resp) => {
+            const headers = {};
+            resp.headers.forEach((value, name) => {
+                headers[name] = value;
+            });
+            const body = {
+                text: () => resp.text(),
+                binary: () => resp.buffer()
+            };
+            return new http_1.ResponseContext(resp.status, headers, body);
+        });
+        return (0, rxjsStub_1.from)(resultPromise);
+    }
+}
+exports.IsomorphicFetchHttpLibrary = IsomorphicFetchHttpLibrary;

package/dist/openapi-v2/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./http/http";
+export * from "./auth/auth";
+export * from "./models/all";
+export { createConfiguration } from "./configuration";
+export { Configuration } from "./configuration";
+export * from "./apis/exception";
+export * from "./servers";
+export { RequiredError } from "./apis/baseapi";
+export { PromiseMiddleware as Middleware } from './middleware';
+export { PromiseAuthenticationApi as AuthenticationApi, PromiseCustomersApi as CustomersApi, PromiseEntitlementsApi as EntitlementsApi, PromiseEventsApi as EventsApi, PromiseInvoicesApi as InvoicesApi, PromiseProductsApi as ProductsApi } from './types/PromiseAPI';

package/dist/openapi-v2/index.js

@@ -0,0 +1,33 @@
+"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 });
+exports.ProductsApi = exports.InvoicesApi = exports.EventsApi = exports.EntitlementsApi = exports.CustomersApi = exports.AuthenticationApi = exports.RequiredError = exports.createConfiguration = void 0;
+__exportStar(require("./http/http"), exports);
+__exportStar(require("./auth/auth"), exports);
+__exportStar(require("./models/all"), exports);
+var configuration_1 = require("./configuration");
+Object.defineProperty(exports, "createConfiguration", { enumerable: true, get: function () { return configuration_1.createConfiguration; } });
+__exportStar(require("./apis/exception"), exports);
+__exportStar(require("./servers"), exports);
+var baseapi_1 = require("./apis/baseapi");
+Object.defineProperty(exports, "RequiredError", { enumerable: true, get: function () { return baseapi_1.RequiredError; } });
+var PromiseAPI_1 = require("./types/PromiseAPI");
+Object.defineProperty(exports, "AuthenticationApi", { enumerable: true, get: function () { return PromiseAPI_1.PromiseAuthenticationApi; } });
+Object.defineProperty(exports, "CustomersApi", { enumerable: true, get: function () { return PromiseAPI_1.PromiseCustomersApi; } });
+Object.defineProperty(exports, "EntitlementsApi", { enumerable: true, get: function () { return PromiseAPI_1.PromiseEntitlementsApi; } });
+Object.defineProperty(exports, "EventsApi", { enumerable: true, get: function () { return PromiseAPI_1.PromiseEventsApi; } });
+Object.defineProperty(exports, "InvoicesApi", { enumerable: true, get: function () { return PromiseAPI_1.PromiseInvoicesApi; } });
+Object.defineProperty(exports, "ProductsApi", { enumerable: true, get: function () { return PromiseAPI_1.PromiseProductsApi; } });

package/dist/openapi-v2/middleware.d.ts

@@ -0,0 +1,54 @@
+import { RequestContext, ResponseContext } from './http/http';
+import { Observable } from './rxjsStub';
+/**
+ * Defines the contract for a middleware intercepting requests before
+ * they are sent (but after the RequestContext was created)
+ * and before the ResponseContext is unwrapped.
+ *
+ */
+export interface Middleware {
+    /**
+     * Modifies the request before the request is sent.
+     *
+     * @param context RequestContext of a request which is about to be sent to the server
+     * @returns an observable of the updated request context
+     *
+     */
+    pre(context: RequestContext): Observable<RequestContext>;
+    /**
+     * Modifies the returned response before it is deserialized.
+     *
+     * @param context ResponseContext of a sent request
+     * @returns an observable of the modified response context
+     */
+    post(context: ResponseContext): Observable<ResponseContext>;
+}
+export declare class PromiseMiddlewareWrapper implements Middleware {
+    private middleware;
+    constructor(middleware: PromiseMiddleware);
+    pre(context: RequestContext): Observable<RequestContext>;
+    post(context: ResponseContext): Observable<ResponseContext>;
+}
+/**
+ * Defines the contract for a middleware intercepting requests before
+ * they are sent (but after the RequestContext was created)
+ * and before the ResponseContext is unwrapped.
+ *
+ */
+export interface PromiseMiddleware {
+    /**
+     * Modifies the request before the request is sent.
+     *
+     * @param context RequestContext of a request which is about to be sent to the server
+     * @returns an observable of the updated request context
+     *
+     */
+    pre(context: RequestContext): Promise<RequestContext>;
+    /**
+ * Modifies the returned response before it is deserialized.
+ *
+ * @param context ResponseContext of a sent request
+ * @returns an observable of the modified response context
+ */
+    post(context: ResponseContext): Promise<ResponseContext>;
+}

package/dist/openapi-v2/middleware.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromiseMiddlewareWrapper = void 0;
+const rxjsStub_1 = require("./rxjsStub");
+class PromiseMiddlewareWrapper {
+    constructor(middleware) {
+        this.middleware = middleware;
+    }
+    pre(context) {
+        return (0, rxjsStub_1.from)(this.middleware.pre(context));
+    }
+    post(context) {
+        return (0, rxjsStub_1.from)(this.middleware.post(context));
+    }
+}
+exports.PromiseMiddlewareWrapper = PromiseMiddlewareWrapper;

package/dist/openapi-v2/models/APICreateCustomerPayload.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 24k
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * OpenAPI spec version: 1.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+export declare class APICreateCustomerPayload {
+    /**
+    * Name
+    */
+    'name': string;
+    /**
+    * External ID
+    */
+    'externalId': string;
+    /**
+    * Construct a type with a set of properties K of type T
+    */
+    'metadata'?: {
+        [key: string]: any;
+    };
+    /**
+    * Aliases
+    */
+    'aliases'?: Array<string>;
+    static readonly discriminator: string | undefined;
+    static readonly attributeTypeMap: Array<{
+        name: string;
+        baseName: string;
+        type: string;
+        format: string;
+    }>;
+    static getAttributeTypeMap(): {
+        name: string;
+        baseName: string;
+        type: string;
+        format: string;
+    }[];
+    constructor();
+}

package/dist/openapi-v2/models/APICreateCustomerPayload.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * 24k
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * OpenAPI spec version: 1.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APICreateCustomerPayload = void 0;
+class APICreateCustomerPayload {
+    static getAttributeTypeMap() {
+        return APICreateCustomerPayload.attributeTypeMap;
+    }
+    constructor() {
+    }
+}
+exports.APICreateCustomerPayload = APICreateCustomerPayload;
+APICreateCustomerPayload.discriminator = undefined;
+APICreateCustomerPayload.attributeTypeMap = [
+    {
+        "name": "name",
+        "baseName": "name",
+        "type": "string",
+        "format": ""
+    },
+    {
+        "name": "externalId",
+        "baseName": "externalId",
+        "type": "string",
+        "format": ""
+    },
+    {
+        "name": "metadata",
+        "baseName": "metadata",
+        "type": "{ [key: string]: any; }",
+        "format": ""
+    },
+    {
+        "name": "aliases",
+        "baseName": "aliases",
+        "type": "Array<string>",
+        "format": ""
+    }
+];

package/dist/openapi-v2/models/APICreateInvoicePayload.d.ts

@@ -0,0 +1,41 @@
+/**
+ * 24k
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * OpenAPI spec version: 1.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import { APIInvoiceBillingPeriod } from '../models/APIInvoiceBillingPeriod';
+export declare class APICreateInvoicePayload {
+    /**
+    * Name
+    */
+    'name': string;
+    /**
+    * Customer ID
+    */
+    'customerId': string;
+    /**
+    * Products
+    */
+    'products': Array<string>;
+    'billingPeriod': APIInvoiceBillingPeriod;
+    static readonly discriminator: string | undefined;
+    static readonly attributeTypeMap: Array<{
+        name: string;
+        baseName: string;
+        type: string;
+        format: string;
+    }>;
+    static getAttributeTypeMap(): {
+        name: string;
+        baseName: string;
+        type: string;
+        format: string;
+    }[];
+    constructor();
+}