@explo-tech/fido-api 0.0.40 → 0.0.41

package/index.ts

@@ -88,7 +88,11 @@ export type { StringContains } from './models/StringContains';
 export type { StringPropertyValue } from './models/StringPropertyValue';
 export type { TablePreviewRequest } from './models/TablePreviewRequest';
 export type { TableView } from './models/TableView';
+export type { Tenant } from './models/Tenant';
+export type { TenantKey } from './models/TenantKey';
 export type { TenantPrivateKeyAuthentication } from './models/TenantPrivateKeyAuthentication';
+export type { TenantRequest } from './models/TenantRequest';
+export type { TenantResponse } from './models/TenantResponse';
 export type { TestConnectionRequest } from './models/TestConnectionRequest';
 export type { TestConnectionResponse } from './models/TestConnectionResponse';
 export type { Tunnel } from './models/Tunnel';
@@ -105,5 +109,6 @@ export { HealthResourceService } from './services/HealthResourceService';
 export { ListViewsResourceService } from './services/ListViewsResourceService';
 export { NamespaceResourceService } from './services/NamespaceResourceService';
 export { QueryResourceService } from './services/QueryResourceService';
+export { TenantResourceService } from './services/TenantResourceService';
 export { TestConnectionResourceService } from './services/TestConnectionResourceService';
 export { ViewResourceService } from './services/ViewResourceService';

package/models/ComputedView.ts

@@ -3,14 +3,15 @@
 /* eslint-disable */
 
 import type { PropertySchema } from './PropertySchema';
+import type { UUID } from './UUID';
 
 export type ComputedView = {
     name: string;
     description: string | null;
     columnDefinitions: Array<PropertySchema>;
-    readonly id: string;
-    readonly namespaceId: string;
-    '@type': 'computed-view';
+    readonly id?: UUID;
+    readonly namespaceId?: UUID;
+    '@type': string;
     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;
+    readonly id?: string;
+    readonly namespaceId?: string;
     configuration: DataSourceConfiguration;
 };
 

package/models/DataSourceResponse.ts

@@ -2,9 +2,15 @@
 /* tslint:disable */
 /* eslint-disable */
 
-import type { DataSource } from './DataSource';
+import type { DataSourceConfiguration } from './DataSourceConfiguration';
 
 export type DataSourceResponse = {
-    dataSource: DataSource;
+    dataSource: {
+        name: string;
+        externalId: string;
+        readonly id: string;
+        readonly namespaceId: string;
+        configuration: DataSourceConfiguration;
+    };
 };
 

package/models/ListViewsResponse.ts

@@ -2,9 +2,9 @@
 /* tslint:disable */
 /* eslint-disable */
 
-import type { View } from './View';
+import type { ViewResponse } from './ViewResponse';
 
 export type ListViewsResponse = {
-    views: Array<View>;
+    views: Array<ViewResponse>;
 };
 

package/models/Namespace.ts

@@ -5,6 +5,6 @@
 export type Namespace = {
     name: string;
     ignoreTableList?: Array<string>;
-    readonly id: string;
+    readonly id?: string;
 };
 

package/models/NamespaceResponse.ts

@@ -6,7 +6,9 @@ import type { Namespace } from './Namespace';
 import type { NamespaceResponseMetadata } from './NamespaceResponseMetadata';
 
 export type NamespaceResponse = {
-    namespace: Namespace;
+    namespace: (Namespace & {
+        readonly id: string;
+    });
     meta: NamespaceResponseMetadata | null;
 };
 

package/models/TableView.ts

@@ -3,14 +3,15 @@
 /* eslint-disable */
 
 import type { PropertySchema } from './PropertySchema';
+import type { UUID } from './UUID';
 
 export type TableView = {
     name: string;
     description: string | null;
     columnDefinitions: Array<PropertySchema>;
-    readonly id: string;
-    readonly namespaceId: string;
-    '@type': 'table-view';
+    readonly id?: UUID;
+    readonly namespaceId?: UUID;
+    '@type': string;
     tableName: string;
 };
 

package/models/Tenant.ts

@@ -0,0 +1,11 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+
+import type { TenantKey } from './TenantKey';
+
+export type Tenant = {
+    id: string;
+    keys?: Array<TenantKey>;
+};
+

package/models/TenantKey.ts

@@ -0,0 +1,10 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+
+export type TenantKey = {
+    id: string;
+    createdAt: string;
+    value: string | null;
+};
+

package/models/TenantRequest.ts

