@fusebase/dashboard-service-sdk 1.23.3-client.10

package/README.md

@@ -0,0 +1,52 @@
+# Dashboard Service SDK
+
+TypeScript SDK for Dashboard Service API - Generated from contract introspection.
+
+## Installation
+
+```bash
+npm install @fusebase/dashboard-service-sdk
+```
+
+## Usage
+
+```typescript
+import { createClient, TokensApi, DashboardsApi } from "@fusebase/dashboard-service-sdk";
+
+// Create client
+const client = createClient({
+  baseUrl: "https://api.example.com",
+  auth: {
+    type: "bearer",
+    token: "your-token-here",
+  },
+});
+
+// Use API classes
+const tokensApi = new TokensApi(client);
+const dashboardsApi = new DashboardsApi(client);
+
+// Call methods
+const token = await tokensApi.createToken({
+  body: {
+    scopes: [{ type: "org", id: "org-id" }],
+    permissions: ["dashboard.read"],
+  },
+});
+```
+
+## API Classes
+
+- `TokensApi` - Token management
+- `DashboardsApi` - Dashboard operations
+- `DatabasesApi` - Database operations
+- `TemplatesApi` - Template operations
+- And more...
+
+## Types
+
+All TypeScript types are exported from the package:
+
+```typescript
+import type { CreateTokenRequestContract, TokenResponseContract } from "@fusebase/dashboard-service-sdk";
+```

package/dist/apis/CustomDashboardRowsApi.d.ts

@@ -0,0 +1,113 @@
+/**
+ * CustomDashboardRows API
+ *
+ * Generated from contract introspection
+ * Domain: custom dashboard rows
+ */
+import type { Client } from "../runtime/transport";
+import type { CreateDashboardRowRequestContract, DashboardRowResponseContract, sectionKeyInQueryRequired, sectionTypeInQueryRequired, StandardApiResponseContract, UpdateRowOrderRequestContract, viewIdInQueryRequired } from "../types";
+export declare class CustomDashboardRowsApi {
+    private client;
+    constructor(client: Client);
+    /**
+     * Create custom dashboard rows
+     * Create a new custom dashboard rows
+     */
+    createDashboardRow(params: {
+        path: {
+            dashboardId: string;
+        };
+        headers?: Record<string, string>;
+        body: CreateDashboardRowRequestContract;
+    }): Promise<DashboardRowResponseContract>;
+    /**
+     * Delete custom dashboard row
+     * Delete a dashboard row by UUID
+     */
+    deleteDashboardRow(params: {
+        path: {
+            dashboardId: string;
+            rowUuid: string;
+        };
+        query?: {
+            force_associated_data_deletion?: boolean;
+        };
+        headers?: Record<string, string>;
+    }): Promise<StandardApiResponseContract>;
+    /**
+     * Initialize default row order for dashboard view, section, or item
+     * Create default row orders based on creation time. Requires section_type (view, section, or item), section_key, and section_value.
+     * For view: section_key=view, section_value=view_id.
+     * For section: section_key=section, section_value=section_uuid.
+     * For item: section_key=item_key, section_value=normalized_value.
+     * Only works if no orders exist.
+     *
+     */
+    initializeDashboardRowOrder(params: {
+        path: {
+            dashboardId: string;
+        };
+        query?: {
+            view_id: viewIdInQueryRequired;
+            section_type: sectionTypeInQueryRequired;
+            section_key: sectionKeyInQueryRequired;
+        };
+        headers?: Record<string, string>;
+    }): Promise<StandardApiResponseContract>;
+    /**
+     * List custom dashboard rows
+     * Get a list of existing row UUIDs for a custom dashboard. Returns all rows when no pagination parameters are provided.
+     */
+    listDashboardRows(params: {
+        path: {
+            dashboardId: string;
+        };
+        query?: {
+            start_from?: number;
+            limit?: number;
+        };
+        headers?: Record<string, string>;
+    }): Promise<DashboardRowResponseContract>;
+    /**
+     * Save current sorting order to permanent row order
+     * Saves the current dynamic sorting order (from field-based sorting) to permanent row order.
+     * Requires section_type (view, section, or item), section_key, and section_value.
+     * For view: section_key=view, section_value=view_id.
+     * For section: section_key=section, section_value=section_uuid.
+     * For item: section_key=item_key, section_value=normalized_value.
+     * Only available for dashboards with entity type "custom".
+     *
+     */
+    saveDashboardRowOrder(params: {
+        path: {
+            dashboardId: string;
+        };
+        query?: {
+            view_id: viewIdInQueryRequired;
+            section_type: sectionTypeInQueryRequired;
+            section_key: sectionKeyInQueryRequired;
+        };
+        headers?: Record<string, string>;
+    }): Promise<StandardApiResponseContract>;
+    /**
+     * Update row order for dashboard view, section, or item
+     * Update the sort order of rows. Requires section_type (view, section, or item), section_key, and section_value.
+     * For view: section_key=view, section_value=view_id.
+     * For section: section_key=section, section_value=section_uuid.
+     * For item: section_key=item_key, section_value=normalized_value.
+     * Implements lazy loading - creates default orders if none exist.
+     *
+     */
+    updateDashboardRowOrder(params: {
+        path: {
+            dashboardId: string;
+        };
+        query?: {
+            view_id: viewIdInQueryRequired;
+            section_type: sectionTypeInQueryRequired;
+            section_key: sectionKeyInQueryRequired;
+        };
+        headers?: Record<string, string>;
+        body: UpdateRowOrderRequestContract;
+    }): Promise<StandardApiResponseContract>;
+}

