vayu-ts 0.1.3 → 0.2.1

package/dist/openapi-v2/types/PromiseAPI.d.ts

@@ -0,0 +1,234 @@
+import { HttpInfo } from '../http/http';
+import { Configuration } from '../configuration';
+import { APICreateCustomerPayload } from '../models/APICreateCustomerPayload';
+import { APICreateInvoicePayload } from '../models/APICreateInvoicePayload';
+import { APICreateProductPayload } from '../models/APICreateProductPayload';
+import { APICustomer } from '../models/APICustomer';
+import { APIEvent } from '../models/APIEvent';
+import { APIIngestEventPayload } from '../models/APIIngestEventPayload';
+import { APIInvoice } from '../models/APIInvoice';
+import { APIProduct } from '../models/APIProduct';
+import { APIQueryPayloadAPICustomer } from '../models/APIQueryPayloadAPICustomer';
+import { APIQueryPayloadAPIEvent } from '../models/APIQueryPayloadAPIEvent';
+import { APIQueryPayloadAPIInvoice } from '../models/APIQueryPayloadAPIInvoice';
+import { APIQueryPayloadAPIProduct } from '../models/APIQueryPayloadAPIProduct';
+import { APIUpdateCustomerPayload } from '../models/APIUpdateCustomerPayload';
+import { APIUpdateInvoicePayload } from '../models/APIUpdateInvoicePayload';
+import { APIUpdateProductPayload } from '../models/APIUpdateProductPayload';
+import { IngestEventToTheSystem201Response } from '../models/IngestEventToTheSystem201Response';
+import { Login200Response } from '../models/Login200Response';
+import { LoginRequest } from '../models/LoginRequest';
+import { QueryResultAPICustomer } from '../models/QueryResultAPICustomer';
+import { QueryResultAPIEvent } from '../models/QueryResultAPIEvent';
+import { QueryResultAPIInvoice } from '../models/QueryResultAPIInvoice';
+import { QueryResultAPIProduct } from '../models/QueryResultAPIProduct';
+import { ReviseProductPayload } from '../models/ReviseProductPayload';
+import { AuthenticationApiRequestFactory, AuthenticationApiResponseProcessor } from "../apis/AuthenticationApi";
+export declare class PromiseAuthenticationApi {
+    private api;
+    constructor(configuration: Configuration, requestFactory?: AuthenticationApiRequestFactory, responseProcessor?: AuthenticationApiResponseProcessor);
+    /**
+     * @param loginRequest
+     */
+    loginWithHttpInfo(loginRequest: LoginRequest, _options?: Configuration): Promise<HttpInfo<Login200Response>>;
+    /**
+     * @param loginRequest
+     */
+    login(loginRequest: LoginRequest, _options?: Configuration): Promise<Login200Response>;
+}
+import { CustomersApiRequestFactory, CustomersApiResponseProcessor } from "../apis/CustomersApi";
+export declare class PromiseCustomersApi {
+    private api;
+    constructor(configuration: Configuration, requestFactory?: CustomersApiRequestFactory, responseProcessor?: CustomersApiResponseProcessor);
+    /**
+     * @param aPICreateCustomerPayload
+     */
+    createCustomerWithHttpInfo(aPICreateCustomerPayload: APICreateCustomerPayload, _options?: Configuration): Promise<HttpInfo<APICustomer>>;
+    /**
+     * @param aPICreateCustomerPayload
+     */
+    createCustomer(aPICreateCustomerPayload: APICreateCustomerPayload, _options?: Configuration): Promise<APICustomer>;
+    /**
+     * @param id
+     */
+    deleteCustomerWithHttpInfo(id: string, _options?: Configuration): Promise<HttpInfo<void>>;
+    /**
+     * @param id
+     */
+    deleteCustomer(id: string, _options?: Configuration): Promise<void>;
+    /**
+     * @param id
+     */
+    getCustomerWithHttpInfo(id: string, _options?: Configuration): Promise<HttpInfo<APICustomer>>;
+    /**
+     * @param id
+     */
+    getCustomer(id: string, _options?: Configuration): Promise<APICustomer>;
+    /**
+     * @param aPIQueryPayloadAPICustomer
+     */
+    queryCustomersWithHttpInfo(aPIQueryPayloadAPICustomer: APIQueryPayloadAPICustomer, _options?: Configuration): Promise<HttpInfo<QueryResultAPICustomer>>;
+    /**
+     * @param aPIQueryPayloadAPICustomer
+     */
+    queryCustomers(aPIQueryPayloadAPICustomer: APIQueryPayloadAPICustomer, _options?: Configuration): Promise<QueryResultAPICustomer>;
+    /**
+     * @param aPIUpdateCustomerPayload
+     * @param id
+     */
+    updateCustomerWithHttpInfo(aPIUpdateCustomerPayload: APIUpdateCustomerPayload, id: string, _options?: Configuration): Promise<HttpInfo<APICustomer>>;
+    /**
+     * @param aPIUpdateCustomerPayload
+     * @param id
+     */
+    updateCustomer(aPIUpdateCustomerPayload: APIUpdateCustomerPayload, id: string, _options?: Configuration): Promise<APICustomer>;
+}
+import { EventsApiRequestFactory, EventsApiResponseProcessor } from "../apis/EventsApi";
+export declare class PromiseEventsApi {
+    private api;
+    constructor(configuration: Configuration, requestFactory?: EventsApiRequestFactory, responseProcessor?: EventsApiResponseProcessor);
+    /**
+     * @param id
+     */
+    deleteEventWithHttpInfo(id: string, _options?: Configuration): Promise<HttpInfo<void>>;
+    /**
+     * @param id
+     */
+    deleteEvent(id: string, _options?: Configuration): Promise<void>;
+    /**
+     * @param id
+     */
+    getEventWithHttpInfo(id: string, _options?: Configuration): Promise<HttpInfo<APIEvent>>;
+    /**
+     * @param id
+     */
+    getEvent(id: string, _options?: Configuration): Promise<APIEvent>;
+    /**
+     * @param aPIIngestEventPayload
+     */
+    ingestEventToTheSystemWithHttpInfo(aPIIngestEventPayload: Array<APIIngestEventPayload>, _options?: Configuration): Promise<HttpInfo<IngestEventToTheSystem201Response>>;
+    /**
+     * @param aPIIngestEventPayload
+     */
+    ingestEventToTheSystem(aPIIngestEventPayload: Array<APIIngestEventPayload>, _options?: Configuration): Promise<IngestEventToTheSystem201Response>;
+    /**
+     * @param aPIQueryPayloadAPIEvent
+     */
+    queryEventsWithHttpInfo(aPIQueryPayloadAPIEvent: APIQueryPayloadAPIEvent, _options?: Configuration): Promise<HttpInfo<QueryResultAPIEvent>>;
+    /**
+     * @param aPIQueryPayloadAPIEvent
+     */
+    queryEvents(aPIQueryPayloadAPIEvent: APIQueryPayloadAPIEvent, _options?: Configuration): Promise<QueryResultAPIEvent>;
+}
+import { InvoicesApiRequestFactory, InvoicesApiResponseProcessor } from "../apis/InvoicesApi";
+export declare class PromiseInvoicesApi {
+    private api;
+    constructor(configuration: Configuration, requestFactory?: InvoicesApiRequestFactory, responseProcessor?: InvoicesApiResponseProcessor);
+    /**
+     * @param id
+     */
+    calculateInvoiceWithHttpInfo(id: string, _options?: Configuration): Promise<HttpInfo<APIInvoice>>;
+    /**
+     * @param id
+     */
+    calculateInvoice(id: string, _options?: Configuration): Promise<APIInvoice>;
+    /**
+     * @param aPICreateInvoicePayload
+     */
+    createInvoiceWithHttpInfo(aPICreateInvoicePayload: APICreateInvoicePayload, _options?: Configuration): Promise<HttpInfo<APIInvoice>>;
+    /**
+     * @param aPICreateInvoicePayload
+     */
+    createInvoice(aPICreateInvoicePayload: APICreateInvoicePayload, _options?: Configuration): Promise<APIInvoice>;
+    /**
+     * @param id
+     */
+    deleteInvoiceWithHttpInfo(id: string, _options?: Configuration): Promise<HttpInfo<void>>;
+    /**
+     * @param id
+     */
+    deleteInvoice(id: string, _options?: Configuration): Promise<void>;
+    /**
+     * @param id
+     */
+    getInvoiceWithHttpInfo(id: string, _options?: Configuration): Promise<HttpInfo<APIInvoice>>;
+    /**
+     * @param id
+     */
+    getInvoice(id: string, _options?: Configuration): Promise<APIInvoice>;
+    /**
+     * @param aPIQueryPayloadAPIInvoice
+     */
+    queryInvoicesWithHttpInfo(aPIQueryPayloadAPIInvoice: APIQueryPayloadAPIInvoice, _options?: Configuration): Promise<HttpInfo<QueryResultAPIInvoice>>;
+    /**
+     * @param aPIQueryPayloadAPIInvoice
+     */
+    queryInvoices(aPIQueryPayloadAPIInvoice: APIQueryPayloadAPIInvoice, _options?: Configuration): Promise<QueryResultAPIInvoice>;
+    /**
+     * @param aPIUpdateInvoicePayload
+     * @param id
+     */
+    updateInvoiceWithHttpInfo(aPIUpdateInvoicePayload: APIUpdateInvoicePayload, id: string, _options?: Configuration): Promise<HttpInfo<APIInvoice>>;
+    /**
+     * @param aPIUpdateInvoicePayload
+     * @param id
+     */
+    updateInvoice(aPIUpdateInvoicePayload: APIUpdateInvoicePayload, id: string, _options?: Configuration): Promise<APIInvoice>;
+}
+import { ProductsApiRequestFactory, ProductsApiResponseProcessor } from "../apis/ProductsApi";
+export declare class PromiseProductsApi {
+    private api;
+    constructor(configuration: Configuration, requestFactory?: ProductsApiRequestFactory, responseProcessor?: ProductsApiResponseProcessor);
+    /**
+     * @param aPICreateProductPayload
+     */
+    createProductWithHttpInfo(aPICreateProductPayload: APICreateProductPayload, _options?: Configuration): Promise<HttpInfo<APIProduct>>;
+    /**
+     * @param aPICreateProductPayload
+     */
+    createProduct(aPICreateProductPayload: APICreateProductPayload, _options?: Configuration): Promise<APIProduct>;
+    /**
+     * @param id
+     */
+    deleteProductWithHttpInfo(id: string, _options?: Configuration): Promise<HttpInfo<void>>;
+    /**
+     * @param id
+     */
+    deleteProduct(id: string, _options?: Configuration): Promise<void>;
+    /**
+     * @param id
+     */
+    getProductWithHttpInfo(id: string, _options?: Configuration): Promise<HttpInfo<APIProduct>>;
+    /**
+     * @param id
+     */
+    getProduct(id: string, _options?: Configuration): Promise<APIProduct>;
+    /**
+     * @param aPIQueryPayloadAPIProduct
+     */
+    queryProductsWithHttpInfo(aPIQueryPayloadAPIProduct: APIQueryPayloadAPIProduct, _options?: Configuration): Promise<HttpInfo<QueryResultAPIProduct>>;
+    /**
+     * @param aPIQueryPayloadAPIProduct
+     */
+    queryProducts(aPIQueryPayloadAPIProduct: APIQueryPayloadAPIProduct, _options?: Configuration): Promise<QueryResultAPIProduct>;
+    /**
+     * @param body
+     * @param id
+     */
+    reviseAProductWithHttpInfo(body: ReviseProductPayload, id: string, _options?: Configuration): Promise<HttpInfo<APIProduct>>;
+    /**
+     * @param body
+     * @param id
+     */
+    reviseAProduct(body: ReviseProductPayload, id: string, _options?: Configuration): Promise<APIProduct>;
+    /**
+     * @param aPIUpdateProductPayload
+     * @param id
+     */
+    updateProductWithHttpInfo(aPIUpdateProductPayload: APIUpdateProductPayload, id: string, _options?: Configuration): Promise<HttpInfo<APIProduct>>;
+    /**
+     * @param aPIUpdateProductPayload
+     * @param id
+     */
+    updateProduct(aPIUpdateProductPayload: APIUpdateProductPayload, id: string, _options?: Configuration): Promise<APIProduct>;
+}