@@ -0,0 +1,8 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+
+export type TenantRequest = {
+    tenantOptions?: Record<string, any>;
+};
+

package/models/TenantResponse.ts

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

package/models/View.ts

@@ -2,15 +2,13 @@
 /* tslint:disable */
 /* eslint-disable */
 
-import type { ComputedView } from './ComputedView';
 import type { PropertySchema } from './PropertySchema';
-import type { TableView } from './TableView';
 
-export type View = (TableView | ComputedView | {
+export type View = {
     name: string;
     description: string | null;
     columnDefinitions: Array<PropertySchema>;
-    readonly id: string;
-    readonly namespaceId: string;
-});
+    readonly id?: string;
+    readonly namespaceId?: string;
+};
 

package/models/ViewRequest.ts

@@ -2,9 +2,10 @@
 /* tslint:disable */
 /* eslint-disable */
 
-import type { View } from './View';
+import type { ComputedView } from './ComputedView';
+import type { TableView } from './TableView';
 
 export type ViewRequest = {
-    view: View;
+    view: (TableView | ComputedView);
 };
 

package/models/ViewResponse.ts

@@ -5,6 +5,9 @@
 import type { View } from './View';
 
 export type ViewResponse = {
-    view: View;
+    view: (View & {
+        readonly id: string;
+        readonly namespaceId: string;
+    });
 };
 

package/package.json

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

package/services/DataSourceResourceService.ts

