@fusebase/fusebase-gate-sdk 1.0.2-sdk.4 → 2.0.7

package/dist/apis/DashboardsApi.js

@@ -1,507 +0,0 @@
-"use strict";
-/**
- * Dashboards API
- *
- * Generated from contract introspection
- * Domain: dashboards
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DashboardsApi = void 0;
-class DashboardsApi {
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * Assign or update representation for a view
-     * Create or update a representation instance for a dashboard view. If this is the first representation for the view, it will automatically be set as default.
-     */
-    async assignRepresentationToView(params) {
-        return this.client.request({
-            method: "POST",
-            path: "/dashboards/:dashboardId/views/:viewId/representations/:representationTemplateId",
-            pathParams: params.path,
-            headers: params.headers,
-            body: params.body,
-            opId: "assignRepresentationToView",
-            expectedContentType: "application/json",
-        });
-    }
-    /**
-     * Copy dashboard from another dashboard
-     * Create a new dashboard by copying an existing dashboard with all its views, representations, rows, and optionally data
-     */
-    async copyDashboardFromDashboard(params) {
-        return this.client.request({
-            method: "POST",
-            path: "/dashboards/copy-from/dashboard",
-            query: params.query,
-            headers: params.headers,
-            body: params.body,
-            opId: "copyDashboardFromDashboard",
-            expectedContentType: "application/json",
-        });
-    }
-    /**
-     * Create dashboard
-     * Create a new dashboard
-     */
-    async createDashboard(params) {
-        return this.client.request({
-            method: "POST",
-            path: "/dashboards",
-            headers: params.headers,
-            body: params.body,
-            opId: "createDashboard",
-            expectedContentType: "application/json",
-        });
-    }
-    /**
-     * Create dashboard from form
-     * Create a new dashboard based on an existing form
-     */
-    async createDashboardFromForm(params) {
-        return this.client.request({
-            method: "POST",
-            path: "/dashboards/copy-from/form",
-            headers: params.headers,
-            body: params.body,
-            opId: "createDashboardFromForm",
-            expectedContentType: "application/json",
-        });
-    }
-    /**
-     * Create dashboard from template
-     * Create a new dashboard based on an existing template
-     */
-    async createDashboardFromTemplate(params) {
-        return this.client.request({
-            method: "POST",
-            path: "/dashboards/copy-from/template",
-            headers: params.headers,
-            body: params.body,
-            opId: "createDashboardFromTemplate",
-            expectedContentType: "application/json",
-        });
-    }
-    /**
-     * Create dashboard via Intent
-     * Create a new dashboard using a simplified Intent payload.
-     * The Intent payload is enriched into a canonical full schema using allowed-items templates.
-     * Keys and aliases are auto-generated if not provided.
-     *
-     */
-    async createDashboardIntent(params) {
-        return this.client.request({
-            method: "POST",
-            path: "/dashboards/intent",
-            headers: params.headers,
-            body: params.body,
-            opId: "createDashboardIntent",
-            expectedContentType: "application/json",
-        });
-    }
-    /**
-     * Create dashboard view
-     * Create a new dashboard view
-     */
-    async createDashboardView(params) {
-        return this.client.request({
-            method: "POST",
-            path: "/dashboards/:dashboardId/views",
-            pathParams: params.path,
-            headers: params.headers,
-            body: params.body,
-            opId: "createDashboardView",
-            expectedContentType: "application/json",
-        });
-    }
-    /**
-     * Create a dashboard view representation template (system endpoint)
-     * Create a new dashboard view representation template with its scope.
-     * This is a system endpoint used for internal operations.
-     *
-     */
-    async createDashboardViewRepresentationTemplate(params) {
-        return this.client.request({
-            method: "POST",
-            path: "/_system/representation-templates",
-            headers: params.headers,
-            body: params.body,
-            opId: "createDashboardViewRepresentationTemplate",
-            expectedContentType: "application/json",
-        });
-    }
-    /**
-     * Create dashboard view via Intent
-     * Create a new dashboard view using a simplified Intent payload.
-     * Specify which columns from the dashboard schema to include in the view.
-     * Schema items must already exist in the dashboard before they can be included in a view.
-     * Does NOT modify the dashboard schema.
-     *
-     */
-    async createViewIntent(params) {
-        return this.client.request({
-            method: "POST",
-            path: "/dashboards/:dashboardId/views/intent",
-            pathParams: params.path,
-            headers: params.headers,
-            body: params.body,
-            opId: "createViewIntent",
-            expectedContentType: "application/json",
-        });
-    }
-    /**
-     * Delete dashboard by UUID
-     * Delete a dashboard (soft delete) by UUID
-     */
-    async deleteDashboard(params) {
-        return this.client.request({
-            method: "DELETE",
-            path: "/dashboards/:dashboardId",
-            pathParams: params.path,
-            headers: params.headers,
-            opId: "deleteDashboard",
-            expectedContentType: "application/json",
-        });
-    }
-    /**
-     * Permanently delete dashboard schema item
-     * Permanently delete a schema item from a dashboard and all views by its key by dashboard UUID
-     */
-    async deleteDashboardSchemaItem(params) {
-        return this.client.request({
-            method: "DELETE",
-            path: "/dashboards/:dashboardId/schema/items/:itemKey",
-            pathParams: params.path,
-            headers: params.headers,
-            opId: "deleteDashboardSchemaItem",
-            expectedContentType: "application/json",
-        });
-    }
-    /**
-     * Delete dashboard view
-     * Delete a dashboard view (soft delete)
-     */
-    async deleteDashboardView(params) {
-        return this.client.request({
-            method: "DELETE",
-            path: "/dashboards/:dashboardId/views/:viewId",
-            pathParams: params.path,
-            headers: params.headers,
-            opId: "deleteDashboardView",
-            expectedContentType: "application/json",
-        });
-    }
-    /**
-     * Describe dashboard by UUID
-     * Describe a specific dashboard by UUID
-     */
-    async describeDashboard(params) {
-        return this.client.request({
-            method: "GET",
-            path: "/dashboards/:dashboardId/describe",
-            pathParams: params.path,
-            headers: params.headers,
-            opId: "describeDashboard",
-            expectedContentType: "application/json",
-        });
-    }
-    /**
-     * Export dashboard data as CSV
-     * Export dashboard data as CSV format
-     */
-    async exportDashboardAsCsv(params) {
-        return this.client.request({
-            method: "GET",
-            path: "/dashboards/:dashboardId/export/csv",
-            pathParams: params.path,
-            query: params.query,
-            headers: params.headers,
-            opId: "exportDashboardAsCsv",
-            expectedContentType: "text/csv",
-        });
-    }
-    /**
-     * Export dashboard as JSON
-     * Export dashboard structure and optionally data as JSON
-     */
-    async exportDashboardAsJson(params) {
-        return this.client.request({
-            method: "GET",
-            path: "/dashboards/:dashboardId/views/:viewId/export/json",
-            pathParams: params.path,
-            query: params.query,
-            headers: params.headers,
-            opId: "exportDashboardAsJson",
-            expectedContentType: "application/json",
-        });
-    }
-    /**
-     * Get or create child table link dashboard
-     * Get or create dashboard for a child-table-link cell.
-     * If childTableId in cell is null, creates new dashboard using template from schema item.
-     * If childTableId exists, returns the existing dashboard.
-     * Automatically updates the cell with the created dashboard ID.
-     *
-     */
-    async getChildTableLinkDashboard(params) {
-        return this.client.request({
-            method: "POST",
-            path: "/dashboards/get-child-table-link-dashboard",
-            headers: params.headers,
-            body: params.body,
-            opId: "getChildTableLinkDashboard",
-            expectedContentType: "application/json",
-        });
-    }
-    /**
-     * Get dashboard
-     * Get a specific dashboard by UUID
-     */
-    async getDashboard(params) {
-        return this.client.request({
-            method: "GET",
-            path: "/dashboards/:dashboardId",
-            pathParams: params.path,
-            headers: params.headers,
-            opId: "getDashboard",
-            expectedContentType: "application/json",
-        });
-    }
-    /**
-     * Get available fields and related dashboards
-     * Returns the list of allowed SchemaItem fields for the specified dashboard, along with names and IDs of related dashboards.
-     */
-    async getDashboardAllowedItems(params) {
-        return this.client.request({
-            method: "GET",
-            path: "/dashboards/:dashboardId/allowed-items",
-            pathParams: params.path,
-            query: params.query,
-            headers: params.headers,
-            opId: "getDashboardAllowedItems",
-            expectedContentType: "application/json",
-        });
-    }
-    /**
-     * Get allowed fields by root entity without related dashboards
-     * Returns the list of allowed SchemaItem fields without related dashboards. Returns only common fields that are allowed to be used in the dashboard specified by the root entity.
-     */
-    async getDashboardAllowedItemsByRootEntity(params) {
-        return this.client.request({
-            method: "GET",
-            path: "/dashboards/allowed-items",
-            query: params.query,
-            headers: params.headers,
-            opId: "getDashboardAllowedItemsByRootEntity",
-            expectedContentType: "application/json",
-        });
-    }
-    /**
-     * Get fields types supported for CSV columns mapping
-     * Returns a list of SchemaItem fields that are supported for mapping to CSV columns
-     */
-    async getDashboardCsvImportAllowedItems(params) {
-        return this.client.request({
-            method: "GET",
-            path: "/dashboards/import/csv/allowed-items",
-            query: params.query,
-            headers: params.headers,
-            opId: "getDashboardCsvImportAllowedItems",
-            expectedContentType: "application/json",
-        });
-    }
-    /**
-     * List dashboards
-     * Get a list of dashboards with optional filtering
-     */
-    async getDashboards(params) {
-        return this.client.request({
-            method: "GET",
-            path: "/dashboards",
-            query: params.query,
-            headers: params.headers,
-            opId: "getDashboards",
-            expectedContentType: "application/json",
-        });
-    }
-    /**
-     * Get dashboard view
-     * Get a specific dashboard view by ID
-     */
-    async getDashboardView(params) {
-        return this.client.request({
-            method: "GET",
-            path: "/dashboards/:dashboardId/views/:viewId",
-            pathParams: params.path,
-            query: params.query,
-            headers: params.headers,
-            opId: "getDashboardView",
-            expectedContentType: "application/json",
-        });
-    }
-    /**
-     * Get dashboard view templates for an organization
-     * Fetch dashboard view templates for a specific organization.
-     * Returns all managed templates and custom templates that have the provided scope ID in their scopes.
-     *
-     */
-    async getDashboardViewRepresentationTemplates(params) {
-        return this.client.request({
-            method: "GET",
-            path: "/representation-templates",
-            query: params.query,
-            headers: params.headers,
-            opId: "getDashboardViewRepresentationTemplates",
-            expectedContentType: "application/json",
-        });
-    }
-    /**
-     * Get or create dashboard
-     * Find dashboard by alias and scope, or create new one if not found.
-     * If creating from template, searches for template in template_scope first,
-     * then org scope from scopes array, then system org (from SYSTEM_ORG_SCOPE_ID env var).
-     *
-     */
-    async getOrCreateDashboard(params) {
-        return this.client.request({
-            method: "POST",
-            path: "/dashboards/get-or-create",
-            query: params.query,
-            headers: params.headers,
-            body: params.body,
-            opId: "getOrCreateDashboard",
-            expectedContentType: "application/json",
-        });
-    }
-    /**
-     * Get a list of forms
-     * Get a list of forms for a given org
-     */
-    async getPortalFormsList(params) {
-        return this.client.request({
-            method: "GET",
-            path: "/dashboards/copy-from/form/list",
-            query: params.query,
-            headers: params.headers,
-            opId: "getPortalFormsList",
-            expectedContentType: "application/json",
-        });
-    }
-    /**
-     * Import dashboard from JSON
-     * Import a dashboard from exported JSON structure
-     */
-    async importDashboard(params) {
-        return this.client.request({
-            method: "POST",
-            path: "/dashboards/import",
-            headers: params.headers,
-            body: params.body,
-            opId: "importDashboard",
-            expectedContentType: "application/json",
-        });
-    }
-    /**
-     * Import dashboard data from CSV
-     * The mapping parameter uses OpenAPI's deepObject style with bracket notation
-     * for type-safe serialization in the generated client.
-     * Example query string:
-     * ?database_id=8b7c5d9d-f178-4b2a-99fb-bc3d5c363a6f&mapping[columns][0][index]=0&mapping[columns][0][type]=string&mapping[columns][0][edit_type]=string-single-line&mapping[columns][1][index]=1&mapping[columns][1][type]=number&mapping[columns][1][edit_type]=number
-     *
-     */
-    async importDashboardFromCsv(params) {
-        return this.client.request({
-            method: "POST",
-            path: "/dashboards/import/csv",
-            query: params.query,
-            headers: params.headers,
-            body: params.body,
-            opId: "importDashboardFromCsv",
-            expectedContentType: "application/json",
-        });
-    }
-    /**
-     * Update dashboard
-     * Update an existing dashboard by UUID
-     */
-    async updateDashboard(params) {
-        return this.client.request({
-            method: "PUT",
-            path: "/dashboards/:dashboardId",
-            pathParams: params.path,
-            headers: params.headers,
-            body: params.body,
-            opId: "updateDashboard",
-            expectedContentType: "application/json",
-        });
-    }
-    /**
-     * Update dashboard schema via Intent patch
-     * Update dashboard schema items using a simplified Intent patch payload.
-     * Supports add, update, and remove operations on schema items.
-     * Only specified items are modified; others remain unchanged.
-     * The Intent payload is enriched into canonical full schema items using allowed-items templates.
-     *
-     */
-    async updateDashboardSchemaIntent(params) {
-        return this.client.request({
-            method: "PATCH",
-            path: "/dashboards/:dashboardId/schema/intent",
-            pathParams: params.path,
-            headers: params.headers,
-            body: params.body,
-            opId: "updateDashboardSchemaIntent",
-            expectedContentType: "application/json",
-        });
-    }
-    /**
-     * Update dashboard view
-     * Update an existing dashboard view
-     */
-    async updateDashboardView(params) {
-        return this.client.request({
-            method: "PUT",
-            path: "/dashboards/:dashboardId/views/:viewId",
-            pathParams: params.path,
-            headers: params.headers,
-            body: params.body,
-            opId: "updateDashboardView",
-            expectedContentType: "application/json",
-        });
-    }
-    /**
-     * Update dashboard view filters
-     * Update only the filters configuration of a dashboard view
-     */
-    async updateDashboardViewFilters(params) {
-        return this.client.request({
-            method: "PUT",
-            path: "/dashboards/:dashboardId/views/:viewId/filters",
-            pathParams: params.path,
-            headers: params.headers,
-            body: params.body,
-            opId: "updateDashboardViewFilters",
-            expectedContentType: "application/json",
-        });
-    }
-    /**
-     * Update view schema via Intent patch
-     * Update view schema using the same Intent patch payload as dashboard schema updates.
-     * Supports add, update, and remove operations on schema items for this view.
-     * Uses UpdateSchemaIntentRequest (schema_patch) — same payload as PATCH /dashboards/{id}/schema/intent.
-     *
-     */
-    async updateViewIntent(params) {
-        return this.client.request({
-            method: "PUT",
-            path: "/dashboards/:dashboardId/views/:viewId/intent",
-            pathParams: params.path,
-            headers: params.headers,
-            body: params.body,
-            opId: "updateViewIntent",
-            expectedContentType: "application/json",
-        });
-    }
-}
-exports.DashboardsApi = DashboardsApi;

