@explo-tech/fido-api 2.12.10 → 3.0.0-jordan-testing

package/models/ViewResponse.ts

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

package/models/ViewRunRequest.ts

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

package/services/BranchResourceService.ts

@@ -1,112 +0,0 @@
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-import type { BranchResponse } from '../models/BranchResponse';
-import type { DiffBranchResponse } from '../models/DiffBranchResponse';
-import type { ListBranchResponse } from '../models/ListBranchResponse';
-import type { MergeBranchRequest } from '../models/MergeBranchRequest';
-import type { UUID } from '../models/UUID';
-import type { ViewRequest } from '../models/ViewRequest';
-
-import type { CancelablePromise } from '../core/CancelablePromise';
-import { OpenAPI } from '../core/OpenAPI';
-import { request as __request } from '../core/request';
-
-export class BranchResourceService {
-
-    /**
-     * Lists all branches
-     * @returns ListBranchResponse The branches
-     * @throws ApiError
-     */
-    public static listBranches(): CancelablePromise<ListBranchResponse> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/v1/branches',
-        });
-    }
-
-    /**
-     * Creates a new branch
-     * @param requestBody Branch to create
-     * @returns BranchResponse The created branch
-     * @throws ApiError
-     */
-    public static createBranch(
-        requestBody: ViewRequest,
-    ): CancelablePromise<BranchResponse> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/v1/branches',
-            body: requestBody,
-            mediaType: 'application/json',
-        });
-    }
-
-    /**
-     * Returns the diff between the provided source branch and the provided target branch
-     * @param from
-     * @param to
-     * @returns DiffBranchResponse The diff between the two branches
-     * @throws ApiError
-     */
-    public static diffBranch(
-        from?: UUID,
-        to?: UUID,
-    ): CancelablePromise<DiffBranchResponse> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/v1/branches/diff',
-            query: {
-                'from': from,
-                'to': to,
-            },
-        });
-    }
-
-    /**
-     * Gets the branch with the requested id
-     * @param id
-     * @param includeMeta
-     * @returns BranchResponse The requested branch
-     * @throws ApiError
-     */
-    public static getBranch(
-        id: UUID,
-        includeMeta: boolean = false,
-    ): CancelablePromise<BranchResponse> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/v1/branches/{id}',
-            path: {
-                'id': id,
-            },
-            query: {
-                'includeMeta': includeMeta,
-            },
-        });
-    }
-
-    /**
-     * Merge the provided source branch into the provided target branch
-     * @param sourceBranchId
-     * @param requestBody Options for merge
-     * @returns BranchResponse The target branch with the new head
-     * @throws ApiError
-     */
-    public static mergeBranch(
-        sourceBranchId: string,
-        requestBody: MergeBranchRequest,
-    ): CancelablePromise<BranchResponse> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/v1/branches/{sourceBranchId}/merge',
-            path: {
-                'sourceBranchId': sourceBranchId,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-        });
-    }
-
-}

package/services/CommitResourceService.ts

@@ -1,48 +0,0 @@
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-import type { CreateCommitRequest } from '../models/CreateCommitRequest';
-import type { CreateCommitResponse } from '../models/CreateCommitResponse';
-import type { ListViewsResponse } from '../models/ListViewsResponse';
-
-import type { CancelablePromise } from '../core/CancelablePromise';
-import { OpenAPI } from '../core/OpenAPI';
-import { request as __request } from '../core/request';
-
-export class CommitResourceService {
-
-    /**
-     * Creates a new commit on the provided branch
-     * @param branchId
-     * @param requestBody Branch to create
-     * @returns CreateCommitResponse The created commit
-     * @throws ApiError
-     */
-    public static createCommit(
-        branchId: string,
-        requestBody: CreateCommitRequest,
-    ): CancelablePromise<CreateCommitResponse> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/v1/branches/{branchId}/commits',
-            path: {
-                'branchId': branchId,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-        });
-    }
-
-    /**
-     * Lists the views affected by the specified commit
-     * @returns ListViewsResponse The views affected by the commit
-     * @throws ApiError
-     */
-    public static listCommitViews(): CancelablePromise<ListViewsResponse> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/v1/branches/{branchId}/commits/views',
-        });
-    }
-
-}

package/services/DataSourceResourceService.ts