@@ -13,66 +13,63 @@ import { request as __request } from '../core/request';
 export class DataSourceResourceService {
 
     /**
-     * Gets a data source
-     * @param id
+     * Creates a data source
      * @param namespaceId
+     * @param requestBody Data Source object to create
      * @returns DataSourceResponse The requested data source
      * @throws ApiError
      */
-    public static getDataSource(
-        id: UUID,
+    public static createDataSource(
         namespaceId: UUID,
+        requestBody: DataSourceRequest,
     ): CancelablePromise<DataSourceResponse> {
         return __request(OpenAPI, {
-            method: 'GET',
-            url: '/v1/namespaces/{namespaceId}/data-sources/{id}',
+            method: 'POST',
+            url: '/v1/namespaces/{namespaceId}/data-sources',
             path: {
-                'id': id,
                 'namespaceId': namespaceId,
             },
+            body: requestBody,
+            mediaType: '*/*',
         });
     }
 
     /**
-     * Updates a data source's metadata
+     * Gets a data source
      * @param id
      * @param namespaceId
-     * @param requestBody Data Source object to update
-     * @returns DataSourceResponse The updated data source
+     * @returns DataSourceResponse The requested data source
      * @throws ApiError
      */
-    public static updateDataSource(
+    public static getDataSource(
         id: UUID,
         namespaceId: UUID,
-        requestBody: DataSourceRequest,
     ): CancelablePromise<DataSourceResponse> {
         return __request(OpenAPI, {
-            method: 'PUT',
+            method: 'GET',
             url: '/v1/namespaces/{namespaceId}/data-sources/{id}',
             path: {
                 'id': id,
                 'namespaceId': namespaceId,
             },
-            body: requestBody,
-            mediaType: '*/*',
         });
     }
 
     /**
-     * Creates a data source
+     * Updates a data source's metadata
      * @param id
      * @param namespaceId
-     * @param requestBody Data Source object to create
-     * @returns DataSourceResponse The requested data source
+     * @param requestBody Data Source object to update
+     * @returns DataSourceResponse The updated data source
      * @throws ApiError
      */
-    public static createDataSource(
+    public static updateDataSource(
         id: UUID,
         namespaceId: UUID,
         requestBody: DataSourceRequest,
     ): CancelablePromise<DataSourceResponse> {
         return __request(OpenAPI, {
-            method: 'POST',
+            method: 'PUT',
             url: '/v1/namespaces/{namespaceId}/data-sources/{id}',
             path: {
                 'id': id,

package/services/ListViewsResourceService.ts

@@ -2,7 +2,7 @@
 /* tslint:disable */
 /* eslint-disable */
 import type { ListViewsRequest } from '../models/ListViewsRequest';
-import type { View } from '../models/View';
+import type { ViewResponse } from '../models/ViewResponse';
 
 import type { CancelablePromise } from '../core/CancelablePromise';
 import { OpenAPI } from '../core/OpenAPI';
@@ -19,7 +19,7 @@ export class ListViewsResourceService {
     public static cloneViews(
         requestBody: ListViewsRequest,
     ): CancelablePromise<{
-        views: Array<View>;
+        views: Array<ViewResponse>;
     }> {
         return __request(OpenAPI, {
             method: 'POST',
@@ -38,7 +38,7 @@ export class ListViewsResourceService {
     public static getViews(
         requestBody: ListViewsRequest,
     ): CancelablePromise<{
-        views: Array<View>;
+        views: Array<ViewResponse>;
     }> {
         return __request(OpenAPI, {
             method: 'POST',

package/services/NamespaceResourceService.ts

@@ -11,6 +11,23 @@ import { request as __request } from '../core/request';
 
 export class NamespaceResourceService {
 
+    /**
+     * Creates a namespace and optionally a data source associated with it
+     * @param requestBody Namespace object to create
+     * @returns NamespaceResponse The requested namespace, along with its associated data source if applicable
+     * @throws ApiError
+     */
+    public static createNamespace(
+        requestBody: NamespaceRequest,
+    ): CancelablePromise<NamespaceResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/v1/namespaces',
+            body: requestBody,
+            mediaType: '*/*',
+        });
+    }
+
     /**
      * Fetches all namespaces and, optionally, their associated data sources
      * @param includeDataSources
@@ -76,28 +93,6 @@ export class NamespaceResourceService {
         });
     }
 
-    /**
-     * 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

package/services/TenantResourceService.ts

@@ -0,0 +1,49 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { TenantRequest } from '../models/TenantRequest';
+import type { TenantResponse } from '../models/TenantResponse';
+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 TenantResourceService {
+
+    /**
+     * Creates a tenant
+     * @param requestBody Tenant request to create with
+     * @returns TenantResponse The requested tenant
+     * @throws ApiError
+     */
+    public static createTenant(
+        requestBody: TenantRequest,
+    ): CancelablePromise<TenantResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/v1/tenants',
+            body: requestBody,
+            mediaType: '*/*',
+        });
+    }
+
+    /**
+     * Gets a tenant
+     * @param id
+     * @returns TenantResponse The requested tenant
+     * @throws ApiError
+     */
+    public static getTenant(
+        id: UUID,
+    ): CancelablePromise<TenantResponse> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/v1/tenants/{id}',
+            path: {
+                'id': id,
+            },
+        });
+    }
+
+}

package/services/ViewResourceService.ts

@@ -12,66 +12,63 @@ import { request as __request } from '../core/request';
 export class ViewResourceService {
 
     /**
-     * Gets a view
-     * @param id
+     * Creates a view
      * @param namespaceId
+     * @param requestBody View object to create
      * @returns ViewResponse The requested view
      * @throws ApiError
      */
-    public static getView(
-        id: UUID,
+    public static createView(
         namespaceId: UUID,
+        requestBody: ViewRequest,
     ): CancelablePromise<ViewResponse> {
         return __request(OpenAPI, {
-            method: 'GET',
-            url: '/v1/namespaces/{namespaceId}/views/{id}',
+            method: 'POST',
+            url: '/v1/namespaces/{namespaceId}/views',
             path: {
-                'id': id,
                 'namespaceId': namespaceId,
             },
+            body: requestBody,
+            mediaType: '*/*',
         });
     }
 
     /**
-     * Updates a view's metadata
+     * Gets a view
      * @param id
      * @param namespaceId
-     * @param requestBody View object to update
-     * @returns ViewResponse The updated view
+     * @returns ViewResponse The requested view
      * @throws ApiError
      */
-    public static updateView(
+    public static getView(
         id: UUID,
         namespaceId: UUID,
-        requestBody: ViewRequest,
     ): CancelablePromise<ViewResponse> {
         return __request(OpenAPI, {
-            method: 'PUT',
+            method: 'GET',
             url: '/v1/namespaces/{namespaceId}/views/{id}',
             path: {
                 'id': id,
                 'namespaceId': namespaceId,
             },
-            body: requestBody,
-            mediaType: '*/*',
         });
     }
 
     /**
-     * Creates a view
+     * Updates a view's metadata
      * @param id
      * @param namespaceId
-     * @param requestBody View object to create
-     * @returns ViewResponse The requested view
+     * @param requestBody View object to update
+     * @returns ViewResponse The updated view
      * @throws ApiError
      */
-    public static createView(
+    public static updateView(
         id: UUID,
         namespaceId: UUID,
         requestBody: ViewRequest,
     ): CancelablePromise<ViewResponse> {
         return __request(OpenAPI, {
-            method: 'POST',
+            method: 'PUT',
             url: '/v1/namespaces/{namespaceId}/views/{id}',
             path: {
                 'id': id,