@explo-tech/fido-api 0.0.13 → 0.0.14

package/index.ts

@@ -7,63 +7,45 @@ export { OpenAPI } from './core/OpenAPI';
 export type { OpenAPIConfig } from './core/OpenAPI';
 
 export type { BooleanPropertyValue } from './models/BooleanPropertyValue';
-export type { BulkViewsRequest } from './models/BulkViewsRequest';
+export type { BulkNamespacesResponse } from './models/BulkNamespacesResponse';
 export type { BulkViewsResponse } from './models/BulkViewsResponse';
 export type { ClientError } from './models/ClientError';
-export type { Computation } from './models/Computation';
 export type { ComputedView } from './models/ComputedView';
 export type { DataPage } from './models/DataPage';
 export type { DataRecord } from './models/DataRecord';
-export type { DataRequestParameters } from './models/DataRequestParameters';
 export type { DataResponseMetadata } from './models/DataResponseMetadata';
 export type { DataSchema } from './models/DataSchema';
 export type { DataSource } from './models/DataSource';
 export type { DataSourceConfiguration } from './models/DataSourceConfiguration';
-export type { DataSourceRequest } from './models/DataSourceRequest';
 export type { DataSourceResponse } from './models/DataSourceResponse';
 export type { DatePropertyValue } from './models/DatePropertyValue';
 export type { DateTimePropertyValue } from './models/DateTimePropertyValue';
 export type { DecimalPropertyValue } from './models/DecimalPropertyValue';
 export type { DoublePropertyValue } from './models/DoublePropertyValue';
-export type { Filter } from './models/Filter';
 export type { IntegerPropertyValue } from './models/IntegerPropertyValue';
 export type { MySql } from './models/MySql';
 export type { MySqlAuthentication } from './models/MySqlAuthentication';
 export type { Namespace } from './models/Namespace';
-export type { NamespaceRequest } from './models/NamespaceRequest';
 export type { NamespaceResponse } from './models/NamespaceResponse';
 export type { NamespaceResponseMetadata } from './models/NamespaceResponseMetadata';
-export type { PagingConfiguration } from './models/PagingConfiguration';
 export type { PasswordAuthentication } from './models/PasswordAuthentication';
 export type { Postgres } from './models/Postgres';
 export type { PostgresAuthentication } from './models/PostgresAuthentication';
-export type { Property } from './models/Property';
 export type { PropertySchema } from './models/PropertySchema';
 export { PropertyType } from './models/PropertyType';
 export type { PropertyValue } from './models/PropertyValue';
 export type { PublicTunnel } from './models/PublicTunnel';
 export type { QueryExecutionResponse } from './models/QueryExecutionResponse';
-export type { QueryPreviewRequest } from './models/QueryPreviewRequest';
 export type { RequestTelemetry } from './models/RequestTelemetry';
-export type { Sort } from './models/Sort';
-export { SortDirection } from './models/SortDirection';
 export type { SSHAuthentication } from './models/SSHAuthentication';
 export type { SSHTunnel } from './models/SSHTunnel';
 export type { StringPropertyValue } from './models/StringPropertyValue';
-export type { TablePreviewRequest } from './models/TablePreviewRequest';
 export type { TableView } from './models/TableView';
 export type { TenantPrivateKeyAuthentication } from './models/TenantPrivateKeyAuthentication';
 export type { Tunnel } from './models/Tunnel';
 export type { UUID } from './models/UUID';
 export type { VendorPrivateKeyAuthentication } from './models/VendorPrivateKeyAuthentication';
 export type { View } from './models/View';
-export type { ViewRequest } from './models/ViewRequest';
 export type { ViewResponse } from './models/ViewResponse';
-export type { ViewRunRequest } from './models/ViewRunRequest';
 
-export { BulkViewsResourceService } from './services/BulkViewsResourceService';
-export { DataSourceResourceService } from './services/DataSourceResourceService';
-export { HealthResourceService } from './services/HealthResourceService';
-export { NamespaceResourceService } from './services/NamespaceResourceService';
-export { QueryResourceService } from './services/QueryResourceService';
-export { ViewResourceService } from './services/ViewResourceService';
+export { DefaultService } from './services/DefaultService';

