@explo-tech/fido-api 0.0.2 → 0.0.3

package/.openapi-generator/FILES

@@ -6,6 +6,7 @@ api/healthResourceApi.ts
 api/namespaceResourceApi.ts
 api/queryResourceApi.ts
 git_push.sh
+model/clientError.ts
 model/computedViewRunRequest.ts
 model/dataPage.ts
 model/dataRequestParameters.ts
@@ -14,17 +15,18 @@ model/dataSchema.ts
 model/dataSource.ts
 model/dataSourceConfiguration.ts
 model/dataSourceRequest.ts
+model/dataSourceResponse.ts
 model/dataSourceTablePreviewRequest.ts
 model/models.ts
 model/namespace.ts
 model/namespaceRequest.ts
+model/namespaceResponse.ts
+model/namespaceResponseMeta.ts
 model/namespaceResponseMetadata.ts
 model/pagingConfiguration.ts
 model/propertySchema.ts
 model/propertyType.ts
+model/queryExecutionResponse.ts
+model/queryExecutionResponseRequestTelemetry.ts
 model/record.ts
-model/v1NamespacesIdGet200Response.ts
-model/v1NamespacesIdGet200ResponseMeta.ts
-model/v1NamespacesIdGet4xxResponse.ts
-model/v1NamespacesNamespaceIdDataSourcesDataSourceIdPreviewPost200Response.ts
-model/v1NamespacesNamespaceIdDataSourcesIdGet200Response.ts
+model/requestTelemetry.ts

package/api/datasourceResourceApi.ts

@@ -15,9 +15,9 @@ import localVarRequest from 'request';
 import http from 'http';
 
 /* tslint:disable:no-unused-locals */
+import { ClientError } from '../model/clientError';
 import { DataSourceRequest } from '../model/dataSourceRequest';
-import { V1NamespacesIdGet4xxResponse } from '../model/v1NamespacesIdGet4xxResponse';
-import { V1NamespacesNamespaceIdDataSourcesIdGet200Response } from '../model/v1NamespacesNamespaceIdDataSourcesIdGet200Response';
+import { DataSourceResponse } from '../model/dataSourceResponse';
 
 import { ObjectSerializer, Authentication, VoidAuth, Interceptor } from '../model/models';
 import { HttpBasicAuth, HttpBearerAuth, ApiKeyAuth, OAuth } from '../model/models';
