@chainstream-io/sdk 0.0.1

package/src/openapi/apis/WalletApi.ts

@@ -0,0 +1,364 @@
+// TODO: better import syntax?
+import {BaseAPIRequestFactory, RequiredError, COLLECTION_FORMATS} from './baseapi';
+import {Configuration} from '../configuration';
+import {RequestContext, HttpMethod, ResponseContext, HttpFile, HttpInfo} from '../http/http';
+import {ObjectSerializer} from '../models/ObjectSerializer';
+import {ApiException} from './exception';
+import {canConsumeForm, isCodeInRange} from '../util';
+import {SecurityAuthentication} from '../auth/auth';
+
+
+import { CalculatePnlInput } from '../models/CalculatePnlInput';
+import { WalletBalancesDTO } from '../models/WalletBalancesDTO';
+import { WalletPnlDTO } from '../models/WalletPnlDTO';
+
+/**
+ * no description
+ */
+export class WalletApiRequestFactory extends BaseAPIRequestFactory {
+
+    /**
+     * CONTROLLER.WALLET.CALCULATE_PNL.DESCRIPTION
+     * CONTROLLER.WALLET.CALCULATE_PNL.SUMMARY
+     * @param chain GLOBAL.CHAIN.DESCRIPTION
+     * @param walletAddress GLOBAL.WALLETADDRESS.DESCRIPTION
+     * @param calculatePnlInput 
+     */
+    public async calculatePnl(chain: 'sol' | 'base' | 'bsc' | 'polygon' | 'arbitrum' | 'optimism' | 'avalanche' | 'ethereum' | 'zksync' | 'sui', walletAddress: string, calculatePnlInput: CalculatePnlInput, _options?: Configuration): Promise<RequestContext> {
+        let _config = _options || this.configuration;
+
+        // verify required parameter 'chain' is not null or undefined
+        if (chain === null || chain === undefined) {
+            throw new RequiredError("WalletApi", "calculatePnl", "chain");
+        }
+
+
+        // verify required parameter 'walletAddress' is not null or undefined
+        if (walletAddress === null || walletAddress === undefined) {
+            throw new RequiredError("WalletApi", "calculatePnl", "walletAddress");
+        }
+
+
+        // verify required parameter 'calculatePnlInput' is not null or undefined
+        if (calculatePnlInput === null || calculatePnlInput === undefined) {
+            throw new RequiredError("WalletApi", "calculatePnl", "calculatePnlInput");
+        }
+
+
+        // Path Params
+        const localVarPath = '/v1/wallet/{chain}/{walletAddress}/calculate-pnl'
+            .replace('{' + 'chain' + '}', encodeURIComponent(String(chain)))
+            .replace('{' + 'walletAddress' + '}', encodeURIComponent(String(walletAddress)));
+
+        // Make Request Context
+        const requestContext = _config.baseServer.makeRequestContext(localVarPath, HttpMethod.POST);
+        requestContext.setHeaderParam("Accept", "application/json, */*;q=0.8")
+        const randomId = Math.floor(Math.random() * Math.pow(2, 32))
+        requestContext.setHeaderParam("x-req-id", randomId.toString())
+
+
+
+        // Body Params
+        const contentType = ObjectSerializer.getPreferredMediaType([
+            "application/json"
+        ]);
+        requestContext.setHeaderParam("Content-Type", contentType);
+        const serializedBody = ObjectSerializer.stringify(
+            ObjectSerializer.serialize(calculatePnlInput, "CalculatePnlInput", ""),
+            contentType
+        );
+        requestContext.setBody(serializedBody);
+
+        let authMethod: SecurityAuthentication | undefined;
+        // Apply auth methods
+        authMethod = _config.authMethods["bearer"]
+        if (authMethod?.applySecurityAuthentication) {
+            await authMethod?.applySecurityAuthentication(requestContext);
+        }
+
+        const defaultAuth: SecurityAuthentication | undefined = _options?.authMethods?.default || this.configuration?.authMethods?.default
+        if (defaultAuth?.applySecurityAuthentication) {
+            await defaultAuth?.applySecurityAuthentication(requestContext);
+        }
+
+        return requestContext;
+    }
+
+    /**
+     * CONTROLLER.WALLET.GET_BALANCES.DESCRIPTION
+     * CONTROLLER.WALLET.GET_BALANCES.SUMMARY
+     * @param chain GLOBAL.CHAIN.DESCRIPTION
+     * @param walletAddress GLOBAL.WALLETADDRESS.DESCRIPTION
+     * @param tokenAddress DTO.WALLET.BALANCE.QUERY.TOKEN_ADDRESS
+     */
+    public async getBalance(chain: 'sol' | 'base' | 'bsc' | 'polygon' | 'arbitrum' | 'optimism' | 'avalanche' | 'ethereum' | 'zksync' | 'sui', walletAddress: string, tokenAddress?: string, _options?: Configuration): Promise<RequestContext> {
+        let _config = _options || this.configuration;
+
+        // verify required parameter 'chain' is not null or undefined
+        if (chain === null || chain === undefined) {
+            throw new RequiredError("WalletApi", "getBalance", "chain");
+        }
+
+
+        // verify required parameter 'walletAddress' is not null or undefined
+        if (walletAddress === null || walletAddress === undefined) {
+            throw new RequiredError("WalletApi", "getBalance", "walletAddress");
+        }
+
+
+
+        // Path Params
+        const localVarPath = '/v1/wallet/{chain}/{walletAddress}/balance'
+            .replace('{' + 'chain' + '}', encodeURIComponent(String(chain)))
+            .replace('{' + 'walletAddress' + '}', encodeURIComponent(String(walletAddress)));
+
+        // Make Request Context
+        const requestContext = _config.baseServer.makeRequestContext(localVarPath, HttpMethod.GET);
+        requestContext.setHeaderParam("Accept", "application/json, */*;q=0.8")
+        const randomId = Math.floor(Math.random() * Math.pow(2, 32))
+        requestContext.setHeaderParam("x-req-id", randomId.toString())
+
+
+        // Query Params
+        if (tokenAddress !== undefined) {
+            requestContext.setQueryParam("tokenAddress", ObjectSerializer.serialize(tokenAddress, "string", ""));
+        }
+
+
+        let authMethod: SecurityAuthentication | undefined;
+        // Apply auth methods
+        authMethod = _config.authMethods["bearer"]
+        if (authMethod?.applySecurityAuthentication) {
+            await authMethod?.applySecurityAuthentication(requestContext);
+        }
+
+        const defaultAuth: SecurityAuthentication | undefined = _options?.authMethods?.default || this.configuration?.authMethods?.default
+        if (defaultAuth?.applySecurityAuthentication) {
+            await defaultAuth?.applySecurityAuthentication(requestContext);
+        }
+
+        return requestContext;
+    }
+
+    /**
+     * CONTROLLER.WALLET.GET_PNL.DESCRIPTION
+     * CONTROLLER.WALLET.GET_PNL.SUMMARY
+     * @param chain GLOBAL.CHAIN.DESCRIPTION
+     * @param walletAddress GLOBAL.WALLETADDRESS.DESCRIPTION
+     * @param tokenAddress GLOBAL.TOKENADDRESS.DESCRIPTION
+     */
+    public async getPnl(chain: 'sol' | 'base' | 'bsc' | 'polygon' | 'arbitrum' | 'optimism' | 'avalanche' | 'ethereum' | 'zksync' | 'sui', walletAddress: string, tokenAddress?: string, _options?: Configuration): Promise<RequestContext> {
+        let _config = _options || this.configuration;
+
+        // verify required parameter 'chain' is not null or undefined
+        if (chain === null || chain === undefined) {
+            throw new RequiredError("WalletApi", "getPnl", "chain");
+        }
+
+
+        // verify required parameter 'walletAddress' is not null or undefined
+        if (walletAddress === null || walletAddress === undefined) {
+            throw new RequiredError("WalletApi", "getPnl", "walletAddress");
+        }
+
+
+
+        // Path Params
+        const localVarPath = '/v1/wallet/{chain}/{walletAddress}'
+            .replace('{' + 'chain' + '}', encodeURIComponent(String(chain)))
+            .replace('{' + 'walletAddress' + '}', encodeURIComponent(String(walletAddress)));
+
+        // Make Request Context
+        const requestContext = _config.baseServer.makeRequestContext(localVarPath, HttpMethod.GET);
+        requestContext.setHeaderParam("Accept", "application/json, */*;q=0.8")
+        const randomId = Math.floor(Math.random() * Math.pow(2, 32))
+        requestContext.setHeaderParam("x-req-id", randomId.toString())
+
+
+        // Query Params
+        if (tokenAddress !== undefined) {
+            requestContext.setQueryParam("tokenAddress", ObjectSerializer.serialize(tokenAddress, "string", ""));
+        }
+
+
+        let authMethod: SecurityAuthentication | undefined;
+        // Apply auth methods
+        authMethod = _config.authMethods["bearer"]
+        if (authMethod?.applySecurityAuthentication) {
+            await authMethod?.applySecurityAuthentication(requestContext);
+        }
+
+        const defaultAuth: SecurityAuthentication | undefined = _options?.authMethods?.default || this.configuration?.authMethods?.default
+        if (defaultAuth?.applySecurityAuthentication) {
+            await defaultAuth?.applySecurityAuthentication(requestContext);
+        }
+
+        return requestContext;
+    }
+
+    /**
+     * CONTROLLER.WALLET.GET_PNL_STATS.DESCRIPTION
+     * CONTROLLER.WALLET.GET_PNL_STATS.SUMMARY
+     * @param chain GLOBAL.CHAIN.DESCRIPTION
+     * @param walletAddress GLOBAL.WALLETADDRESS.DESCRIPTION
+     */
+    public async getPnlStats(chain: 'sol' | 'base' | 'bsc' | 'polygon' | 'arbitrum' | 'optimism' | 'avalanche' | 'ethereum' | 'zksync' | 'sui', walletAddress: string, _options?: Configuration): Promise<RequestContext> {
+        let _config = _options || this.configuration;
+
+        // verify required parameter 'chain' is not null or undefined
+        if (chain === null || chain === undefined) {
+            throw new RequiredError("WalletApi", "getPnlStats", "chain");
+        }
+
+
+        // verify required parameter 'walletAddress' is not null or undefined
+        if (walletAddress === null || walletAddress === undefined) {
+            throw new RequiredError("WalletApi", "getPnlStats", "walletAddress");
+        }
+
+
+        // Path Params
+        const localVarPath = '/v1/wallet/{chain}/{walletAddress}/stats'
+            .replace('{' + 'chain' + '}', encodeURIComponent(String(chain)))
+            .replace('{' + 'walletAddress' + '}', encodeURIComponent(String(walletAddress)));
+
+        // Make Request Context
+        const requestContext = _config.baseServer.makeRequestContext(localVarPath, HttpMethod.GET);
+        requestContext.setHeaderParam("Accept", "application/json, */*;q=0.8")
+        const randomId = Math.floor(Math.random() * Math.pow(2, 32))
+        requestContext.setHeaderParam("x-req-id", randomId.toString())
+
+
+
+        let authMethod: SecurityAuthentication | undefined;
+        // Apply auth methods
+        authMethod = _config.authMethods["bearer"]
+        if (authMethod?.applySecurityAuthentication) {
+            await authMethod?.applySecurityAuthentication(requestContext);
+        }
+
+        const defaultAuth: SecurityAuthentication | undefined = _options?.authMethods?.default || this.configuration?.authMethods?.default
+        if (defaultAuth?.applySecurityAuthentication) {
+            await defaultAuth?.applySecurityAuthentication(requestContext);
+        }
+
+        return requestContext;
+    }
+
+}
+
+export class WalletApiResponseProcessor {
+
+    /**
+     * 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 calculatePnl
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+     public async calculatePnlWithHttpInfo(response: ResponseContext): Promise<HttpInfo<boolean >> {
+        const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+        if (isCodeInRange("200", response.httpStatusCode)) {
+            const body: boolean = ObjectSerializer.deserialize(
+                ObjectSerializer.parse(await response.body.text(), contentType),
+                "boolean", ""
+            ) as boolean;
+            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
+        }
+
+        // Work around for missing responses in specification, e.g. for petstore.yaml
+        if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
+            const body: boolean = ObjectSerializer.deserialize(
+                ObjectSerializer.parse(await response.body.text(), contentType),
+                "boolean", ""
+            ) as boolean;
+            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
+        }
+        throw new ApiException<string | Blob | undefined>(response.httpStatusCode, "Unknown API Status Code!", await response.getBodyAsAny(), response.headers);
+    }
+
+    /**
+     * 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 getBalance
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+     public async getBalanceWithHttpInfo(response: ResponseContext): Promise<HttpInfo<WalletBalancesDTO >> {
+        const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+        if (isCodeInRange("200", response.httpStatusCode)) {
+            const body: WalletBalancesDTO = ObjectSerializer.deserialize(
+                ObjectSerializer.parse(await response.body.text(), contentType),
+                "WalletBalancesDTO", ""
+            ) as WalletBalancesDTO;
+            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
+        }
+
+        // Work around for missing responses in specification, e.g. for petstore.yaml
+        if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
+            const body: WalletBalancesDTO = ObjectSerializer.deserialize(
+                ObjectSerializer.parse(await response.body.text(), contentType),
+                "WalletBalancesDTO", ""
+            ) as WalletBalancesDTO;
+            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
+        }
+        throw new ApiException<string | Blob | undefined>(response.httpStatusCode, "Unknown API Status Code!", await response.getBodyAsAny(), response.headers);
+    }
+
+    /**
+     * 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 getPnl
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+     public async getPnlWithHttpInfo(response: ResponseContext): Promise<HttpInfo<Array<WalletPnlDTO> >> {
+        const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+        if (isCodeInRange("200", response.httpStatusCode)) {
+            const body: Array<WalletPnlDTO> = ObjectSerializer.deserialize(
+                ObjectSerializer.parse(await response.body.text(), contentType),
+                "Array<WalletPnlDTO>", ""
+            ) as Array<WalletPnlDTO>;
+            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
+        }
+
+        // Work around for missing responses in specification, e.g. for petstore.yaml
+        if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
+            const body: Array<WalletPnlDTO> = ObjectSerializer.deserialize(
+                ObjectSerializer.parse(await response.body.text(), contentType),
+                "Array<WalletPnlDTO>", ""
+            ) as Array<WalletPnlDTO>;
+            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
+        }
+        throw new ApiException<string | Blob | undefined>(response.httpStatusCode, "Unknown API Status Code!", await response.getBodyAsAny(), response.headers);
+    }
+
+    /**
+     * 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 getPnlStats
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+     public async getPnlStatsWithHttpInfo(response: ResponseContext): Promise<HttpInfo<Array<WalletPnlDTO> >> {
+        const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+        if (isCodeInRange("200", response.httpStatusCode)) {
+            const body: Array<WalletPnlDTO> = ObjectSerializer.deserialize(
+                ObjectSerializer.parse(await response.body.text(), contentType),
+                "Array<WalletPnlDTO>", ""
+            ) as Array<WalletPnlDTO>;
+            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
+        }
+
+        // Work around for missing responses in specification, e.g. for petstore.yaml
+        if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
+            const body: Array<WalletPnlDTO> = ObjectSerializer.deserialize(
+                ObjectSerializer.parse(await response.body.text(), contentType),
+                "Array<WalletPnlDTO>", ""
+            ) as Array<WalletPnlDTO>;
+            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
+        }
+        throw new ApiException<string | Blob | undefined>(response.httpStatusCode, "Unknown API Status Code!", await response.getBodyAsAny(), response.headers);
+    }
+
+}

package/src/openapi/apis/WatchlistApi.ts

@@ -0,0 +1,98 @@
+// TODO: better import syntax?
+import {BaseAPIRequestFactory, RequiredError, COLLECTION_FORMATS} from './baseapi';
+import {Configuration} from '../configuration';
+import {RequestContext, HttpMethod, ResponseContext, HttpFile, HttpInfo} from '../http/http';
+import {ObjectSerializer} from '../models/ObjectSerializer';
+import {ApiException} from './exception';
+import {canConsumeForm, isCodeInRange} from '../util';
+import {SecurityAuthentication} from '../auth/auth';
+
+
+
+/**
+ * no description
+ */
+export class WatchlistApiRequestFactory extends BaseAPIRequestFactory {
+
+    /**
+     * CONTROLLER.WATCHLIST.ADD.DESCRIPTION
+     * CONTROLLER.WATCHLIST.ADD.SUMMARY
+     * @param chain GLOBAL.CHAIN.DESCRIPTION
+     * @param walletAddress GLOBAL.WALLETADDRESS.DESCRIPTION
+     */
+    public async watchlistAdd(chain: 'sol' | 'base' | 'bsc' | 'polygon' | 'arbitrum' | 'optimism' | 'avalanche' | 'ethereum' | 'zksync' | 'sui', walletAddress: string, _options?: Configuration): Promise<RequestContext> {
+        let _config = _options || this.configuration;
+
+        // verify required parameter 'chain' is not null or undefined
+        if (chain === null || chain === undefined) {
+            throw new RequiredError("WatchlistApi", "watchlistAdd", "chain");
+        }
+
+
+        // verify required parameter 'walletAddress' is not null or undefined
+        if (walletAddress === null || walletAddress === undefined) {
+            throw new RequiredError("WatchlistApi", "watchlistAdd", "walletAddress");
+        }
+
+
+        // Path Params
+        const localVarPath = '/v1/watchlist/{chain}/{walletAddress}'
+            .replace('{' + 'chain' + '}', encodeURIComponent(String(chain)))
+            .replace('{' + 'walletAddress' + '}', encodeURIComponent(String(walletAddress)));
+
+        // Make Request Context
+        const requestContext = _config.baseServer.makeRequestContext(localVarPath, HttpMethod.POST);
+        requestContext.setHeaderParam("Accept", "application/json, */*;q=0.8")
+        const randomId = Math.floor(Math.random() * Math.pow(2, 32))
+        requestContext.setHeaderParam("x-req-id", randomId.toString())
+
+
+
+        let authMethod: SecurityAuthentication | undefined;
+        // Apply auth methods
+        authMethod = _config.authMethods["bearer"]
+        if (authMethod?.applySecurityAuthentication) {
+            await authMethod?.applySecurityAuthentication(requestContext);
+        }
+
+        const defaultAuth: SecurityAuthentication | undefined = _options?.authMethods?.default || this.configuration?.authMethods?.default
+        if (defaultAuth?.applySecurityAuthentication) {
+            await defaultAuth?.applySecurityAuthentication(requestContext);
+        }
+
+        return requestContext;
+    }
+
+}
+
+export class WatchlistApiResponseProcessor {
+
+    /**
+     * 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 watchlistAdd
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+     public async watchlistAddWithHttpInfo(response: ResponseContext): Promise<HttpInfo<string >> {
+        const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+        if (isCodeInRange("200", response.httpStatusCode)) {
+            const body: string = ObjectSerializer.deserialize(
+                ObjectSerializer.parse(await response.body.text(), contentType),
+                "string", ""
+            ) as string;
+            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
+        }
+
+        // Work around for missing responses in specification, e.g. for petstore.yaml
+        if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
+            const body: string = ObjectSerializer.deserialize(
+                ObjectSerializer.parse(await response.body.text(), contentType),
+                "string", ""
+            ) as string;
+            return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
+        }
+        throw new ApiException<string | Blob | undefined>(response.httpStatusCode, "Unknown API Status Code!", await response.getBodyAsAny(), response.headers);
+    }
+
+}

package/src/openapi/apis/baseapi.ts

@@ -0,0 +1,37 @@
+import { Configuration } from '../configuration'
+
+/**
+ *
+ * @export
+ */
+export const COLLECTION_FORMATS = {
+    csv: ",",
+    ssv: " ",
+    tsv: "\t",
+    pipes: "|",
+};
+
+
+/**
+ *
+ * @export
+ * @class BaseAPI
+ */
+export class BaseAPIRequestFactory {
+
+    constructor(protected configuration: Configuration) {
+    }
+};
+
+/**
+ *
+ * @export
+ * @class RequiredError
+ * @extends {Error}
+ */
+export class RequiredError extends Error {
+    override name: "RequiredError" = "RequiredError";
+    constructor(public api: string, public method: string, public field: string) {
+        super("Required parameter " + field + " was null or undefined when calling " + api + "." + method + ".");
+    }
+}

package/src/openapi/apis/exception.ts

@@ -0,0 +1,15 @@
+/**
+ * Represents an error caused by an api call i.e. it has attributes for a HTTP status code
+ * and the returned body object.
+ *
+ * Example
+ * API returns a ErrorMessageObject whenever HTTP status code is not in [200, 299]
+ * => ApiException(404, someErrorMessageObject)
+ *
+ */
+export class ApiException<T> extends Error {
+    public constructor(public code: number, message: string, public body: T, public headers: { [key: string]: string; }) {
+        super("HTTP-Code: " + code + "\nMessage: " + message + "\nBody: " + JSON.stringify(body) + "\nHeaders: " +
+        JSON.stringify(headers))
+    }
+}

package/src/openapi/auth/auth.ts

@@ -0,0 +1,80 @@
+import { RequestContext } from "../http/http";
+
+/**
+ * Interface authentication schemes.
+ */
+export interface SecurityAuthentication {
+    /*
+     * @return returns the name of the security authentication as specified in OAI
+     */
+    getName(): string;
+
+    /**
+     * Applies the authentication scheme to the request context
+     *
+     * @params context the request context which should use this authentication scheme
+     */
+    applySecurityAuthentication(context: RequestContext): void | Promise<void>;
+}
+
+export interface TokenProvider {
+  getToken(): Promise<string> | string;
+}
+
+/**
+ * Applies http authentication to the request context.
+ */
+export class BearerAuthentication implements SecurityAuthentication {
+    /**
+     * Configures the http authentication with the required details.
+     *
+     * @param tokenProvider service that can provide the up-to-date token when needed
+     */
+    public constructor(private tokenProvider: TokenProvider) {}
+
+    public getName(): string {
+        return "bearer";
+    }
+
+    public async applySecurityAuthentication(context: RequestContext) {
+        context.setHeaderParam("Authorization", "Bearer " + await this.tokenProvider.getToken());
+    }
+}
+
+
+export type AuthMethods = {
+    "default"?: SecurityAuthentication,
+    "bearer"?: SecurityAuthentication
+}
+
+export type ApiKeyConfiguration = string;
+export type HttpBasicConfiguration = { "username": string, "password": string };
+export type HttpBearerConfiguration = { tokenProvider: TokenProvider };
+export type OAuth2Configuration = { accessToken: string };
+export type HttpSignatureConfiguration = unknown; // TODO: Implement
+
+export type AuthMethodsConfiguration = {
+    "default"?: SecurityAuthentication,
+    "bearer"?: HttpBearerConfiguration
+}
+
+/**
+ * Creates the authentication methods from a swagger description.
+ *
+ */
+export function configureAuthMethods(config: AuthMethodsConfiguration | undefined): AuthMethods {
+    let authMethods: AuthMethods = {}
+
+    if (!config) {
+        return authMethods;
+    }
+    authMethods["default"] = config["default"]
+
+    if (config["bearer"]) {
+        authMethods["bearer"] = new BearerAuthentication(
+            config["bearer"]["tokenProvider"]
+        );
+    }
+
+    return authMethods;
+}

package/src/openapi/configuration.ts

@@ -0,0 +1,82 @@
+import { HttpLibrary } from "./http/http";
+import { Middleware, PromiseMiddleware, PromiseMiddlewareWrapper } from "./middleware";
+import { IsomorphicFetchHttpLibrary as DefaultHttpLibrary } from "./http/isomorphic-fetch";
+import { BaseServerConfiguration, server1 } from "./servers";
+import { configureAuthMethods, AuthMethods, AuthMethodsConfiguration } from "./auth/auth";
+
+export interface Configuration {
+    readonly baseServer: BaseServerConfiguration;
+    readonly httpApi: HttpLibrary;
+    readonly middleware: Middleware[];
+    readonly authMethods: AuthMethods;
+}
+
+
+/**
+ * Interface with which a configuration object can be configured.
+ */
+export interface ConfigurationParameters {
+    /**
+     * Default server to use - a list of available servers (according to the 
+     * OpenAPI yaml definition) is included in the `servers` const in `./servers`. You can also
+     * create your own server with the `ServerConfiguration` class from the same 
+     * file.
+     */
+    baseServer?: BaseServerConfiguration;
+    /**
+     * HTTP library to use e.g. IsomorphicFetch. This can usually be skipped as 
+     * all generators come with a default library.
+     * If available, additional libraries can be imported from `./http/*`
+     */
+    httpApi?: HttpLibrary;
+
+    /**
+     * The middlewares which will be applied to requests and responses. You can 
+     * add any number of middleware components to modify requests before they 
+     * are sent or before they are deserialized by implementing the `Middleware`
+     * interface defined in `./middleware`
+     */
+    middleware?: Middleware[];
+    /**
+     * Configures middleware functions that return promises instead of 
+     * Observables (which are used by `middleware`). Otherwise allows for the 
+     * same functionality as `middleware`, i.e., modifying requests before they 
+     * are sent and before they are deserialized.
+     */
+    promiseMiddleware?: PromiseMiddleware[];
+    /**
+     * Configuration for the available authentication methods (e.g., api keys) 
+     * according to the OpenAPI yaml definition. For the definition, please refer to 
+     * `./auth/auth`
+     */
+    authMethods?: AuthMethodsConfiguration
+}
+
+/**
+ * Provide your `ConfigurationParameters` to this function to get a `Configuration`
+ * object that can be used to configure your APIs (in the constructor or 
+ * for each request individually).
+ *
+ * If a property is not included in conf, a default is used:
+ *    - baseServer: server1
+ *    - httpApi: IsomorphicFetchHttpLibrary
+ *    - middleware: []
+ *    - promiseMiddleware: []
+ *    - authMethods: {}
+ *
+ * @param conf partial configuration
+ */
+export function createConfiguration(conf: ConfigurationParameters = {}): Configuration {
+    const configuration: Configuration = {
+        baseServer: conf.baseServer !== undefined ? conf.baseServer : server1,
+        httpApi: conf.httpApi || new DefaultHttpLibrary(),
+        middleware: conf.middleware || [],
+        authMethods: configureAuthMethods(conf.authMethods)
+    };
+    if (conf.promiseMiddleware) {
+        conf.promiseMiddleware.forEach(
+            m => configuration.middleware.push(new PromiseMiddlewareWrapper(m))
+        );
+    }
+    return configuration;
+}