package/models/BulkNamespacesResponse.ts

@@ -0,0 +1,10 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+
+import type { NamespaceResponse } from './NamespaceResponse';
+
+export type BulkNamespacesResponse = {
+    namespaces: Array<NamespaceResponse>;
+};
+

package/models/ComputedView.ts

@@ -8,8 +8,8 @@ export type ComputedView = {
     name: string;
     description: string | null;
     columnDefinitions: Array<PropertySchema>;
-    readonly id: string;
-    readonly namespaceId: string;
+    id: string | null;
+    namespaceId: string | null;
     query: string;
 };
 

package/models/DataSource.ts

@@ -7,8 +7,8 @@ import type { DataSourceConfiguration } from './DataSourceConfiguration';
 export type DataSource = {
     name: string;
     externalId: string;
-    readonly id: string;
-    readonly namespaceId: string;
+    id: string | null;
+    namespaceId: string | null;
     configuration: DataSourceConfiguration;
 };
 

package/models/Namespace.ts

@@ -4,6 +4,6 @@
 
 export type Namespace = {
     name: string;
-    readonly id: string;
+    id: string | null;
 };
 

package/models/TableView.ts

@@ -8,8 +8,8 @@ export type TableView = {
     name: string;
     description: string | null;
     columnDefinitions: Array<PropertySchema>;
-    readonly id: string;
-    readonly namespaceId: string;
+    id: string | null;
+    namespaceId: string | null;
     tableName: string;
 };
 

package/models/View.ts

@@ -10,7 +10,7 @@ export type View = (TableView | ComputedView | {
     name: string;
     description: string | null;
     columnDefinitions: Array<PropertySchema>;
-    readonly id: string;
-    readonly namespaceId: string;
+    id: string | null;
+    namespaceId: string | null;
 });
 

package/package.json

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

package/services/DefaultService.ts