@@ -103,11 +103,12 @@ export class DatasourceResourceApi {
 
     /**
      * 
-     * @summary Deletes a data source
+     * @summary Creates a data source
      * @param id 
      * @param namespaceId 
+     * @param dataSourceRequest 
      */
-    public async v1NamespacesNamespaceIdDataSourcesIdDelete (id: string, namespaceId: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: http.IncomingMessage; body: object;  }> {
+    public async createDataSource (id: string, namespaceId: string, dataSourceRequest?: DataSourceRequest, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: http.IncomingMessage; body: DataSourceResponse;  }> {
         const localVarPath = this.basePath + '/v1/namespaces/{namespaceId}/data-sources/{id}'
             .replace('{' + 'id' + '}', encodeURIComponent(String(id)))
             .replace('{' + 'namespaceId' + '}', encodeURIComponent(String(namespaceId)));
@@ -124,12 +125,12 @@ export class DatasourceResourceApi {
 
         // verify required parameter 'id' is not null or undefined
         if (id === null || id === undefined) {
-            throw new Error('Required parameter id was null or undefined when calling v1NamespacesNamespaceIdDataSourcesIdDelete.');
+            throw new Error('Required parameter id was null or undefined when calling createDataSource.');
         }
 
         // verify required parameter 'namespaceId' is not null or undefined
         if (namespaceId === null || namespaceId === undefined) {
-            throw new Error('Required parameter namespaceId was null or undefined when calling v1NamespacesNamespaceIdDataSourcesIdDelete.');
+            throw new Error('Required parameter namespaceId was null or undefined when calling createDataSource.');
         }
 
         (<any>Object).assign(localVarHeaderParams, options.headers);
@@ -137,12 +138,13 @@ export class DatasourceResourceApi {
         let localVarUseFormData = false;
 
         let localVarRequestOptions: localVarRequest.Options = {
-            method: 'DELETE',
+            method: 'POST',
             qs: localVarQueryParameters,
             headers: localVarHeaderParams,
             uri: localVarPath,
             useQuerystring: this._useQuerystring,
             json: true,
+            body: ObjectSerializer.serialize(dataSourceRequest, "DataSourceRequest")
         };
 
         let authenticationPromise = Promise.resolve();
@@ -161,13 +163,13 @@ export class DatasourceResourceApi {
                     localVarRequestOptions.form = localVarFormParams;
                 }
             }
-            return new Promise<{ response: http.IncomingMessage; body: object;  }>((resolve, reject) => {
+            return new Promise<{ response: http.IncomingMessage; body: DataSourceResponse;  }>((resolve, reject) => {
                 localVarRequest(localVarRequestOptions, (error, response, body) => {
                     if (error) {
                         reject(error);
                     } else {
                         if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
-                            body = ObjectSerializer.deserialize(body, "object");
+                            body = ObjectSerializer.deserialize(body, "DataSourceResponse");
                             resolve({ response: response, body: body });
                         } else {
                             reject(new HttpError(response, body, response.statusCode));
@@ -179,11 +181,11 @@ export class DatasourceResourceApi {
     }
     /**
      * 
-     * @summary Gets a data source
+     * @summary Deletes a data source
      * @param id 
      * @param namespaceId 
      */
-    public async v1NamespacesNamespaceIdDataSourcesIdGet (id: string, namespaceId: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: http.IncomingMessage; body: V1NamespacesNamespaceIdDataSourcesIdGet200Response;  }> {
+    public async deleteDataSource (id: string, namespaceId: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: http.IncomingMessage; body: object;  }> {
         const localVarPath = this.basePath + '/v1/namespaces/{namespaceId}/data-sources/{id}'
             .replace('{' + 'id' + '}', encodeURIComponent(String(id)))
             .replace('{' + 'namespaceId' + '}', encodeURIComponent(String(namespaceId)));
@@ -200,12 +202,12 @@ export class DatasourceResourceApi {
 
         // verify required parameter 'id' is not null or undefined
         if (id === null || id === undefined) {
-            throw new Error('Required parameter id was null or undefined when calling v1NamespacesNamespaceIdDataSourcesIdGet.');
+            throw new Error('Required parameter id was null or undefined when calling deleteDataSource.');
         }
 
         // verify required parameter 'namespaceId' is not null or undefined
         if (namespaceId === null || namespaceId === undefined) {
-            throw new Error('Required parameter namespaceId was null or undefined when calling v1NamespacesNamespaceIdDataSourcesIdGet.');
+            throw new Error('Required parameter namespaceId was null or undefined when calling deleteDataSource.');
         }
 
         (<any>Object).assign(localVarHeaderParams, options.headers);
@@ -213,7 +215,7 @@ export class DatasourceResourceApi {
         let localVarUseFormData = false;
 
         let localVarRequestOptions: localVarRequest.Options = {
-            method: 'GET',
+            method: 'DELETE',
             qs: localVarQueryParameters,
             headers: localVarHeaderParams,
             uri: localVarPath,
@@ -237,13 +239,13 @@ export class DatasourceResourceApi {
                     localVarRequestOptions.form = localVarFormParams;
                 }
             }
-            return new Promise<{ response: http.IncomingMessage; body: V1NamespacesNamespaceIdDataSourcesIdGet200Response;  }>((resolve, reject) => {
+            return new Promise<{ response: http.IncomingMessage; body: object;  }>((resolve, reject) => {
                 localVarRequest(localVarRequestOptions, (error, response, body) => {
                     if (error) {
                         reject(error);
                     } else {
                         if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
-                            body = ObjectSerializer.deserialize(body, "V1NamespacesNamespaceIdDataSourcesIdGet200Response");
+                            body = ObjectSerializer.deserialize(body, "object");
                             resolve({ response: response, body: body });
                         } else {
                             reject(new HttpError(response, body, response.statusCode));
@@ -255,12 +257,11 @@ export class DatasourceResourceApi {
     }
     /**
      * 
-     * @summary Creates a data source
+     * @summary Gets a data source
      * @param id 
      * @param namespaceId 
-     * @param dataSourceRequest 
      */
-    public async v1NamespacesNamespaceIdDataSourcesIdPost (id: string, namespaceId: string, dataSourceRequest?: DataSourceRequest, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: http.IncomingMessage; body: V1NamespacesNamespaceIdDataSourcesIdGet200Response;  }> {
+    public async getDataSource (id: string, namespaceId: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: http.IncomingMessage; body: DataSourceResponse;  }> {
         const localVarPath = this.basePath + '/v1/namespaces/{namespaceId}/data-sources/{id}'
             .replace('{' + 'id' + '}', encodeURIComponent(String(id)))
             .replace('{' + 'namespaceId' + '}', encodeURIComponent(String(namespaceId)));
@@ -277,12 +278,12 @@ export class DatasourceResourceApi {
 
         // verify required parameter 'id' is not null or undefined
         if (id === null || id === undefined) {
-            throw new Error('Required parameter id was null or undefined when calling v1NamespacesNamespaceIdDataSourcesIdPost.');
+            throw new Error('Required parameter id was null or undefined when calling getDataSource.');
         }
 
         // verify required parameter 'namespaceId' is not null or undefined
         if (namespaceId === null || namespaceId === undefined) {
-            throw new Error('Required parameter namespaceId was null or undefined when calling v1NamespacesNamespaceIdDataSourcesIdPost.');
+            throw new Error('Required parameter namespaceId was null or undefined when calling getDataSource.');
         }
 
         (<any>Object).assign(localVarHeaderParams, options.headers);
@@ -290,13 +291,12 @@ export class DatasourceResourceApi {
         let localVarUseFormData = false;
 
         let localVarRequestOptions: localVarRequest.Options = {
-            method: 'POST',
+            method: 'GET',
             qs: localVarQueryParameters,
             headers: localVarHeaderParams,
             uri: localVarPath,
             useQuerystring: this._useQuerystring,
             json: true,
-            body: ObjectSerializer.serialize(dataSourceRequest, "DataSourceRequest")
         };
 
         let authenticationPromise = Promise.resolve();
@@ -315,13 +315,13 @@ export class DatasourceResourceApi {
                     localVarRequestOptions.form = localVarFormParams;
                 }
             }
-            return new Promise<{ response: http.IncomingMessage; body: V1NamespacesNamespaceIdDataSourcesIdGet200Response;  }>((resolve, reject) => {
+            return new Promise<{ response: http.IncomingMessage; body: DataSourceResponse;  }>((resolve, reject) => {
                 localVarRequest(localVarRequestOptions, (error, response, body) => {
                     if (error) {
                         reject(error);
                     } else {
                         if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
-                            body = ObjectSerializer.deserialize(body, "V1NamespacesNamespaceIdDataSourcesIdGet200Response");
+                            body = ObjectSerializer.deserialize(body, "DataSourceResponse");
                             resolve({ response: response, body: body });
                         } else {
                             reject(new HttpError(response, body, response.statusCode));
@@ -338,7 +338,7 @@ export class DatasourceResourceApi {
      * @param namespaceId 
      * @param dataSourceRequest 
      */
-    public async v1NamespacesNamespaceIdDataSourcesIdPut (id: string, namespaceId: string, dataSourceRequest?: DataSourceRequest, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: http.IncomingMessage; body: V1NamespacesNamespaceIdDataSourcesIdGet200Response;  }> {
+    public async updateDataSource (id: string, namespaceId: string, dataSourceRequest?: DataSourceRequest, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: http.IncomingMessage; body: DataSourceResponse;  }> {
         const localVarPath = this.basePath + '/v1/namespaces/{namespaceId}/data-sources/{id}'
             .replace('{' + 'id' + '}', encodeURIComponent(String(id)))
             .replace('{' + 'namespaceId' + '}', encodeURIComponent(String(namespaceId)));
@@ -355,12 +355,12 @@ export class DatasourceResourceApi {
 
         // verify required parameter 'id' is not null or undefined
         if (id === null || id === undefined) {
-            throw new Error('Required parameter id was null or undefined when calling v1NamespacesNamespaceIdDataSourcesIdPut.');
+            throw new Error('Required parameter id was null or undefined when calling updateDataSource.');
         }
 
         // verify required parameter 'namespaceId' is not null or undefined
         if (namespaceId === null || namespaceId === undefined) {
-            throw new Error('Required parameter namespaceId was null or undefined when calling v1NamespacesNamespaceIdDataSourcesIdPut.');
+            throw new Error('Required parameter namespaceId was null or undefined when calling updateDataSource.');
         }
 
         (<any>Object).assign(localVarHeaderParams, options.headers);
@@ -393,13 +393,13 @@ export class DatasourceResourceApi {
                     localVarRequestOptions.form = localVarFormParams;
                 }
             }
-            return new Promise<{ response: http.IncomingMessage; body: V1NamespacesNamespaceIdDataSourcesIdGet200Response;  }>((resolve, reject) => {
+            return new Promise<{ response: http.IncomingMessage; body: DataSourceResponse;  }>((resolve, reject) => {
                 localVarRequest(localVarRequestOptions, (error, response, body) => {
                     if (error) {
                         reject(error);
                     } else {
                         if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
-                            body = ObjectSerializer.deserialize(body, "V1NamespacesNamespaceIdDataSourcesIdGet200Response");
+                            body = ObjectSerializer.deserialize(body, "DataSourceResponse");
                             resolve({ response: response, body: body });
                         } else {
                             reject(new HttpError(response, body, response.statusCode));

package/api/healthResourceApi.ts

@@ -104,7 +104,7 @@ export class HealthResourceApi {
      * @param dataSourceId 
      * @param namespaceId 
      */
-    public async v1HealthDataSourceConnectionNamespaceIdDataSourceIdGet (dataSourceId: string, namespaceId: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: http.IncomingMessage; body: object;  }> {
+    public async getDataSourceConnectionHealth (dataSourceId: string, namespaceId: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: http.IncomingMessage; body: object;  }> {
         const localVarPath = this.basePath + '/v1/health/data-source-connection/{namespaceId}/{dataSourceId}'
             .replace('{' + 'dataSourceId' + '}', encodeURIComponent(String(dataSourceId)))
             .replace('{' + 'namespaceId' + '}', encodeURIComponent(String(namespaceId)));
@@ -121,12 +121,12 @@ export class HealthResourceApi {
 
         // verify required parameter 'dataSourceId' is not null or undefined
         if (dataSourceId === null || dataSourceId === undefined) {
-            throw new Error('Required parameter dataSourceId was null or undefined when calling v1HealthDataSourceConnectionNamespaceIdDataSourceIdGet.');
+            throw new Error('Required parameter dataSourceId was null or undefined when calling getDataSourceConnectionHealth.');
         }
 
         // verify required parameter 'namespaceId' is not null or undefined
         if (namespaceId === null || namespaceId === undefined) {
-            throw new Error('Required parameter namespaceId was null or undefined when calling v1HealthDataSourceConnectionNamespaceIdDataSourceIdGet.');
+            throw new Error('Required parameter namespaceId was null or undefined when calling getDataSourceConnectionHealth.');
         }
 
         (<any>Object).assign(localVarHeaderParams, options.headers);
@@ -178,7 +178,7 @@ export class HealthResourceApi {
      * 
      * @summary Returns the entire state of the FIDO application
      */
-    public async v1HealthGet (options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: http.IncomingMessage; body: object;  }> {
+    public async getFidoHealth (options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: http.IncomingMessage; body: object;  }> {
         const localVarPath = this.basePath + '/v1/health';
         let localVarQueryParameters: any = {};
         let localVarHeaderParams: any = (<any>Object).assign({}, this._defaultHeaders);

package/api/namespaceResourceApi.ts

@@ -15,9 +15,9 @@ import localVarRequest from 'request';
 import http from 'http';
 
 /* tslint:disable:no-unused-locals */
+import { ClientError } from '../model/clientError';
 import { NamespaceRequest } from '../model/namespaceRequest';
-import { V1NamespacesIdGet200Response } from '../model/v1NamespacesIdGet200Response';
-import { V1NamespacesIdGet4xxResponse } from '../model/v1NamespacesIdGet4xxResponse';
+import { NamespaceResponse } from '../model/namespaceResponse';
 
 import { ObjectSerializer, Authentication, VoidAuth, Interceptor } from '../model/models';
 import { HttpBasicAuth, HttpBearerAuth, ApiKeyAuth, OAuth } from '../model/models';
@@ -103,10 +103,11 @@ export class NamespaceResourceApi {
 
     /**
      * 
-     * @summary Deletes a namespace, cascading to its associated resources
+     * @summary Creates a namespace and optionally a data source associated with it
      * @param id 
+     * @param namespaceRequest 
      */
-    public async v1NamespacesIdDelete (id: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: http.IncomingMessage; body: object;  }> {
+    public async createNamespace (id: string, namespaceRequest?: NamespaceRequest, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: http.IncomingMessage; body: NamespaceResponse;  }> {
         const localVarPath = this.basePath + '/v1/namespaces/{id}'
             .replace('{' + 'id' + '}', encodeURIComponent(String(id)));
         let localVarQueryParameters: any = {};
@@ -122,7 +123,7 @@ export class NamespaceResourceApi {
 
         // verify required parameter 'id' is not null or undefined
         if (id === null || id === undefined) {
-            throw new Error('Required parameter id was null or undefined when calling v1NamespacesIdDelete.');
+            throw new Error('Required parameter id was null or undefined when calling createNamespace.');
         }
 
         (<any>Object).assign(localVarHeaderParams, options.headers);
@@ -130,12 +131,13 @@ export class NamespaceResourceApi {
         let localVarUseFormData = false;
 
         let localVarRequestOptions: localVarRequest.Options = {
-            method: 'DELETE',
+            method: 'POST',
             qs: localVarQueryParameters,
             headers: localVarHeaderParams,
             uri: localVarPath,
             useQuerystring: this._useQuerystring,
             json: true,
+            body: ObjectSerializer.serialize(namespaceRequest, "NamespaceRequest")
         };
 
         let authenticationPromise = Promise.resolve();
@@ -154,13 +156,13 @@ export class NamespaceResourceApi {
                     localVarRequestOptions.form = localVarFormParams;
                 }
             }
-            return new Promise<{ response: http.IncomingMessage; body: object;  }>((resolve, reject) => {
+            return new Promise<{ response: http.IncomingMessage; body: NamespaceResponse;  }>((resolve, reject) => {
                 localVarRequest(localVarRequestOptions, (error, response, body) => {
                     if (error) {
                         reject(error);
                     } else {
                         if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
-                            body = ObjectSerializer.deserialize(body, "object");
+                            body = ObjectSerializer.deserialize(body, "NamespaceResponse");
                             resolve({ response: response, body: body });
                         } else {
                             reject(new HttpError(response, body, response.statusCode));
@@ -172,11 +174,10 @@ export class NamespaceResourceApi {
     }
     /**
      * 
-     * @summary Gets a namespace and its associated data sources
+     * @summary Deletes a namespace, cascading to its associated resources
      * @param id 
-     * @param includeDataSources 
      */
-    public async v1NamespacesIdGet (id: string, includeDataSources?: boolean, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: http.IncomingMessage; body: V1NamespacesIdGet200Response;  }> {
+    public async deleteNamespace (id: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: http.IncomingMessage; body: object;  }> {
         const localVarPath = this.basePath + '/v1/namespaces/{id}'
             .replace('{' + 'id' + '}', encodeURIComponent(String(id)));
         let localVarQueryParameters: any = {};
@@ -192,11 +193,7 @@ export class NamespaceResourceApi {
 
         // verify required parameter 'id' is not null or undefined
         if (id === null || id === undefined) {
-            throw new Error('Required parameter id was null or undefined when calling v1NamespacesIdGet.');
-        }
-
-        if (includeDataSources !== undefined) {
-            localVarQueryParameters['includeDataSources'] = ObjectSerializer.serialize(includeDataSources, "boolean");
+            throw new Error('Required parameter id was null or undefined when calling deleteNamespace.');
         }
 
         (<any>Object).assign(localVarHeaderParams, options.headers);
@@ -204,7 +201,7 @@ export class NamespaceResourceApi {
         let localVarUseFormData = false;
 
         let localVarRequestOptions: localVarRequest.Options = {
-            method: 'GET',
+            method: 'DELETE',
             qs: localVarQueryParameters,
             headers: localVarHeaderParams,
             uri: localVarPath,
@@ -228,13 +225,13 @@ export class NamespaceResourceApi {
                     localVarRequestOptions.form = localVarFormParams;
                 }
             }
-            return new Promise<{ response: http.IncomingMessage; body: V1NamespacesIdGet200Response;  }>((resolve, reject) => {
+            return new Promise<{ response: http.IncomingMessage; body: object;  }>((resolve, reject) => {
                 localVarRequest(localVarRequestOptions, (error, response, body) => {
                     if (error) {
                         reject(error);
                     } else {
                         if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
-                            body = ObjectSerializer.deserialize(body, "V1NamespacesIdGet200Response");
+                            body = ObjectSerializer.deserialize(body, "object");
                             resolve({ response: response, body: body });
                         } else {
                             reject(new HttpError(response, body, response.statusCode));
@@ -246,11 +243,11 @@ export class NamespaceResourceApi {
     }
     /**
      * 
-     * @summary Creates a namespace and optionally a data source associated with it
+     * @summary Gets a namespace and its associated data sources
      * @param id 
-     * @param namespaceRequest 
+     * @param includeDataSources 
      */
-    public async v1NamespacesIdPost (id: string, namespaceRequest?: NamespaceRequest, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: http.IncomingMessage; body: V1NamespacesIdGet200Response;  }> {
+    public async getNamespace (id: string, includeDataSources?: boolean, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: http.IncomingMessage; body: NamespaceResponse;  }> {
         const localVarPath = this.basePath + '/v1/namespaces/{id}'
             .replace('{' + 'id' + '}', encodeURIComponent(String(id)));
         let localVarQueryParameters: any = {};
@@ -266,7 +263,11 @@ export class NamespaceResourceApi {
 
         // verify required parameter 'id' is not null or undefined
         if (id === null || id === undefined) {
-            throw new Error('Required parameter id was null or undefined when calling v1NamespacesIdPost.');
+            throw new Error('Required parameter id was null or undefined when calling getNamespace.');
+        }
+
+        if (includeDataSources !== undefined) {
+            localVarQueryParameters['includeDataSources'] = ObjectSerializer.serialize(includeDataSources, "boolean");
         }
 
         (<any>Object).assign(localVarHeaderParams, options.headers);
@@ -274,13 +275,12 @@ export class NamespaceResourceApi {
         let localVarUseFormData = false;
 
         let localVarRequestOptions: localVarRequest.Options = {
-            method: 'POST',
+            method: 'GET',
             qs: localVarQueryParameters,
             headers: localVarHeaderParams,
             uri: localVarPath,
             useQuerystring: this._useQuerystring,
             json: true,
-            body: ObjectSerializer.serialize(namespaceRequest, "NamespaceRequest")
         };
 
         let authenticationPromise = Promise.resolve();
@@ -299,13 +299,13 @@ export class NamespaceResourceApi {
                     localVarRequestOptions.form = localVarFormParams;
                 }
             }
-            return new Promise<{ response: http.IncomingMessage; body: V1NamespacesIdGet200Response;  }>((resolve, reject) => {
+            return new Promise<{ response: http.IncomingMessage; body: NamespaceResponse;  }>((resolve, reject) => {
                 localVarRequest(localVarRequestOptions, (error, response, body) => {
                     if (error) {
                         reject(error);
                     } else {
                         if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
-                            body = ObjectSerializer.deserialize(body, "V1NamespacesIdGet200Response");
+                            body = ObjectSerializer.deserialize(body, "NamespaceResponse");
                             resolve({ response: response, body: body });
                         } else {
                             reject(new HttpError(response, body, response.statusCode));
@@ -321,7 +321,7 @@ export class NamespaceResourceApi {
      * @param id 
      * @param namespaceRequest 
      */
-    public async v1NamespacesIdPut (id: string, namespaceRequest?: NamespaceRequest, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: http.IncomingMessage; body: V1NamespacesIdGet200Response;  }> {
+    public async updateNamespace (id: string, namespaceRequest?: NamespaceRequest, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: http.IncomingMessage; body: NamespaceResponse;  }> {
         const localVarPath = this.basePath + '/v1/namespaces/{id}'
             .replace('{' + 'id' + '}', encodeURIComponent(String(id)));
         let localVarQueryParameters: any = {};
@@ -337,7 +337,7 @@ export class NamespaceResourceApi {
 
         // verify required parameter 'id' is not null or undefined
         if (id === null || id === undefined) {
-            throw new Error('Required parameter id was null or undefined when calling v1NamespacesIdPut.');
+            throw new Error('Required parameter id was null or undefined when calling updateNamespace.');
         }
 
         (<any>Object).assign(localVarHeaderParams, options.headers);
@@ -370,13 +370,13 @@ export class NamespaceResourceApi {
                     localVarRequestOptions.form = localVarFormParams;
                 }
             }
-            return new Promise<{ response: http.IncomingMessage; body: V1NamespacesIdGet200Response;  }>((resolve, reject) => {
+            return new Promise<{ response: http.IncomingMessage; body: NamespaceResponse;  }>((resolve, reject) => {
                 localVarRequest(localVarRequestOptions, (error, response, body) => {
                     if (error) {
                         reject(error);
                     } else {
                         if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
-                            body = ObjectSerializer.deserialize(body, "V1NamespacesIdGet200Response");
+                            body = ObjectSerializer.deserialize(body, "NamespaceResponse");
                             resolve({ response: response, body: body });
                         } else {
                             reject(new HttpError(response, body, response.statusCode));

package/api/queryResourceApi.ts

@@ -15,10 +15,10 @@ import localVarRequest from 'request';
 import http from 'http';
 
 /* tslint:disable:no-unused-locals */
+import { ClientError } from '../model/clientError';
 import { ComputedViewRunRequest } from '../model/computedViewRunRequest';
 import { DataSourceTablePreviewRequest } from '../model/dataSourceTablePreviewRequest';
-import { V1NamespacesIdGet4xxResponse } from '../model/v1NamespacesIdGet4xxResponse';
-import { V1NamespacesNamespaceIdDataSourcesDataSourceIdPreviewPost200Response } from '../model/v1NamespacesNamespaceIdDataSourcesDataSourceIdPreviewPost200Response';
+import { QueryExecutionResponse } from '../model/queryExecutionResponse';
 
 import { ObjectSerializer, Authentication, VoidAuth, Interceptor } from '../model/models';
 import { HttpBasicAuth, HttpBearerAuth, ApiKeyAuth, OAuth } from '../model/models';
@@ -109,7 +109,7 @@ export class QueryResourceApi {
      * @param namespaceId 
      * @param dataSourceTablePreviewRequest 
      */
-    public async v1NamespacesNamespaceIdDataSourcesDataSourceIdPreviewPost (dataSourceId: string, namespaceId: string, dataSourceTablePreviewRequest?: DataSourceTablePreviewRequest, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: http.IncomingMessage; body: V1NamespacesNamespaceIdDataSourcesDataSourceIdPreviewPost200Response;  }> {
+    public async getDatasourceTablePreview (dataSourceId: string, namespaceId: string, dataSourceTablePreviewRequest?: DataSourceTablePreviewRequest, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: http.IncomingMessage; body: QueryExecutionResponse;  }> {
         const localVarPath = this.basePath + '/v1/namespaces/{namespaceId}/data-sources/{dataSourceId}/_preview'
             .replace('{' + 'dataSourceId' + '}', encodeURIComponent(String(dataSourceId)))
             .replace('{' + 'namespaceId' + '}', encodeURIComponent(String(namespaceId)));
@@ -126,12 +126,12 @@ export class QueryResourceApi {
 
         // verify required parameter 'dataSourceId' is not null or undefined
         if (dataSourceId === null || dataSourceId === undefined) {
-            throw new Error('Required parameter dataSourceId was null or undefined when calling v1NamespacesNamespaceIdDataSourcesDataSourceIdPreviewPost.');
+            throw new Error('Required parameter dataSourceId was null or undefined when calling getDatasourceTablePreview.');
         }
 
         // verify required parameter 'namespaceId' is not null or undefined
         if (namespaceId === null || namespaceId === undefined) {
-            throw new Error('Required parameter namespaceId was null or undefined when calling v1NamespacesNamespaceIdDataSourcesDataSourceIdPreviewPost.');
+            throw new Error('Required parameter namespaceId was null or undefined when calling getDatasourceTablePreview.');
         }
 
         (<any>Object).assign(localVarHeaderParams, options.headers);
@@ -164,13 +164,13 @@ export class QueryResourceApi {
                     localVarRequestOptions.form = localVarFormParams;
                 }
             }
-            return new Promise<{ response: http.IncomingMessage; body: V1NamespacesNamespaceIdDataSourcesDataSourceIdPreviewPost200Response;  }>((resolve, reject) => {
+            return new Promise<{ response: http.IncomingMessage; body: QueryExecutionResponse;  }>((resolve, reject) => {
                 localVarRequest(localVarRequestOptions, (error, response, body) => {
                     if (error) {
                         reject(error);
                     } else {
                         if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
-                            body = ObjectSerializer.deserialize(body, "V1NamespacesNamespaceIdDataSourcesDataSourceIdPreviewPost200Response");
+                            body = ObjectSerializer.deserialize(body, "QueryExecutionResponse");
                             resolve({ response: response, body: body });
                         } else {
                             reject(new HttpError(response, body, response.statusCode));
@@ -187,7 +187,7 @@ export class QueryResourceApi {
      * @param namespaceId 
      * @param computedViewRunRequest 
      */
-    public async v1NamespacesNamespaceIdDataSourcesDataSourceIdRunPost (dataSourceId: string, namespaceId: string, computedViewRunRequest?: ComputedViewRunRequest, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: http.IncomingMessage; body?: any;  }> {
+    public async runComputedView (dataSourceId: string, namespaceId: string, computedViewRunRequest?: ComputedViewRunRequest, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: http.IncomingMessage; body: QueryExecutionResponse;  }> {
         const localVarPath = this.basePath + '/v1/namespaces/{namespaceId}/data-sources/{dataSourceId}/_run'
             .replace('{' + 'dataSourceId' + '}', encodeURIComponent(String(dataSourceId)))
             .replace('{' + 'namespaceId' + '}', encodeURIComponent(String(namespaceId)));
@@ -204,12 +204,12 @@ export class QueryResourceApi {
 
         // verify required parameter 'dataSourceId' is not null or undefined
         if (dataSourceId === null || dataSourceId === undefined) {
-            throw new Error('Required parameter dataSourceId was null or undefined when calling v1NamespacesNamespaceIdDataSourcesDataSourceIdRunPost.');
+            throw new Error('Required parameter dataSourceId was null or undefined when calling runComputedView.');
         }
 
         // verify required parameter 'namespaceId' is not null or undefined
         if (namespaceId === null || namespaceId === undefined) {
-            throw new Error('Required parameter namespaceId was null or undefined when calling v1NamespacesNamespaceIdDataSourcesDataSourceIdRunPost.');
+            throw new Error('Required parameter namespaceId was null or undefined when calling runComputedView.');
         }
 
         (<any>Object).assign(localVarHeaderParams, options.headers);
@@ -242,12 +242,13 @@ export class QueryResourceApi {
                     localVarRequestOptions.form = localVarFormParams;
                 }
             }
-            return new Promise<{ response: http.IncomingMessage; body?: any;  }>((resolve, reject) => {
+            return new Promise<{ response: http.IncomingMessage; body: QueryExecutionResponse;  }>((resolve, reject) => {
                 localVarRequest(localVarRequestOptions, (error, response, body) => {
                     if (error) {
                         reject(error);
                     } else {
                         if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
+                            body = ObjectSerializer.deserialize(body, "QueryExecutionResponse");
                             resolve({ response: response, body: body });
                         } else {
                             reject(new HttpError(response, body, response.statusCode));

package/model/{v1NamespacesIdGet4xxResponse.ts → clientError.ts}

@@ -12,7 +12,7 @@
 
 import { RequestFile } from './models';
 
-export class V1NamespacesIdGet4xxResponse {
+export class ClientError {
     'status': number;
     'message': string;
 
@@ -31,7 +31,7 @@ export class V1NamespacesIdGet4xxResponse {
         }    ];
 
     static getAttributeTypeMap() {
-        return V1NamespacesIdGet4xxResponse.attributeTypeMap;
+        return ClientError.attributeTypeMap;
     }
 }
 

package/model/{v1NamespacesNamespaceIdDataSourcesIdGet200Response.ts → dataSourceResponse.ts}

@@ -13,7 +13,7 @@
 import { RequestFile } from './models';
 import { DataSource } from './dataSource';
 
-export class V1NamespacesNamespaceIdDataSourcesIdGet200Response {
+export class DataSourceResponse {
     'dataSource': DataSource;
 
     static discriminator: string | undefined = undefined;
@@ -26,7 +26,7 @@ export class V1NamespacesNamespaceIdDataSourcesIdGet200Response {
         }    ];
 
     static getAttributeTypeMap() {
-        return V1NamespacesNamespaceIdDataSourcesIdGet200Response.attributeTypeMap;
+        return DataSourceResponse.attributeTypeMap;
     }
 }
 

package/model/models.ts

@@ -1,5 +1,6 @@
 import localVarRequest from 'request';
 
+export * from './clientError';
 export * from './computedViewRunRequest';
 export * from './dataPage';
 export * from './dataRequestParameters';
@@ -8,19 +9,20 @@ export * from './dataSchema';
 export * from './dataSource';
 export * from './dataSourceConfiguration';
 export * from './dataSourceRequest';
+export * from './dataSourceResponse';
 export * from './dataSourceTablePreviewRequest';
 export * from './namespace';
 export * from './namespaceRequest';
+export * from './namespaceResponse';
+export * from './namespaceResponseMeta';
 export * from './namespaceResponseMetadata';
 export * from './pagingConfiguration';
 export * from './propertySchema';
 export * from './propertyType';
+export * from './queryExecutionResponse';
+export * from './queryExecutionResponseRequestTelemetry';
 export * from './record';
-export * from './v1NamespacesIdGet200Response';
-export * from './v1NamespacesIdGet200ResponseMeta';
-export * from './v1NamespacesIdGet4xxResponse';
-export * from './v1NamespacesNamespaceIdDataSourcesDataSourceIdPreviewPost200Response';
-export * from './v1NamespacesNamespaceIdDataSourcesIdGet200Response';
+export * from './requestTelemetry';
 
 import * as fs from 'fs';
 
@@ -35,6 +37,7 @@ export interface RequestDetailedFile {
 export type RequestFile = string | Buffer | fs.ReadStream | RequestDetailedFile;
 
 
+import { ClientError } from './clientError';
 import { ComputedViewRunRequest } from './computedViewRunRequest';
 import { DataPage } from './dataPage';
 import { DataRequestParameters } from './dataRequestParameters';
@@ -43,19 +46,20 @@ import { DataSchema } from './dataSchema';
 import { DataSource } from './dataSource';
 import { DataSourceConfiguration } from './dataSourceConfiguration';
 import { DataSourceRequest } from './dataSourceRequest';
+import { DataSourceResponse } from './dataSourceResponse';
 import { DataSourceTablePreviewRequest } from './dataSourceTablePreviewRequest';
 import { Namespace } from './namespace';
 import { NamespaceRequest } from './namespaceRequest';
+import { NamespaceResponse } from './namespaceResponse';
+import { NamespaceResponseMeta } from './namespaceResponseMeta';
 import { NamespaceResponseMetadata } from './namespaceResponseMetadata';
 import { PagingConfiguration } from './pagingConfiguration';
 import { PropertySchema } from './propertySchema';
 import { PropertyType } from './propertyType';
+import { QueryExecutionResponse } from './queryExecutionResponse';
+import { QueryExecutionResponseRequestTelemetry } from './queryExecutionResponseRequestTelemetry';
 import { Record } from './record';
-import { V1NamespacesIdGet200Response } from './v1NamespacesIdGet200Response';
-import { V1NamespacesIdGet200ResponseMeta } from './v1NamespacesIdGet200ResponseMeta';
-import { V1NamespacesIdGet4xxResponse } from './v1NamespacesIdGet4xxResponse';
-import { V1NamespacesNamespaceIdDataSourcesDataSourceIdPreviewPost200Response } from './v1NamespacesNamespaceIdDataSourcesDataSourceIdPreviewPost200Response';
-import { V1NamespacesNamespaceIdDataSourcesIdGet200Response } from './v1NamespacesNamespaceIdDataSourcesIdGet200Response';
+import { RequestTelemetry } from './requestTelemetry';
 
 /* tslint:disable:no-unused-variable */
 let primitives = [
@@ -74,6 +78,7 @@ let enumsMap: {[index: string]: any} = {
 }
 
 let typeMap: {[index: string]: any} = {
+    "ClientError": ClientError,
     "ComputedViewRunRequest": ComputedViewRunRequest,
     "DataPage": DataPage,
     "DataRequestParameters": DataRequestParameters,
@@ -82,18 +87,19 @@ let typeMap: {[index: string]: any} = {
     "DataSource": DataSource,
     "DataSourceConfiguration": DataSourceConfiguration,
     "DataSourceRequest": DataSourceRequest,
+    "DataSourceResponse": DataSourceResponse,
     "DataSourceTablePreviewRequest": DataSourceTablePreviewRequest,
     "Namespace": Namespace,
     "NamespaceRequest": NamespaceRequest,
+    "NamespaceResponse": NamespaceResponse,
+    "NamespaceResponseMeta": NamespaceResponseMeta,
     "NamespaceResponseMetadata": NamespaceResponseMetadata,
     "PagingConfiguration": PagingConfiguration,
     "PropertySchema": PropertySchema,
+    "QueryExecutionResponse": QueryExecutionResponse,
+    "QueryExecutionResponseRequestTelemetry": QueryExecutionResponseRequestTelemetry,
     "Record": Record,
-    "V1NamespacesIdGet200Response": V1NamespacesIdGet200Response,
-    "V1NamespacesIdGet200ResponseMeta": V1NamespacesIdGet200ResponseMeta,
-    "V1NamespacesIdGet4xxResponse": V1NamespacesIdGet4xxResponse,
-    "V1NamespacesNamespaceIdDataSourcesDataSourceIdPreviewPost200Response": V1NamespacesNamespaceIdDataSourcesDataSourceIdPreviewPost200Response,
-    "V1NamespacesNamespaceIdDataSourcesIdGet200Response": V1NamespacesNamespaceIdDataSourcesIdGet200Response,
+    "RequestTelemetry": RequestTelemetry,
 }
 
 export class ObjectSerializer {

package/model/{v1NamespacesIdGet200Response.ts → namespaceResponse.ts}

@@ -12,11 +12,11 @@
 
 import { RequestFile } from './models';
 import { Namespace } from './namespace';
-import { V1NamespacesIdGet200ResponseMeta } from './v1NamespacesIdGet200ResponseMeta';
+import { NamespaceResponseMeta } from './namespaceResponseMeta';
 
-export class V1NamespacesIdGet200Response {
+export class NamespaceResponse {
     'namespace': Namespace;
-    'meta': V1NamespacesIdGet200ResponseMeta | null;
+    'meta': NamespaceResponseMeta | null;
 
     static discriminator: string | undefined = undefined;
 
@@ -29,11 +29,11 @@ export class V1NamespacesIdGet200Response {
         {
             "name": "meta",
             "baseName": "meta",
-            "type": "V1NamespacesIdGet200ResponseMeta"
+            "type": "NamespaceResponseMeta"
         }    ];
 
     static getAttributeTypeMap() {
-        return V1NamespacesIdGet200Response.attributeTypeMap;
+        return NamespaceResponse.attributeTypeMap;
     }
 }
 

package/model/{v1NamespacesIdGet200ResponseMeta.ts → namespaceResponseMeta.ts}

@@ -13,7 +13,7 @@
 import { RequestFile } from './models';
 import { DataSource } from './dataSource';
 
-export class V1NamespacesIdGet200ResponseMeta {
+export class NamespaceResponseMeta {
     'dataSources': Array<DataSource>;
 
     static discriminator: string | undefined = undefined;
@@ -26,7 +26,7 @@ export class V1NamespacesIdGet200ResponseMeta {
         }    ];
 
     static getAttributeTypeMap() {
-        return V1NamespacesIdGet200ResponseMeta.attributeTypeMap;
+        return NamespaceResponseMeta.attributeTypeMap;
     }
 }
 

package/model/{v1NamespacesNamespaceIdDataSourcesDataSourceIdPreviewPost200Response.ts → queryExecutionResponse.ts}

@@ -13,12 +13,13 @@
 import { RequestFile } from './models';
 import { DataPage } from './dataPage';
 import { DataResponseMetadata } from './dataResponseMetadata';
+import { QueryExecutionResponseRequestTelemetry } from './queryExecutionResponseRequestTelemetry';
 
-export class V1NamespacesNamespaceIdDataSourcesDataSourceIdPreviewPost200Response {
+export class QueryExecutionResponse {
     'data': DataPage;
     'meta': DataResponseMetadata;
     'tableIdentifier': string;
-    'requestTelemetry'?: object | null;
+    'requestTelemetry'?: QueryExecutionResponseRequestTelemetry | null;
 
     static discriminator: string | undefined = undefined;
 
@@ -41,11 +42,11 @@ export class V1NamespacesNamespaceIdDataSourcesDataSourceIdPreviewPost200Respons
         {
             "name": "requestTelemetry",
             "baseName": "requestTelemetry",
-            "type": "object"
+            "type": "QueryExecutionResponseRequestTelemetry"
         }    ];
 
     static getAttributeTypeMap() {
-        return V1NamespacesNamespaceIdDataSourcesDataSourceIdPreviewPost200Response.attributeTypeMap;
+        return QueryExecutionResponse.attributeTypeMap;
     }
 }
 

package/model/queryExecutionResponseRequestTelemetry.ts

@@ -0,0 +1,43 @@
+/**
+ * fido API
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: unspecified
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { RequestFile } from './models';
+
+export class QueryExecutionResponseRequestTelemetry {
+    'requestTime'?: string | null;
+    'queryTime'?: string | null;
+    'processingTime'?: string | null;
+
+    static discriminator: string | undefined = undefined;
+
+    static attributeTypeMap: Array<{name: string, baseName: string, type: string}> = [
+        {
+            "name": "requestTime",
+            "baseName": "requestTime",
+            "type": "string"
+        },
+        {
+            "name": "queryTime",
+            "baseName": "queryTime",
+            "type": "string"
+        },
+        {
+            "name": "processingTime",
+            "baseName": "processingTime",
+            "type": "string"
+        }    ];
+
+    static getAttributeTypeMap() {
+        return QueryExecutionResponseRequestTelemetry.attributeTypeMap;
+    }
+}
+

package/model/requestTelemetry.ts

@@ -0,0 +1,43 @@
+/**
+ * fido API
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: unspecified
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { RequestFile } from './models';
+
+export class RequestTelemetry {
+    'requestTime'?: string | null;
+    'queryTime'?: string | null;
+    'processingTime'?: string | null;
+
+    static discriminator: string | undefined = undefined;
+
+    static attributeTypeMap: Array<{name: string, baseName: string, type: string}> = [
+        {
+            "name": "requestTime",
+            "baseName": "requestTime",
+            "type": "string"
+        },
+        {
+            "name": "queryTime",
+            "baseName": "queryTime",
+            "type": "string"
+        },
+        {
+            "name": "processingTime",
+            "baseName": "processingTime",
+            "type": "string"
+        }    ];
+
+    static getAttributeTypeMap() {
+        return RequestTelemetry.attributeTypeMap;
+    }
+}
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@explo-tech/fido-api",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "Fido api",
   "homepage": "https://github.com/trust-kaz/fido",
   "license": "MIT",