package/dist/apis/DatabasesApi.d.ts

@@ -1,134 +0,0 @@
-/**
- * Databases API
- *
- * Generated from contract introspection
- * Domain: databases
- */
-import type { Client } from "../runtime/transport";
-import type { aliasInQueryOptional, aliasInQueryRequired, CopyDatabaseFromDatabaseRequestContract, copyDataInQueryRequired, copyRelationsInQueryRequired, copyTablesInQueryRequired, copyViewsInQueryRequired, CreateDatabaseRequestContract, createDefaultRowsInQuery, DatabaseListResponseContract, DatabaseResponseContract, ExportDatabaseAsJson200ResponseContract, GetOrCreateDatabaseRequestContract, GetOrCreateDatabaseResponseContract, ImportDatabaseRequestContract, limitInQueryOptional, pageInQueryOptional, scopeIdInQueryRequired, scopeTypeOrgInQueryRequired, UpdateDatabaseRequestContract } from "../types";
-export declare class DatabasesApi {
-    private client;
-    constructor(client: Client);
-    /**
-     * Copy database from another database
-     * Create a new database by copying an existing database with all its dashboards, relations, and optionally data
-     */
-    copyDatabaseFromDatabase(params: {
-        query?: {
-            copy_tables: copyTablesInQueryRequired;
-            copy_views: copyViewsInQueryRequired;
-            copy_data: copyDataInQueryRequired;
-            copy_relations: copyRelationsInQueryRequired;
-            create_default_rows?: createDefaultRowsInQuery;
-        };
-        headers?: Record<string, string>;
-        body: CopyDatabaseFromDatabaseRequestContract;
-    }): Promise<DatabaseResponseContract>;
-    /**
-     * Create a new database
-     * Create a new database with the provided information
-     */
-    createDatabase(params: {
-        query?: {
-            no_default_dashboard?: boolean;
-        };
-        headers?: Record<string, string>;
-        body: CreateDatabaseRequestContract;
-    }): Promise<DatabaseResponseContract>;
-    /**
-     * Delete database
-     * Soft delete a database
-     */
-    deleteDatabase(params: {
-        path: {
-            id: string;
-        };
-        headers?: Record<string, string>;
-    }): Promise<void>;
-    /**
-     * Export database data as CSV
-     * Export database data as CSV format
-     */
-    exportDatabaseAsCsv(params: {
-        path: {
-            id: string;
-        };
-        headers?: Record<string, string>;
-    }): Promise<string>;
-    /**
-     * Export database as JSON
-     * Export database structure and optionally data as JSON
-     */
-    exportDatabaseAsJson(params: {
-        path: {
-            id: string;
-        };
-        query?: {
-            structure?: boolean;
-            data?: boolean;
-        };
-        headers?: Record<string, string>;
-    }): Promise<ExportDatabaseAsJson200ResponseContract>;
-    /**
-     * Get all databases
-     * Retrieve a list of all databases
-     */
-    getAllDatabases(params: {
-        query?: {
-            include_expanded?: boolean;
-            sort_by?: string;
-            sort_order?: string;
-            alias?: aliasInQueryOptional;
-            scope_type: scopeTypeOrgInQueryRequired;
-            scope_id: scopeIdInQueryRequired;
-            page?: pageInQueryOptional;
-            limit?: limitInQueryOptional;
-        };
-        headers?: Record<string, string>;
-    }): Promise<DatabaseListResponseContract>;
-    /**
-     * Get database by ID
-     * Retrieve a specific database by its global ID
-     */
-    getDatabaseById(params: {
-        path: {
-            id: string;
-        };
-        headers?: Record<string, string>;
-    }): Promise<DatabaseResponseContract>;
-    /**
-     * Get or create database
-     * Find database by alias and scope, or create new one if not found.
-     * If creating from template, searches for template in template_scope first,
-     * then org scope from scopes array, then system org (from SYSTEM_ORG_SCOPE_ID env var).
-     *
-     */
-    getOrCreateDatabase(params: {
-        query?: {
-            alias: aliasInQueryRequired;
-            scope_type: scopeTypeOrgInQueryRequired;
-            scope_id: scopeIdInQueryRequired;
-        };
-        headers?: Record<string, string>;
-        body: GetOrCreateDatabaseRequestContract;
-    }): Promise<GetOrCreateDatabaseResponseContract>;
-    /**
-     * Import database from JSON
-     * Import a database from exported JSON structure
-     */
-    importDatabase(params: {
-        headers?: Record<string, string>;
-        body: ImportDatabaseRequestContract;
-    }): Promise<DatabaseResponseContract>;
-    /**
-     * Update database
-     * Update an existing database
-     */
-    updateDatabase(params: {
-        path: {
-            id: string;
-        };
-        headers?: Record<string, string>;
-        body: UpdateDatabaseRequestContract;
-    }): Promise<DatabaseResponseContract>;
-}