@@ -0,0 +1,409 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { DataSourceResponse } from '../models/DataSourceResponse';
+import type { NamespaceResponse } from '../models/NamespaceResponse';
+import type { QueryExecutionResponse } from '../models/QueryExecutionResponse';
+import type { UUID } from '../models/UUID';
+import type { View } from '../models/View';
+import type { ViewResponse } from '../models/ViewResponse';
+
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+
+export class DefaultService {
+
+    /**
+     * Returns the entire state of the FIDO application
+     * @returns any A response with the current status of the FIDO
+     * @throws ApiError
+     */
+    public static getFidoHealth(): CancelablePromise<Record<string, any>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/v1/health',
+        });
+    }
+
+    /**
+     * Verifies that the DataSourceConnection verticle is alive
+     * @param dataSourceId
+     * @param namespaceId
+     * @returns any A response with the current status of the verticle
+     * @throws ApiError
+     */
+    public static getDataSourceConnectionHealth(
+        dataSourceId: UUID,
+        namespaceId: UUID,
+    ): CancelablePromise<Record<string, any>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/v1/health/data-source-connection/{namespaceId}/{dataSourceId}',
+            path: {
+                'dataSourceId': dataSourceId,
+                'namespaceId': namespaceId,
+            },
+        });
+    }
+
+    /**
+     * Fetches all namespaces and its associated data sources
+     * @param includeDataSources
+     * @returns any All namespaces, along with associated data sources
+     * @throws ApiError
+     */
+    public static getNamespaces(
+        includeDataSources: boolean = false,
+    ): CancelablePromise<{
+        namespaces: Array<NamespaceResponse>;
+    }> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/v1/namespaces/list',
+            query: {
+                'includeDataSources': includeDataSources,
+            },
+        });
+    }
+
+    /**
+     * Gets a namespace and its associated data sources
+     * @param id
+     * @param includeDataSources
+     * @returns NamespaceResponse The requested namespace, along with its associated data sources
+     * @throws ApiError
+     */
+    public static getNamespace(
+        id: UUID,
+        includeDataSources: boolean = false,
+    ): CancelablePromise<NamespaceResponse> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/v1/namespaces/{id}',
+            path: {
+                'id': id,
+            },
+            query: {
+                'includeDataSources': includeDataSources,
+            },
+        });
+    }
+
+    /**
+     * Updates a namespace's metadata
+     * @param id
+     * @returns NamespaceResponse The updated namespace, along with its associated data sources
+     * @throws ApiError
+     */
+    public static updateNamespace(
+        id: UUID,
+    ): CancelablePromise<NamespaceResponse> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/v1/namespaces/{id}',
+            path: {
+                'id': id,
+            },
+        });
+    }
+
+    /**
+     * Creates a namespace and optionally a data source associated with it
+     * @param id
+     * @returns NamespaceResponse The requested namespace, along with its associated data source if applicable
+     * @throws ApiError
+     */
+    public static createNamespace(
+        id: UUID,
+    ): CancelablePromise<NamespaceResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/v1/namespaces/{id}',
+            path: {
+                'id': id,
+            },
+        });
+    }
+
+    /**
+     * Deletes a namespace, cascading to its associated resources
+     * @param id
+     * @returns any 200 if the namespace was deleted properly
+     * @throws ApiError
+     */
+    public static deleteNamespace(
+        id: UUID,
+    ): CancelablePromise<Record<string, any>> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/v1/namespaces/{id}',
+            path: {
+                'id': id,
+            },
+        });
+    }
+
+    /**
+     * Runs a provided query against the provided data source
+     * @param dataSourceId
+     * @param namespaceId
+     * @returns QueryExecutionResponse A DataPage of the provided query
+     * @throws ApiError
+     */
+    public static getQueryPreview(
+        dataSourceId: UUID,
+        namespaceId: UUID,
+    ): CancelablePromise<QueryExecutionResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/v1/namespaces/{namespaceId}/data-sources/{dataSourceId}/preview',
+            path: {
+                'dataSourceId': dataSourceId,
+                'namespaceId': namespaceId,
+            },
+        });
+    }
+
+    /**
+     * Gets a preview of a specified table in a Data Source
+     * @param dataSourceId
+     * @param namespaceId
+     * @returns QueryExecutionResponse A DataPage of the resulting Data Source's data
+     * @throws ApiError
+     */
+    public static getTablePreview(
+        dataSourceId: UUID,
+        namespaceId: UUID,
+    ): CancelablePromise<QueryExecutionResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/v1/namespaces/{namespaceId}/data-sources/{dataSourceId}/preview-table',
+            path: {
+                'dataSourceId': dataSourceId,
+                'namespaceId': namespaceId,
+            },
+        });
+    }
+
+    /**
+     * Runs the requested view against the provided data source
+     * @param dataSourceId
+     * @param namespaceId
+     * @param viewId
+     * @returns QueryExecutionResponse A DataPage of the provided query
+     * @throws ApiError
+     */
+    public static runView(
+        dataSourceId: UUID,
+        namespaceId: UUID,
+        viewId: UUID,
+    ): CancelablePromise<QueryExecutionResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/v1/namespaces/{namespaceId}/data-sources/{dataSourceId}/views/{viewId}/run',
+            path: {
+                'dataSourceId': dataSourceId,
+                'namespaceId': namespaceId,
+                'viewId': viewId,
+            },
+        });
+    }
+
+    /**
+     * Gets a data source
+     * @param id
+     * @param namespaceId
+     * @returns DataSourceResponse The requested data source
+     * @throws ApiError
+     */
+    public static getDataSource(
+        id: UUID,
+        namespaceId: UUID,
+    ): CancelablePromise<DataSourceResponse> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/v1/namespaces/{namespaceId}/data-sources/{id}',
+            path: {
+                'id': id,
+                'namespaceId': namespaceId,
+            },
+        });
+    }
+
+    /**
+     * Updates a data source's metadata
+     * @param id
+     * @param namespaceId
+     * @returns DataSourceResponse The updated data source
+     * @throws ApiError
+     */
+    public static updateDataSource(
+        id: UUID,
+        namespaceId: UUID,
+    ): CancelablePromise<DataSourceResponse> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/v1/namespaces/{namespaceId}/data-sources/{id}',
+            path: {
+                'id': id,
+                'namespaceId': namespaceId,
+            },
+        });
+    }
+
+    /**
+     * Creates a data source
+     * @param id
+     * @param namespaceId
+     * @returns DataSourceResponse The requested data source
+     * @throws ApiError
+     */
+    public static createDataSource(
+        id: UUID,
+        namespaceId: UUID,
+    ): CancelablePromise<DataSourceResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/v1/namespaces/{namespaceId}/data-sources/{id}',
+            path: {
+                'id': id,
+                'namespaceId': namespaceId,
+            },
+        });
+    }
+
+    /**
+     * Deletes a data source
+     * @param id
+     * @param namespaceId
+     * @returns any 200 if the data source was deleted properly
+     * @throws ApiError
+     */
+    public static deleteDataSource(
+        id: UUID,
+        namespaceId: UUID,
+    ): CancelablePromise<Record<string, any>> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/v1/namespaces/{namespaceId}/data-sources/{id}',
+            path: {
+                'id': id,
+                'namespaceId': namespaceId,
+            },
+        });
+    }
+
+    /**
+     * Gets a view
+     * @param id
+     * @param namespaceId
+     * @returns ViewResponse The requested view
+     * @throws ApiError
+     */
+    public static getView(
+        id: UUID,
+        namespaceId: UUID,
+    ): CancelablePromise<ViewResponse> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/v1/namespaces/{namespaceId}/views/{id}',
+            path: {
+                'id': id,
+                'namespaceId': namespaceId,
+            },
+        });
+    }
+
+    /**
+     * Updates a view's metadata
+     * @param id
+     * @param namespaceId
+     * @returns ViewResponse The updated view
+     * @throws ApiError
+     */
+    public static updateView(
+        id: UUID,
+        namespaceId: UUID,
+    ): CancelablePromise<ViewResponse> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/v1/namespaces/{namespaceId}/views/{id}',
+            path: {
+                'id': id,
+                'namespaceId': namespaceId,
+            },
+        });
+    }
+
+    /**
+     * Creates a view
+     * @param id
+     * @param namespaceId
+     * @returns ViewResponse The requested view
+     * @throws ApiError
+     */
+    public static createView(
+        id: UUID,
+        namespaceId: UUID,
+    ): CancelablePromise<ViewResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/v1/namespaces/{namespaceId}/views/{id}',
+            path: {
+                'id': id,
+                'namespaceId': namespaceId,
+            },
+        });
+    }
+
+    /**
+     * Deletes a view
+     * @param id
+     * @param namespaceId
+     * @returns any 200 if the view was deleted properly
+     * @throws ApiError
+     */
+    public static deleteView(
+        id: UUID,
+        namespaceId: UUID,
+    ): CancelablePromise<Record<string, any>> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/v1/namespaces/{namespaceId}/views/{id}',
+            path: {
+                'id': id,
+                'namespaceId': namespaceId,
+            },
+        });
+    }
+
+    /**
+     * Clones the request set of views
+     * @returns any The cloned views
+     * @throws ApiError
+     */
+    public static cloneViews(): CancelablePromise<{
+        views: Array<View>;
+    }> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/v1/views/clone',
+        });
+    }
+
+    /**
+     * Deletes a view
+     * @returns any The requested views
+     * @throws ApiError
+     */
+    public static getViews(): CancelablePromise<{
+        views: Array<View>;
+    }> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/v1/views/get',
+        });
+    }
+
+}