package/dist/openapi-v2/types/PromiseAPI.js

@@ -0,0 +1,354 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromiseProductsApi = exports.PromiseInvoicesApi = exports.PromiseEventsApi = exports.PromiseCustomersApi = exports.PromiseAuthenticationApi = void 0;
+const ObservableAPI_1 = require("./ObservableAPI");
+class PromiseAuthenticationApi {
+    constructor(configuration, requestFactory, responseProcessor) {
+        this.api = new ObservableAPI_1.ObservableAuthenticationApi(configuration, requestFactory, responseProcessor);
+    }
+    /**
+     * @param loginRequest
+     */
+    loginWithHttpInfo(loginRequest, _options) {
+        const result = this.api.loginWithHttpInfo(loginRequest, _options);
+        return result.toPromise();
+    }
+    /**
+     * @param loginRequest
+     */
+    login(loginRequest, _options) {
+        const result = this.api.login(loginRequest, _options);
+        return result.toPromise();
+    }
+}
+exports.PromiseAuthenticationApi = PromiseAuthenticationApi;
+const ObservableAPI_2 = require("./ObservableAPI");
+class PromiseCustomersApi {
+    constructor(configuration, requestFactory, responseProcessor) {
+        this.api = new ObservableAPI_2.ObservableCustomersApi(configuration, requestFactory, responseProcessor);
+    }
+    /**
+     * @param aPICreateCustomerPayload
+     */
+    createCustomerWithHttpInfo(aPICreateCustomerPayload, _options) {
+        const result = this.api.createCustomerWithHttpInfo(aPICreateCustomerPayload, _options);
+        return result.toPromise();
+    }
+    /**
+     * @param aPICreateCustomerPayload
+     */
+    createCustomer(aPICreateCustomerPayload, _options) {
+        const result = this.api.createCustomer(aPICreateCustomerPayload, _options);
+        return result.toPromise();
+    }
+    /**
+     * @param id
+     */
+    deleteCustomerWithHttpInfo(id, _options) {
+        const result = this.api.deleteCustomerWithHttpInfo(id, _options);
+        return result.toPromise();
+    }
+    /**
+     * @param id
+     */
+    deleteCustomer(id, _options) {
+        const result = this.api.deleteCustomer(id, _options);
+        return result.toPromise();
+    }
+    /**
+     * @param id
+     */
+    getCustomerWithHttpInfo(id, _options) {
+        const result = this.api.getCustomerWithHttpInfo(id, _options);
+        return result.toPromise();
+    }
+    /**
+     * @param id
+     */
+    getCustomer(id, _options) {
+        const result = this.api.getCustomer(id, _options);
+        return result.toPromise();
+    }
+    /**
+     * @param aPIQueryPayloadAPICustomer
+     */
+    queryCustomersWithHttpInfo(aPIQueryPayloadAPICustomer, _options) {
+        const result = this.api.queryCustomersWithHttpInfo(aPIQueryPayloadAPICustomer, _options);
+        return result.toPromise();
+    }
+    /**
+     * @param aPIQueryPayloadAPICustomer
+     */
+    queryCustomers(aPIQueryPayloadAPICustomer, _options) {
+        const result = this.api.queryCustomers(aPIQueryPayloadAPICustomer, _options);
+        return result.toPromise();
+    }
+    /**
+     * @param aPIUpdateCustomerPayload
+     * @param id
+     */
+    updateCustomerWithHttpInfo(aPIUpdateCustomerPayload, id, _options) {
+        const result = this.api.updateCustomerWithHttpInfo(aPIUpdateCustomerPayload, id, _options);
+        return result.toPromise();
+    }
+    /**
+     * @param aPIUpdateCustomerPayload
+     * @param id
+     */
+    updateCustomer(aPIUpdateCustomerPayload, id, _options) {
+        const result = this.api.updateCustomer(aPIUpdateCustomerPayload, id, _options);
+        return result.toPromise();
+    }
+}
+exports.PromiseCustomersApi = PromiseCustomersApi;
+const ObservableAPI_3 = require("./ObservableAPI");
+class PromiseEventsApi {
+    constructor(configuration, requestFactory, responseProcessor) {
+        this.api = new ObservableAPI_3.ObservableEventsApi(configuration, requestFactory, responseProcessor);
+    }
+    /**
+     * @param id
+     */
+    deleteEventWithHttpInfo(id, _options) {
+        const result = this.api.deleteEventWithHttpInfo(id, _options);
+        return result.toPromise();
+    }
+    /**
+     * @param id
+     */
+    deleteEvent(id, _options) {
+        const result = this.api.deleteEvent(id, _options);
+        return result.toPromise();
+    }
+    /**
+     * @param id
+     */
+    getEventWithHttpInfo(id, _options) {
+        const result = this.api.getEventWithHttpInfo(id, _options);
+        return result.toPromise();
+    }
+    /**
+     * @param id
+     */
+    getEvent(id, _options) {
+        const result = this.api.getEvent(id, _options);
+        return result.toPromise();
+    }
+    /**
+     * @param aPIIngestEventPayload
+     */
+    ingestEventToTheSystemWithHttpInfo(aPIIngestEventPayload, _options) {
+        const result = this.api.ingestEventToTheSystemWithHttpInfo(aPIIngestEventPayload, _options);
+        return result.toPromise();
+    }
+    /**
+     * @param aPIIngestEventPayload
+     */
+    ingestEventToTheSystem(aPIIngestEventPayload, _options) {
+        const result = this.api.ingestEventToTheSystem(aPIIngestEventPayload, _options);
+        return result.toPromise();
+    }
+    /**
+     * @param aPIQueryPayloadAPIEvent
+     */
+    queryEventsWithHttpInfo(aPIQueryPayloadAPIEvent, _options) {
+        const result = this.api.queryEventsWithHttpInfo(aPIQueryPayloadAPIEvent, _options);
+        return result.toPromise();
+    }
+    /**
+     * @param aPIQueryPayloadAPIEvent
+     */
+    queryEvents(aPIQueryPayloadAPIEvent, _options) {
+        const result = this.api.queryEvents(aPIQueryPayloadAPIEvent, _options);
+        return result.toPromise();
+    }
+}
+exports.PromiseEventsApi = PromiseEventsApi;
+const ObservableAPI_4 = require("./ObservableAPI");
+class PromiseInvoicesApi {
+    constructor(configuration, requestFactory, responseProcessor) {
+        this.api = new ObservableAPI_4.ObservableInvoicesApi(configuration, requestFactory, responseProcessor);
+    }
+    /**
+     * @param id
+     */
+    calculateInvoiceWithHttpInfo(id, _options) {
+        const result = this.api.calculateInvoiceWithHttpInfo(id, _options);
+        return result.toPromise();
+    }
+    /**
+     * @param id
+     */
+    calculateInvoice(id, _options) {
+        const result = this.api.calculateInvoice(id, _options);
+        return result.toPromise();
+    }
+    /**
+     * @param aPICreateInvoicePayload
+     */
+    createInvoiceWithHttpInfo(aPICreateInvoicePayload, _options) {
+        const result = this.api.createInvoiceWithHttpInfo(aPICreateInvoicePayload, _options);
+        return result.toPromise();
+    }
+    /**
+     * @param aPICreateInvoicePayload
+     */
+    createInvoice(aPICreateInvoicePayload, _options) {
+        const result = this.api.createInvoice(aPICreateInvoicePayload, _options);
+        return result.toPromise();
+    }
+    /**
+     * @param id
+     */
+    deleteInvoiceWithHttpInfo(id, _options) {
+        const result = this.api.deleteInvoiceWithHttpInfo(id, _options);
+        return result.toPromise();
+    }
+    /**
+     * @param id
+     */
+    deleteInvoice(id, _options) {
+        const result = this.api.deleteInvoice(id, _options);
+        return result.toPromise();
+    }
+    /**
+     * @param id
+     */
+    getInvoiceWithHttpInfo(id, _options) {
+        const result = this.api.getInvoiceWithHttpInfo(id, _options);
+        return result.toPromise();
+    }
+    /**
+     * @param id
+     */
+    getInvoice(id, _options) {
+        const result = this.api.getInvoice(id, _options);
+        return result.toPromise();
+    }
+    /**
+     * @param aPIQueryPayloadAPIInvoice
+     */
+    queryInvoicesWithHttpInfo(aPIQueryPayloadAPIInvoice, _options) {
+        const result = this.api.queryInvoicesWithHttpInfo(aPIQueryPayloadAPIInvoice, _options);
+        return result.toPromise();
+    }
+    /**
+     * @param aPIQueryPayloadAPIInvoice
+     */
+    queryInvoices(aPIQueryPayloadAPIInvoice, _options) {
+        const result = this.api.queryInvoices(aPIQueryPayloadAPIInvoice, _options);
+        return result.toPromise();
+    }
+    /**
+     * @param aPIUpdateInvoicePayload
+     * @param id
+     */
+    updateInvoiceWithHttpInfo(aPIUpdateInvoicePayload, id, _options) {
+        const result = this.api.updateInvoiceWithHttpInfo(aPIUpdateInvoicePayload, id, _options);
+        return result.toPromise();
+    }
+    /**
+     * @param aPIUpdateInvoicePayload
+     * @param id
+     */
+    updateInvoice(aPIUpdateInvoicePayload, id, _options) {
+        const result = this.api.updateInvoice(aPIUpdateInvoicePayload, id, _options);
+        return result.toPromise();
+    }
+}
+exports.PromiseInvoicesApi = PromiseInvoicesApi;
+const ObservableAPI_5 = require("./ObservableAPI");
+class PromiseProductsApi {
+    constructor(configuration, requestFactory, responseProcessor) {
+        this.api = new ObservableAPI_5.ObservableProductsApi(configuration, requestFactory, responseProcessor);
+    }
+    /**
+     * @param aPICreateProductPayload
+     */
+    createProductWithHttpInfo(aPICreateProductPayload, _options) {
+        const result = this.api.createProductWithHttpInfo(aPICreateProductPayload, _options);
+        return result.toPromise();
+    }
+    /**
+     * @param aPICreateProductPayload
+     */
+    createProduct(aPICreateProductPayload, _options) {
+        const result = this.api.createProduct(aPICreateProductPayload, _options);
+        return result.toPromise();
+    }
+    /**
+     * @param id
+     */
+    deleteProductWithHttpInfo(id, _options) {
+        const result = this.api.deleteProductWithHttpInfo(id, _options);
+        return result.toPromise();
+    }
+    /**
+     * @param id
+     */
+    deleteProduct(id, _options) {
+        const result = this.api.deleteProduct(id, _options);
+        return result.toPromise();
+    }
+    /**
+     * @param id
+     */
+    getProductWithHttpInfo(id, _options) {
+        const result = this.api.getProductWithHttpInfo(id, _options);
+        return result.toPromise();
+    }
+    /**
+     * @param id
+     */
+    getProduct(id, _options) {
+        const result = this.api.getProduct(id, _options);
+        return result.toPromise();
+    }
+    /**
+     * @param aPIQueryPayloadAPIProduct
+     */
+    queryProductsWithHttpInfo(aPIQueryPayloadAPIProduct, _options) {
+        const result = this.api.queryProductsWithHttpInfo(aPIQueryPayloadAPIProduct, _options);
+        return result.toPromise();
+    }
+    /**
+     * @param aPIQueryPayloadAPIProduct
+     */
+    queryProducts(aPIQueryPayloadAPIProduct, _options) {
+        const result = this.api.queryProducts(aPIQueryPayloadAPIProduct, _options);
+        return result.toPromise();
+    }
+    /**
+     * @param body
+     * @param id
+     */
+    reviseAProductWithHttpInfo(body, id, _options) {
+        const result = this.api.reviseAProductWithHttpInfo(body, id, _options);
+        return result.toPromise();
+    }
+    /**
+     * @param body
+     * @param id
+     */
+    reviseAProduct(body, id, _options) {
+        const result = this.api.reviseAProduct(body, id, _options);
+        return result.toPromise();
+    }
+    /**
+     * @param aPIUpdateProductPayload
+     * @param id
+     */
+    updateProductWithHttpInfo(aPIUpdateProductPayload, id, _options) {
+        const result = this.api.updateProductWithHttpInfo(aPIUpdateProductPayload, id, _options);
+        return result.toPromise();
+    }
+    /**
+     * @param aPIUpdateProductPayload
+     * @param id
+     */
+    updateProduct(aPIUpdateProductPayload, id, _options) {
+        const result = this.api.updateProduct(aPIUpdateProductPayload, id, _options);
+        return result.toPromise();
+    }
+}
+exports.PromiseProductsApi = PromiseProductsApi;

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