package/dist/apis/CustomDashboardRowsApi.js

@@ -0,0 +1,122 @@
+"use strict";
+/**
+ * CustomDashboardRows API
+ *
+ * Generated from contract introspection
+ * Domain: custom dashboard rows
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomDashboardRowsApi = void 0;
+class CustomDashboardRowsApi {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Create custom dashboard rows
+     * Create a new custom dashboard rows
+     */
+    async createDashboardRow(params) {
+        return this.client.request({
+            method: "POST",
+            path: "/dashboards/:dashboardId/rows",
+            pathParams: params.path,
+            headers: params.headers,
+            body: params.body,
+            opId: "createDashboardRow",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Delete custom dashboard row
+     * Delete a dashboard row by UUID
+     */
+    async deleteDashboardRow(params) {
+        return this.client.request({
+            method: "DELETE",
+            path: "/dashboards/:dashboardId/rows/:rowUuid",
+            pathParams: params.path,
+            query: params.query,
+            headers: params.headers,
+            opId: "deleteDashboardRow",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Initialize default row order for dashboard view, section, or item
+     * Create default row orders based on creation time. Requires section_type (view, section, or item), section_key, and section_value.
+     * For view: section_key=view, section_value=view_id.
+     * For section: section_key=section, section_value=section_uuid.
+     * For item: section_key=item_key, section_value=normalized_value.
+     * Only works if no orders exist.
+     *
+     */
+    async initializeDashboardRowOrder(params) {
+        return this.client.request({
+            method: "POST",
+            path: "/dashboards/:dashboardId/rows/order/initialize",
+            pathParams: params.path,
+            query: params.query,
+            headers: params.headers,
+            opId: "initializeDashboardRowOrder",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * List custom dashboard rows
+     * Get a list of existing row UUIDs for a custom dashboard. Returns all rows when no pagination parameters are provided.
+     */
+    async listDashboardRows(params) {
+        return this.client.request({
+            method: "GET",
+            path: "/dashboards/:dashboardId/rows",
+            pathParams: params.path,
+            query: params.query,
+            headers: params.headers,
+            opId: "listDashboardRows",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Save current sorting order to permanent row order
+     * Saves the current dynamic sorting order (from field-based sorting) to permanent row order.
+     * Requires section_type (view, section, or item), section_key, and section_value.
+     * For view: section_key=view, section_value=view_id.
+     * For section: section_key=section, section_value=section_uuid.
+     * For item: section_key=item_key, section_value=normalized_value.
+     * Only available for dashboards with entity type "custom".
+     *
+     */
+    async saveDashboardRowOrder(params) {
+        return this.client.request({
+            method: "POST",
+            path: "/dashboards/:dashboardId/rows/order/save",
+            pathParams: params.path,
+            query: params.query,
+            headers: params.headers,
+            opId: "saveDashboardRowOrder",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Update row order for dashboard view, section, or item
+     * Update the sort order of rows. Requires section_type (view, section, or item), section_key, and section_value.
+     * For view: section_key=view, section_value=view_id.
+     * For section: section_key=section, section_value=section_uuid.
+     * For item: section_key=item_key, section_value=normalized_value.
+     * Implements lazy loading - creates default orders if none exist.
+     *
+     */
+    async updateDashboardRowOrder(params) {
+        return this.client.request({
+            method: "PUT",
+            path: "/dashboards/:dashboardId/rows/order",
+            pathParams: params.path,
+            query: params.query,
+            headers: params.headers,
+            body: params.body,
+            opId: "updateDashboardRowOrder",
+            expectedContentType: "application/json",
+        });
+    }
+}
+exports.CustomDashboardRowsApi = CustomDashboardRowsApi;

package/dist/apis/DashboardDataApi.d.ts

@@ -0,0 +1,98 @@
+/**
+ * DashboardData API
+ *
+ * Generated from contract introspection
+ * Domain: dashboard data
+ */
+import type { Client } from "../runtime/transport";
+import type { BatchDashboardValueResponseContract, BatchUpdateDashboardDataRequestContract, cacheStrategyInQueryOptional, DashboardDataResponseContract, dashboardIdInPathRequired, DashboardValueResponseContract, ReindexDashboardData200ResponseContract, sectionKeyInQueryOptional, sectionTypeInQueryOptional, sourceDashboardIdInQueryRequired, sourceIndexInQueryRequired, UpdateDashboardDataRequestContract, viewIdInPathRequired } from "../types";
+export declare class DashboardDataApi {
+    private client;
+    constructor(client: Client);
+    /**
+     * Batch update dashboard values
+     * Update or create multiple dashboard values in a single request
+     */
+    batchPutDashboardData(params: {
+        path: {
+            dashboardId: dashboardIdInPathRequired;
+            viewId: viewIdInPathRequired;
+        };
+        query?: {
+            validate?: boolean;
+        };
+        headers?: Record<string, string>;
+        body: BatchUpdateDashboardDataRequestContract;
+    }): Promise<BatchDashboardValueResponseContract>;
+    /**
+     * Get dashboard view data
+     * Get dashboard view data for a specific view
+     */
+    getDashboardViewData(params: {
+        path: {
+            dashboardId: dashboardIdInPathRequired;
+            viewId: viewIdInPathRequired;
+        };
+        query?: {
+            filters?: string;
+            select?: string;
+            sort?: string;
+            page?: number;
+            limit?: number;
+            exclude_async_items?: boolean;
+            item_keys?: unknown[];
+            system_filters?: boolean;
+            use_stored_filters?: boolean;
+            use_stored_sort?: boolean;
+            root_index_values?: unknown[];
+            cacheStrategy?: cacheStrategyInQueryOptional;
+            section_type?: sectionTypeInQueryOptional;
+            section_key?: sectionKeyInQueryOptional;
+        };
+        headers?: Record<string, string>;
+    }): Promise<DashboardDataResponseContract>;
+    /**
+     * Get related dashboard data
+     * Get dashboard data for rows related through dashboard relations
+     */
+    getRelatedDashboardData(params: {
+        path: {
+            dashboardId: dashboardIdInPathRequired;
+        };
+        query?: {
+            page?: number;
+            limit?: number;
+            exclude_async_items?: boolean;
+            item_keys?: unknown[];
+            source_dashboard_id: sourceDashboardIdInQueryRequired;
+            source_index: sourceIndexInQueryRequired;
+            cacheStrategy?: cacheStrategyInQueryOptional;
+        };
+        headers?: Record<string, string>;
+    }): Promise<DashboardDataResponseContract>;
+    /**
+     * Update dashboard value
+     * Update or create a dashboard value for a specific root index key and value
+     */
+    putDashboardData(params: {
+        path: {
+            dashboardId: dashboardIdInPathRequired;
+            viewId: viewIdInPathRequired;
+        };
+        query?: {
+            validate?: boolean;
+        };
+        headers?: Record<string, string>;
+        body: UpdateDashboardDataRequestContract;
+    }): Promise<DashboardValueResponseContract>;
+    /**
+     * Reindex dashboard cache
+     * Force reindexing of dashboard data in Redis cache
+     */
+    reindexDashboardData(params: {
+        path: {
+            dashboardId: dashboardIdInPathRequired;
+        };
+        headers?: Record<string, string>;
+    }): Promise<ReindexDashboardData200ResponseContract>;
+}

package/dist/apis/DashboardDataApi.js

@@ -0,0 +1,91 @@
+"use strict";
+/**
+ * DashboardData API
+ *
+ * Generated from contract introspection
+ * Domain: dashboard data
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DashboardDataApi = void 0;
+class DashboardDataApi {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Batch update dashboard values
+     * Update or create multiple dashboard values in a single request
+     */
+    async batchPutDashboardData(params) {
+        return this.client.request({
+            method: "PUT",
+            path: "/dashboards/:dashboardId/views/:viewId/data/batch",
+            pathParams: params.path,
+            query: params.query,
+            headers: params.headers,
+            body: params.body,
+            opId: "batchPutDashboardData",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Get dashboard view data
+     * Get dashboard view data for a specific view
+     */
+    async getDashboardViewData(params) {
+        return this.client.request({
+            method: "GET",
+            path: "/dashboards/:dashboardId/views/:viewId/data",
+            pathParams: params.path,
+            query: params.query,
+            headers: params.headers,
+            opId: "getDashboardViewData",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Get related dashboard data
+     * Get dashboard data for rows related through dashboard relations
+     */
+    async getRelatedDashboardData(params) {
+        return this.client.request({
+            method: "GET",
+            path: "/dashboards/:dashboardId/related-data",
+            pathParams: params.path,
+            query: params.query,
+            headers: params.headers,
+            opId: "getRelatedDashboardData",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Update dashboard value
+     * Update or create a dashboard value for a specific root index key and value
+     */
+    async putDashboardData(params) {
+        return this.client.request({
+            method: "PUT",
+            path: "/dashboards/:dashboardId/views/:viewId/data",
+            pathParams: params.path,
+            query: params.query,
+            headers: params.headers,
+            body: params.body,
+            opId: "putDashboardData",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Reindex dashboard cache
+     * Force reindexing of dashboard data in Redis cache
+     */
+    async reindexDashboardData(params) {
+        return this.client.request({
+            method: "POST",
+            path: "/dashboards/:dashboardId/reindex",
+            pathParams: params.path,
+            headers: params.headers,
+            opId: "reindexDashboardData",
+            expectedContentType: "application/json",
+        });
+    }
+}
+exports.DashboardDataApi = DashboardDataApi;

package/dist/apis/DashboardRelationsApi.d.ts

@@ -0,0 +1,92 @@
+/**
+ * DashboardRelations API
+ *
+ * Generated from contract introspection
+ * Domain: dashboard relations
+ */
+import type { Client } from "../runtime/transport";
+import type { AddRelationRowsRequestContract, CreateDashboardRelationRequestContract, DashboardRelationListResponseContract, DashboardRelationResponseContract, includeRows, relationId, StandardApiResponseContract, targetDashboardIdInQueryRequired, UpdateRelationRowsRequestContract } from "../types";
+export declare class DashboardRelationsApi {
+    private client;
+    constructor(client: Client);
+    /**
+     * Add relation rows
+     * Add row mappings to an existing relation
+     */
+    addRelationRows(params: {
+        path: {
+            relationId: relationId;
+        };
+        headers?: Record<string, string>;
+        body: AddRelationRowsRequestContract;
+    }): Promise<DashboardRelationResponseContract>;
+    /**
+     * Create dashboard relation
+     * Create a new relation between two dashboards
+     */
+    createDashboardRelation(params: {
+        headers?: Record<string, string>;
+        body: CreateDashboardRelationRequestContract;
+    }): Promise<DashboardRelationResponseContract>;
+    /**
+     * Delete dashboard relation
+     * Delete a dashboard relation and all its row mappings (soft delete)
+     */
+    deleteDashboardRelation(params: {
+        path: {
+            relationId: relationId;
+        };
+        headers?: Record<string, string>;
+    }): Promise<StandardApiResponseContract>;
+    /**
+     * Delete relation rows
+     * Remove specific row mappings from a relation
+     */
+    deleteRelationRows(params: {
+        path: {
+            relationId: relationId;
+        };
+        query?: {
+            source_index?: string;
+            target_index?: string;
+        };
+        headers?: Record<string, string>;
+    }): Promise<StandardApiResponseContract>;
+    /**
+     * Find relations
+     * Find relations by source and target dashboard IDs
+     */
+    findRelationsByDashboardIds(params: {
+        query?: {
+            source_dashboard_id?: string;
+            inversive_search?: boolean;
+            include_rows?: boolean;
+            target_dashboard_id: targetDashboardIdInQueryRequired;
+        };
+        headers?: Record<string, string>;
+    }): Promise<DashboardRelationListResponseContract>;
+    /**
+     * Get dashboard relation
+     * Get a specific dashboard relation by ID
+     */
+    getDashboardRelationById(params: {
+        path: {
+            relationId: relationId;
+        };
+        query?: {
+            include_rows?: includeRows;
+        };
+        headers?: Record<string, string>;
+    }): Promise<DashboardRelationResponseContract>;
+    /**
+     * Update relation rows
+     * Replace all row mappings for a relation
+     */
+    updateRelationRows(params: {
+        path: {
+            relationId: relationId;
+        };
+        headers?: Record<string, string>;
+        body: UpdateRelationRowsRequestContract;
+    }): Promise<DashboardRelationResponseContract>;
+}

package/dist/apis/DashboardRelationsApi.js

@@ -0,0 +1,117 @@
+"use strict";
+/**
+ * DashboardRelations API
+ *
+ * Generated from contract introspection
+ * Domain: dashboard relations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DashboardRelationsApi = void 0;
+class DashboardRelationsApi {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Add relation rows
+     * Add row mappings to an existing relation
+     */
+    async addRelationRows(params) {
+        return this.client.request({
+            method: "POST",
+            path: "/relations/:relationId/rows",
+            pathParams: params.path,
+            headers: params.headers,
+            body: params.body,
+            opId: "addRelationRows",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Create dashboard relation
+     * Create a new relation between two dashboards
+     */
+    async createDashboardRelation(params) {
+        return this.client.request({
+            method: "POST",
+            path: "/relations",
+            headers: params.headers,
+            body: params.body,
+            opId: "createDashboardRelation",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Delete dashboard relation
+     * Delete a dashboard relation and all its row mappings (soft delete)
+     */
+    async deleteDashboardRelation(params) {
+        return this.client.request({
+            method: "DELETE",
+            path: "/relations/:relationId",
+            pathParams: params.path,
+            headers: params.headers,
+            opId: "deleteDashboardRelation",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Delete relation rows
+     * Remove specific row mappings from a relation
+     */
+    async deleteRelationRows(params) {
+        return this.client.request({
+            method: "DELETE",
+            path: "/relations/:relationId/rows",
+            pathParams: params.path,
+            query: params.query,
+            headers: params.headers,
+            opId: "deleteRelationRows",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Find relations
+     * Find relations by source and target dashboard IDs
+     */
+    async findRelationsByDashboardIds(params) {
+        return this.client.request({
+            method: "GET",
+            path: "/relations",
+            query: params.query,
+            headers: params.headers,
+            opId: "findRelationsByDashboardIds",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Get dashboard relation
+     * Get a specific dashboard relation by ID
+     */
+    async getDashboardRelationById(params) {
+        return this.client.request({
+            method: "GET",
+            path: "/relations/:relationId",
+            pathParams: params.path,
+            query: params.query,
+            headers: params.headers,
+            opId: "getDashboardRelationById",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Update relation rows
+     * Replace all row mappings for a relation
+     */
+    async updateRelationRows(params) {
+        return this.client.request({
+            method: "PUT",
+            path: "/relations/:relationId/rows",
+            pathParams: params.path,
+            headers: params.headers,
+            body: params.body,
+            opId: "updateRelationRows",
+            expectedContentType: "application/json",
+        });
+    }
+}
+exports.DashboardRelationsApi = DashboardRelationsApi;