package/.tool-versions

@@ -1 +0,0 @@
-nodejs 16.17.1

package/models/BulkViewsRequest.ts

@@ -1,8 +0,0 @@
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-
-export type BulkViewsRequest = {
-    viewIds: Array<string>;
-};
-

package/models/Computation.ts

@@ -1,14 +0,0 @@
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-
-import type { Filter } from './Filter';
-import type { Property } from './Property';
-import type { Sort } from './Sort';
-
-export type Computation = {
-    properties: Array<Property>;
-    filter: Filter | null;
-    sorts: Array<Sort>;
-};
-

package/models/DataRequestParameters.ts

@@ -1,11 +0,0 @@
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-
-import type { PagingConfiguration } from './PagingConfiguration';
-
-export type DataRequestParameters = {
-    pagingConfiguration?: PagingConfiguration;
-    includeTotalResults?: boolean;
-};
-

package/models/DataSourceRequest.ts

@@ -1,10 +0,0 @@
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-
-import type { DataSource } from './DataSource';
-
-export type DataSourceRequest = {
-    dataSource: DataSource;
-};
-

package/models/Filter.ts

@@ -1,5 +0,0 @@
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-
-export type Filter = Record<string, any>;

package/models/NamespaceRequest.ts

@@ -1,10 +0,0 @@
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-
-import type { Namespace } from './Namespace';
-
-export type NamespaceRequest = {
-    namespace: Namespace;
-};
-