@@ -1,146 +0,0 @@
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-import type { DataSourceRequest } from '../models/DataSourceRequest';
-import type { DataSourceResponse } from '../models/DataSourceResponse';
-import type { ListViewsResponse } from '../models/ListViewsResponse';
-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 {
-
-    /**
-     * Creates a data source
-     * @param namespaceId
-     * @param requestBody Data Source object to create
-     * @returns DataSourceResponse The requested data source
-     * @throws ApiError
-     */
-    public static createDataSource(
-        namespaceId: UUID,
-        requestBody: DataSourceRequest,
-    ): CancelablePromise<DataSourceResponse> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/v1/namespaces/{namespaceId}/data-sources',
-            path: {
-                'namespaceId': namespaceId,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-        });
-    }
-
-    /**
-     * 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: 'application/json',
-        });
-    }
-
-    /**
-     * 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 tables
-     * @param id
-     * @param namespaceId
-     * @returns ListViewsResponse The tables views associated with the data source
-     * @throws ApiError
-     */
-    public static getTables(
-        id: UUID,
-        namespaceId: UUID,
-    ): CancelablePromise<ListViewsResponse> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/v1/namespaces/{namespaceId}/data-sources/{id}/tables',
-            path: {
-                'id': id,
-                'namespaceId': namespaceId,
-            },
-        });
-    }
-
-    /**
-     * Syncs the tables for a given namespace and data source
-     * @param id
-     * @param namespaceId
-     * @returns ListViewsResponse Syncs the tables for a given namespace and data source
-     * @throws ApiError
-     */
-    public static syncTables(
-        id: UUID,
-        namespaceId: UUID,
-    ): CancelablePromise<ListViewsResponse> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/v1/namespaces/{namespaceId}/data-sources/{id}/views/sync',
-            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/ListViewsResourceService.ts

@@ -1,73 +0,0 @@
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-import type { ListVersionedViewsRequest } from '../models/ListVersionedViewsRequest';
-import type { ListViewsRequest } from '../models/ListViewsRequest';
-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 ListViewsResourceService {
-
-    /**
-     * Gets the requested set of views
-     * @param requestBody View ids to get
-     * @returns any The requested views
-     * @throws ApiError
-     */
-    public static batchGetViews(
-        requestBody: ListVersionedViewsRequest,
-    ): CancelablePromise<{
-        views: Array<ViewResponse>;
-    }> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/v1/views/batch-get',
-            body: requestBody,
-            mediaType: 'application/json',
-        });
-    }
-
-    /**
-     * @deprecated
-     * Clones the request set of views
-     * @param requestBody View ids to clone
-     * @returns any The cloned views
-     * @throws ApiError
-     */
-    public static cloneViews(
-        requestBody: ListViewsRequest,
-    ): CancelablePromise<{
-        views: Array<ViewResponse>;
-    }> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/v1/views/clone',
-            body: requestBody,
-            mediaType: 'application/json',
-        });
-    }
-
-    /**
-     * @deprecated
-     * Gets the requested set of views
-     * @param requestBody View ids to get
-     * @returns any The requested views
-     * @throws ApiError
-     */
-    public static getViews(
-        requestBody: ListViewsRequest,
-    ): CancelablePromise<{
-        views: Array<ViewResponse>;
-    }> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/v1/views/get',
-            body: requestBody,
-            mediaType: 'application/json',
-        });
-    }
-
-}

package/services/NamespaceResourceService.ts

@@ -1,120 +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 {
-
-    /**
-     * 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: 'application/json',
-        });
-    }
-
-    /**
-     * Fetches all namespaces and, optionally, their associated data sources and or table views
-     * @param includeDataSources
-     * @param includeViews
-     * @returns any All namespaces, along with associated data sources and or table views
-     * @throws ApiError
-     */
-    public static getNamespaces(
-        includeDataSources: boolean = false,
-        includeViews: boolean = false,
-    ): CancelablePromise<{
-        namespaces: Array<NamespaceResponse>;
-    }> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/v1/namespaces/list',
-            query: {
-                'includeDataSources': includeDataSources,
-                'includeViews': includeViews,
-            },
-        });
-    }
-
-    /**
-     * Gets a namespace and its associated data sources and or views
-     * @param id
-     * @param includeDataSources
-     * @param includeViews
-     * @returns NamespaceResponse The requested namespace, along with its associated data sources and or views
-     * @throws ApiError
-     */
-    public static getNamespace(
-        id: UUID,
-        includeDataSources: boolean = false,
-        includeViews: boolean = false,
-    ): CancelablePromise<NamespaceResponse> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/v1/namespaces/{id}',
-            path: {
-                'id': id,
-            },
-            query: {
-                'includeDataSources': includeDataSources,
-                'includeViews': includeViews,
-            },
-        });
-    }
-
-    /**
-     * 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: 'application/json',
-        });
-    }
-
-    /**
-     * 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,
-            },
-        });
-    }
-
-}