@@ -0,0 +1,15 @@
+/**
+ * Returns if a specific http code is in a given code range
+ * where the code range is defined as a combination of digits
+ * and "X" (the letter X) with a length of 3
+ *
+ * @param codeRange string with length 3 consisting of digits and "X" (the letter X)
+ * @param code the http status code to be checked against the code range
+ */
+export declare function isCodeInRange(codeRange: string, code: number): boolean;
+/**
+* Returns if it can consume form
+*
+* @param consumes array
+*/
+export declare function canConsumeForm(contentTypes: string[]): boolean;

package/dist/openapi-v2/util.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canConsumeForm = exports.isCodeInRange = void 0;
+/**
+ * Returns if a specific http code is in a given code range
+ * where the code range is defined as a combination of digits
+ * and "X" (the letter X) with a length of 3
+ *
+ * @param codeRange string with length 3 consisting of digits and "X" (the letter X)
+ * @param code the http status code to be checked against the code range
+ */
+function isCodeInRange(codeRange, code) {
+    // This is how the default value is encoded in OAG
+    if (codeRange === "0") {
+        return true;
+    }
+    if (codeRange == code.toString()) {
+        return true;
+    }
+    else {
+        const codeString = code.toString();
+        if (codeString.length != codeRange.length) {
+            return false;
+        }
+        for (let i = 0; i < codeString.length; i++) {
+            if (codeRange.charAt(i) != "X" && codeRange.charAt(i) != codeString.charAt(i)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+exports.isCodeInRange = isCodeInRange;
+/**
+* Returns if it can consume form
+*
+* @param consumes array
+*/
+function canConsumeForm(contentTypes) {
+    return contentTypes.indexOf('multipart/form-data') !== -1;
+}
+exports.canConsumeForm = canConsumeForm;

package/dist/sdk/clients/ContractsClient.d.ts

@@ -0,0 +1,10 @@
+import type { CreateContractRequest } from '../../openapi';
+import type { PaginationOptions } from '../types';
+export declare class ContractsClient {
+    private client;
+    constructor();
+    list(pagination?: PaginationOptions): Promise<import("../types").ListContractsResponse>;
+    get(id: string): Promise<import("../types").GetContractResponse>;
+    create(payload: CreateContractRequest): Promise<import("../types").CreateContractResponse>;
+    delete(id: string): Promise<import("../types").DeleteContractResponse>;
+}