package/models/PagingConfiguration.ts

@@ -1,9 +0,0 @@
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-
-export type PagingConfiguration = {
-    perPage?: number;
-    page?: number;
-};
-

package/models/Property.ts

@@ -1,8 +0,0 @@
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-
-export type Property = {
-    propertyId: string;
-};
-

package/models/QueryPreviewRequest.ts

@@ -1,15 +0,0 @@
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-
-import type { Computation } from './Computation';
-import type { DataRequestParameters } from './DataRequestParameters';
-
-export type QueryPreviewRequest = {
-    query: string;
-    tableIdentifier: string;
-    dataRequestParameters: DataRequestParameters;
-    queryContext: Record<string, any>;
-    computation: Computation | null;
-};
-

package/models/Sort.ts

@@ -1,11 +0,0 @@
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-
-import type { SortDirection } from './SortDirection';
-
-export type Sort = {
-    sortDirection: SortDirection;
-    propertyId: string;
-};
-

package/models/SortDirection.ts

@@ -1,8 +0,0 @@
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-
-export enum SortDirection {
-    ASCENDING = 'ASCENDING',
-    DESCENDING = 'DESCENDING',
-}

package/models/TablePreviewRequest.ts

@@ -1,11 +0,0 @@
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-
-import type { DataRequestParameters } from './DataRequestParameters';
-
-export type TablePreviewRequest = {
-    tableIdentifier: string;
-    dataRequestParameters: DataRequestParameters;
-};
-

package/models/ViewRequest.ts

@@ -1,10 +0,0 @@
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-
-import type { View } from './View';
-
-export type ViewRequest = {
-    view: View;
-};
-

package/models/ViewRunRequest.ts

@@ -1,13 +0,0 @@
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-
-import type { Computation } from './Computation';
-import type { DataRequestParameters } from './DataRequestParameters';
-
-export type ViewRunRequest = {
-    dataRequestParameters: DataRequestParameters;
-    queryContext: Record<string, any>;
-    computation: Computation | null;
-};
-

package/services/BulkViewsResourceService.ts

@@ -1,51 +0,0 @@
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-import type { BulkViewsRequest } from '../models/BulkViewsRequest';
-import type { View } from '../models/View';
-
-import type { CancelablePromise } from '../core/CancelablePromise';
-import { OpenAPI } from '../core/OpenAPI';
-import { request as __request } from '../core/request';
-
-export class BulkViewsResourceService {
-
-    /**
-     * Clones the request set of views
-     * @param requestBody View ids to clone
-     * @returns any The cloned views
-     * @throws ApiError
-     */
-    public static cloneViews(
-        requestBody: BulkViewsRequest,
-    ): CancelablePromise<{
-        views: Array<View>;
-    }> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/v1/views/clone',
-            body: requestBody,
-            mediaType: '*/*',
-        });
-    }
-
-    /**
-     * Deletes a view
-     * @param requestBody View ids to get
-     * @returns any The requested views
-     * @throws ApiError
-     */
-    public static getViews(
-        requestBody: BulkViewsRequest,
-    ): CancelablePromise<{
-        views: Array<View>;
-    }> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/v1/views/get',
-            body: requestBody,
-            mediaType: '*/*',
-        });
-    }
-
-}

package/services/DataSourceResourceService.ts

@@ -1,106 +0,0 @@
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-import type { DataSourceRequest } from '../models/DataSourceRequest';
-import type { DataSourceResponse } from '../models/DataSourceResponse';
-import type { UUID } from '../models/UUID';
-
-import type { CancelablePromise } from '../core/CancelablePromise';
-import { OpenAPI } from '../core/OpenAPI';
-import { request as __request } from '../core/request';
-
-export class DataSourceResourceService {
-
-    /**
-     * Gets a data source
-     * @param id
-     * @param namespaceId
-     * @returns DataSourceResponse The requested data source
-     * @throws ApiError
-     */
-    public static getDataSource(
-        id: UUID,
-        namespaceId: UUID,
-    ): CancelablePromise<DataSourceResponse> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/v1/namespaces/{namespaceId}/data-sources/{id}',
-            path: {
-                'id': id,
-                'namespaceId': namespaceId,
-            },
-        });
-    }
-
-    /**
-     * Updates a data source's metadata
-     * @param id
-     * @param namespaceId
-     * @param requestBody Data Source object to update
-     * @returns DataSourceResponse The updated data source
-     * @throws ApiError
-     */
-    public static updateDataSource(
-        id: UUID,
-        namespaceId: UUID,
-        requestBody: DataSourceRequest,
-    ): CancelablePromise<DataSourceResponse> {
-        return __request(OpenAPI, {
-            method: 'PUT',
-            url: '/v1/namespaces/{namespaceId}/data-sources/{id}',
-            path: {
-                'id': id,
-                'namespaceId': namespaceId,
-            },
-            body: requestBody,
-            mediaType: '*/*',
-        });
-    }
-
-    /**
-     * Creates a data source
-     * @param id
-     * @param namespaceId
-     * @param requestBody Data Source object to create
-     * @returns DataSourceResponse The requested data source
-     * @throws ApiError
-     */
-    public static createDataSource(
-        id: UUID,
-        namespaceId: UUID,
-        requestBody: DataSourceRequest,
-    ): CancelablePromise<DataSourceResponse> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/v1/namespaces/{namespaceId}/data-sources/{id}',
-            path: {
-                'id': id,
-                'namespaceId': namespaceId,
-            },
-            body: requestBody,
-            mediaType: '*/*',
-        });
-    }
-
-    /**
-     * Deletes a data source
-     * @param id
-     * @param namespaceId
-     * @returns any 200 if the data source was deleted properly
-     * @throws ApiError
-     */
-    public static deleteDataSource(
-        id: UUID,
-        namespaceId: UUID,
-    ): CancelablePromise<Record<string, any>> {
-        return __request(OpenAPI, {
-            method: 'DELETE',
-            url: '/v1/namespaces/{namespaceId}/data-sources/{id}',
-            path: {
-                'id': id,
-                'namespaceId': namespaceId,
-            },
-        });
-    }
-
-}

package/services/HealthResourceService.ts

@@ -1,45 +0,0 @@
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-import type { UUID } from '../models/UUID';
-
-import type { CancelablePromise } from '../core/CancelablePromise';
-import { OpenAPI } from '../core/OpenAPI';
-import { request as __request } from '../core/request';
-
-export class HealthResourceService {
-
-    /**
-     * Returns the entire state of the FIDO application
-     * @returns any A response with the current status of the FIDO
-     * @throws ApiError
-     */
-    public static getFidoHealth(): CancelablePromise<Record<string, any>> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/v1/health',
-        });
-    }
-
-    /**
-     * Verifies that the DataSourceConnection verticle is alive
-     * @param dataSourceId
-     * @param namespaceId
-     * @returns any A response with the current status of the verticle
-     * @throws ApiError
-     */
-    public static getDataSourceConnectionHealth(
-        dataSourceId: UUID,
-        namespaceId: UUID,
-    ): CancelablePromise<Record<string, any>> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/v1/health/data-source-connection/{namespaceId}/{dataSourceId}',
-            path: {
-                'dataSourceId': dataSourceId,
-                'namespaceId': namespaceId,
-            },
-        });
-    }
-
-}

package/services/NamespaceResourceService.ts

@@ -1,99 +0,0 @@
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-import type { NamespaceRequest } from '../models/NamespaceRequest';
-import type { NamespaceResponse } from '../models/NamespaceResponse';
-import type { UUID } from '../models/UUID';
-
-import type { CancelablePromise } from '../core/CancelablePromise';
-import { OpenAPI } from '../core/OpenAPI';
-import { request as __request } from '../core/request';
-
-export class NamespaceResourceService {
-
-    /**
-     * Gets a namespace and its associated data sources
-     * @param id
-     * @param includeDataSources
-     * @returns NamespaceResponse The requested namespace, along with its associated data sources
-     * @throws ApiError
-     */
-    public static getNamespace(
-        id: UUID,
-        includeDataSources: boolean = false,
-    ): CancelablePromise<NamespaceResponse> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/v1/namespaces/{id}',
-            path: {
-                'id': id,
-            },
-            query: {
-                'includeDataSources': includeDataSources,
-            },
-        });
-    }
-
-    /**
-     * Updates a namespace's metadata
-     * @param id
-     * @param requestBody Namespace object to update
-     * @returns NamespaceResponse The updated namespace, along with its associated data sources
-     * @throws ApiError
-     */
-    public static updateNamespace(
-        id: UUID,
-        requestBody: NamespaceRequest,
-    ): CancelablePromise<NamespaceResponse> {
-        return __request(OpenAPI, {
-            method: 'PUT',
-            url: '/v1/namespaces/{id}',
-            path: {
-                'id': id,
-            },
-            body: requestBody,
-            mediaType: '*/*',
-        });
-    }
-
-    /**
-     * Creates a namespace and optionally a data source associated with it
-     * @param id
-     * @param requestBody Namespace object to create
-     * @returns NamespaceResponse The requested namespace, along with its associated data source if applicable
-     * @throws ApiError
-     */
-    public static createNamespace(
-        id: UUID,
-        requestBody: NamespaceRequest,
-    ): CancelablePromise<NamespaceResponse> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/v1/namespaces/{id}',
-            path: {
-                'id': id,
-            },
-            body: requestBody,
-            mediaType: '*/*',
-        });
-    }
-
-    /**
-     * Deletes a namespace, cascading to its associated resources
-     * @param id
-     * @returns any 200 if the namespace was deleted properly
-     * @throws ApiError
-     */
-    public static deleteNamespace(
-        id: UUID,
-    ): CancelablePromise<Record<string, any>> {
-        return __request(OpenAPI, {
-            method: 'DELETE',
-            url: '/v1/namespaces/{id}',
-            path: {
-                'id': id,
-            },
-        });
-    }
-
-}

package/services/QueryResourceService.ts

@@ -1,94 +0,0 @@
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-import type { QueryExecutionResponse } from '../models/QueryExecutionResponse';
-import type { QueryPreviewRequest } from '../models/QueryPreviewRequest';
-import type { TablePreviewRequest } from '../models/TablePreviewRequest';
-import type { UUID } from '../models/UUID';
-import type { ViewRunRequest } from '../models/ViewRunRequest';
-
-import type { CancelablePromise } from '../core/CancelablePromise';
-import { OpenAPI } from '../core/OpenAPI';
-import { request as __request } from '../core/request';
-
-export class QueryResourceService {
-
-    /**
-     * Runs a provided query against the provided data source
-     * @param dataSourceId
-     * @param namespaceId
-     * @param requestBody Query to preview against the provided data source
-     * @returns QueryExecutionResponse A DataPage of the provided query
-     * @throws ApiError
-     */
-    public static getQueryPreview(
-        dataSourceId: UUID,
-        namespaceId: UUID,
-        requestBody: QueryPreviewRequest,
-    ): CancelablePromise<QueryExecutionResponse> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/v1/namespaces/{namespaceId}/data-sources/{dataSourceId}/preview',
-            path: {
-                'dataSourceId': dataSourceId,
-                'namespaceId': namespaceId,
-            },
-            body: requestBody,
-            mediaType: '*/*',
-        });
-    }
-
-    /**
-     * Gets a preview of a specified table in a Data Source
-     * @param dataSourceId
-     * @param namespaceId
-     * @param requestBody Table to preview against the provided data source
-     * @returns QueryExecutionResponse A DataPage of the resulting Data Source's data
-     * @throws ApiError
-     */
-    public static getTablePreview(
-        dataSourceId: UUID,
-        namespaceId: UUID,
-        requestBody: TablePreviewRequest,
-    ): CancelablePromise<QueryExecutionResponse> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/v1/namespaces/{namespaceId}/data-sources/{dataSourceId}/preview-table',
-            path: {
-                'dataSourceId': dataSourceId,
-                'namespaceId': namespaceId,
-            },
-            body: requestBody,
-            mediaType: '*/*',
-        });
-    }
-
-    /**
-     * Runs the requested view against the provided data source
-     * @param dataSourceId
-     * @param namespaceId
-     * @param viewId
-     * @param requestBody View to run against the provided data source
-     * @returns QueryExecutionResponse A DataPage of the provided query
-     * @throws ApiError
-     */
-    public static runView(
-        dataSourceId: UUID,
-        namespaceId: UUID,
-        viewId: UUID,
-        requestBody: ViewRunRequest,
-    ): CancelablePromise<QueryExecutionResponse> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/v1/namespaces/{namespaceId}/data-sources/{dataSourceId}/views/{viewId}/run',
-            path: {
-                'dataSourceId': dataSourceId,
-                'namespaceId': namespaceId,
-                'viewId': viewId,
-            },
-            body: requestBody,
-            mediaType: '*/*',
-        });
-    }
-
-}

package/services/ViewResourceService.ts

@@ -1,106 +0,0 @@
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-import type { UUID } from '../models/UUID';
-import type { ViewRequest } from '../models/ViewRequest';
-import type { ViewResponse } from '../models/ViewResponse';
-
-import type { CancelablePromise } from '../core/CancelablePromise';
-import { OpenAPI } from '../core/OpenAPI';
-import { request as __request } from '../core/request';
-
-export class ViewResourceService {
-
-    /**
-     * Gets a view
-     * @param id
-     * @param namespaceId
-     * @returns ViewResponse The requested view
-     * @throws ApiError
-     */
-    public static getView(
-        id: UUID,
-        namespaceId: UUID,
-    ): CancelablePromise<ViewResponse> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/v1/namespaces/{namespaceId}/views/{id}',
-            path: {
-                'id': id,
-                'namespaceId': namespaceId,
-            },
-        });
-    }
-
-    /**
-     * Updates a view's metadata
-     * @param id
-     * @param namespaceId
-     * @param requestBody View object to update
-     * @returns ViewResponse The updated view
-     * @throws ApiError
-     */
-    public static updateView(
-        id: UUID,
-        namespaceId: UUID,
-        requestBody: ViewRequest,
-    ): CancelablePromise<ViewResponse> {
-        return __request(OpenAPI, {
-            method: 'PUT',
-            url: '/v1/namespaces/{namespaceId}/views/{id}',
-            path: {
-                'id': id,
-                'namespaceId': namespaceId,
-            },
-            body: requestBody,
-            mediaType: '*/*',
-        });
-    }
-
-    /**
-     * Creates a view
-     * @param id
-     * @param namespaceId
-     * @param requestBody View object to create
-     * @returns ViewResponse The requested view
-     * @throws ApiError
-     */
-    public static createView(
-        id: UUID,
-        namespaceId: UUID,
-        requestBody: ViewRequest,
-    ): CancelablePromise<ViewResponse> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/v1/namespaces/{namespaceId}/views/{id}',
-            path: {
-                'id': id,
-                'namespaceId': namespaceId,
-            },
-            body: requestBody,
-            mediaType: '*/*',
-        });
-    }
-
-    /**
-     * Deletes a view
-     * @param id
-     * @param namespaceId
-     * @returns any 200 if the view was deleted properly
-     * @throws ApiError
-     */
-    public static deleteView(
-        id: UUID,
-        namespaceId: UUID,
-    ): CancelablePromise<Record<string, any>> {
-        return __request(OpenAPI, {
-            method: 'DELETE',
-            url: '/v1/namespaces/{namespaceId}/views/{id}',
-            path: {
-                'id': id,
-                'namespaceId': namespaceId,
-            },
-        });
-    }
-
-}