@fusebase/fusebase-gate-sdk 1.0.2-sdk.0

package/dist/apis/DatabasesApi.js

@@ -0,0 +1,162 @@
+"use strict";
+/**
+ * Databases API
+ *
+ * Generated from contract introspection
+ * Domain: databases
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabasesApi = void 0;
+class DatabasesApi {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Copy database from another database
+     * Create a new database by copying an existing database with all its dashboards, relations, and optionally data
+     */
+    async copyDatabaseFromDatabase(params) {
+        return this.client.request({
+            method: "POST",
+            path: "/databases/copy-from/database",
+            query: params.query,
+            headers: params.headers,
+            body: params.body,
+            opId: "copyDatabaseFromDatabase",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Create a new database
+     * Create a new database with the provided information
+     */
+    async createDatabase(params) {
+        return this.client.request({
+            method: "POST",
+            path: "/databases",
+            query: params.query,
+            headers: params.headers,
+            body: params.body,
+            opId: "createDatabase",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Delete database
+     * Soft delete a database
+     */
+    async deleteDatabase(params) {
+        return this.client.request({
+            method: "DELETE",
+            path: "/databases/:id",
+            pathParams: params.path,
+            headers: params.headers,
+            opId: "deleteDatabase",
+        });
+    }
+    /**
+     * Export database data as CSV
+     * Export database data as CSV format
+     */
+    async exportDatabaseAsCsv(params) {
+        return this.client.request({
+            method: "GET",
+            path: "/databases/:id/export/csv",
+            pathParams: params.path,
+            headers: params.headers,
+            opId: "exportDatabaseAsCsv",
+            expectedContentType: "text/csv",
+        });
+    }
+    /**
+     * Export database as JSON
+     * Export database structure and optionally data as JSON
+     */
+    async exportDatabaseAsJson(params) {
+        return this.client.request({
+            method: "GET",
+            path: "/databases/:id/export/json",
+            pathParams: params.path,
+            query: params.query,
+            headers: params.headers,
+            opId: "exportDatabaseAsJson",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Get all databases
+     * Retrieve a list of all databases
+     */
+    async getAllDatabases(params) {
+        return this.client.request({
+            method: "GET",
+            path: "/databases",
+            query: params.query,
+            headers: params.headers,
+            opId: "getAllDatabases",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Get database by ID
+     * Retrieve a specific database by its global ID
+     */
+    async getDatabaseById(params) {
+        return this.client.request({
+            method: "GET",
+            path: "/databases/:id",
+            pathParams: params.path,
+            headers: params.headers,
+            opId: "getDatabaseById",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * 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).
+     *
+     */
+    async getOrCreateDatabase(params) {
+        return this.client.request({
+            method: "POST",
+            path: "/databases/get-or-create",
+            query: params.query,
+            headers: params.headers,
+            body: params.body,
+            opId: "getOrCreateDatabase",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Import database from JSON
+     * Import a database from exported JSON structure
+     */
+    async importDatabase(params) {
+        return this.client.request({
+            method: "POST",
+            path: "/databases/import",
+            headers: params.headers,
+            body: params.body,
+            opId: "importDatabase",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Update database
+     * Update an existing database
+     */
+    async updateDatabase(params) {
+        return this.client.request({
+            method: "PUT",
+            path: "/databases/:id",
+            pathParams: params.path,
+            headers: params.headers,
+            body: params.body,
+            opId: "updateDatabase",
+            expectedContentType: "application/json",
+        });
+    }
+}
+exports.DatabasesApi = DatabasesApi;

package/dist/apis/HealthApi.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Health API
+ *
+ * Generated from contract introspection
+ * Domain: health
+ */
+import type { Client } from "../runtime/transport";
+import type { GetHealth200ResponseContract } from "../types";
+export declare class HealthApi {
+    private client;
+    constructor(client: Client);
+    /**
+     * Basic health check
+     * Returns a simple health status
+     */
+    getHealth(params: {
+        headers?: Record<string, string>;
+    }): Promise<GetHealth200ResponseContract>;
+}

package/dist/apis/HealthApi.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * Health API
+ *
+ * Generated from contract introspection
+ * Domain: health
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HealthApi = void 0;
+class HealthApi {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Basic health check
+     * Returns a simple health status
+     */
+    async getHealth(params) {
+        return this.client.request({
+            method: "GET",
+            path: "/health",
+            headers: params.headers,
+            opId: "getHealth",
+            expectedContentType: "application/json",
+        });
+    }
+}
+exports.HealthApi = HealthApi;

package/dist/apis/OrgUsersApi.d.ts

@@ -0,0 +1,22 @@
+/**
+ * OrgUsers API
+ *
+ * Generated from contract introspection
+ * Domain: org-users
+ */
+import type { Client } from "../runtime/transport";
+import type { orgIdInPathRequired, OrgUserListResponseContract } from "../types";
+export declare class OrgUsersApi {
+    private client;
+    constructor(client: Client);
+    /**
+     * List organization users
+     * Returns the list of users (members) of the organization. Requires org.members.read and org access.
+     */
+    listOrgUsers(params: {
+        path: {
+            orgId: orgIdInPathRequired;
+        };
+        headers?: Record<string, string>;
+    }): Promise<OrgUserListResponseContract>;
+}

package/dist/apis/OrgUsersApi.js

@@ -0,0 +1,29 @@
+"use strict";
+/**
+ * OrgUsers API
+ *
+ * Generated from contract introspection
+ * Domain: org-users
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrgUsersApi = void 0;
+class OrgUsersApi {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * List organization users
+     * Returns the list of users (members) of the organization. Requires org.members.read and org access.
+     */
+    async listOrgUsers(params) {
+        return this.client.request({
+            method: "GET",
+            path: "/:orgId/users",
+            pathParams: params.path,
+            headers: params.headers,
+            opId: "listOrgUsers",
+            expectedContentType: "application/json",
+        });
+    }
+}
+exports.OrgUsersApi = OrgUsersApi;

package/dist/apis/ResolveApi.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Resolve API
+ *
+ * Generated from contract introspection
+ * Domain: resolve
+ */
+import type { Client } from "../runtime/transport";
+import type { ResolveAliasesRequestContract, ResolveAliasesResponseContract } from "../types";
+export declare class ResolveApi {
+    private client;
+    constructor(client: Client);
+    /**
+     * Resolve aliases
+     * Resolve database, dashboard, and view by alias or id within the given organization scope. Returns for each item the resolved id and alias, or resolved: false with error_code. Dashboard requires database; view requires dashboard and database. Request-level cache avoids duplicate DB lookups for repeated parent refs.
+     */
+    resolveAliases(params: {
+        headers?: Record<string, string>;
+        body: ResolveAliasesRequestContract;
+    }): Promise<ResolveAliasesResponseContract>;
+}

package/dist/apis/ResolveApi.js

@@ -0,0 +1,29 @@
+"use strict";
+/**
+ * Resolve API
+ *
+ * Generated from contract introspection
+ * Domain: resolve
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResolveApi = void 0;
+class ResolveApi {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Resolve aliases
+     * Resolve database, dashboard, and view by alias or id within the given organization scope. Returns for each item the resolved id and alias, or resolved: false with error_code. Dashboard requires database; view requires dashboard and database. Request-level cache avoids duplicate DB lookups for repeated parent refs.
+     */
+    async resolveAliases(params) {
+        return this.client.request({
+            method: "POST",
+            path: "/resolve/aliases",
+            headers: params.headers,
+            body: params.body,
+            opId: "resolveAliases",
+            expectedContentType: "application/json",
+        });
+    }
+}
+exports.ResolveApi = ResolveApi;

package/dist/apis/TemplatesApi.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Templates API
+ *
+ * Generated from contract introspection
+ * Domain: templates
+ */
+import type { Client } from "../runtime/transport";
+import type { AliasContract, aliasInQueryOptional, CreateTemplateRequestContract, DashboardListResponseContract, DatabaseListResponseContract, limitInQueryOptional, nameInQueryOptional, pageInQueryOptional, rootEntityInQueryOptional, StandardApiResponseContract, templateIdInPathRequired, TemplateListResponseContract, TemplateResponseContract, UpdateTemplateRequestContract } from "../types";
+export declare class TemplatesApi {
+    private client;
+    constructor(client: Client);
+    /**
+     * Create template
+     * Create a new dashboard template
+     */
+    createTemplate(params: {
+        query?: {
+            replace_existing?: boolean;
+        };
+        headers?: Record<string, string>;
+        body: CreateTemplateRequestContract;
+    }): Promise<TemplateResponseContract>;
+    /**
+     * Delete template
+     * Delete a template (soft delete)
+     */
+    deleteTemplate(params: {
+        path: {
+            template_id: templateIdInPathRequired;
+        };
+        headers?: Record<string, string>;
+    }): Promise<StandardApiResponseContract>;
+    /**
+     * Get template
+     * Get a specific template by ID
+     */
+    getTemplate(params: {
+        path: {
+            template_id: templateIdInPathRequired;
+        };
+        headers?: Record<string, string>;
+    }): Promise<TemplateResponseContract>;
+    /**
+     * List templates
+     * Get a list of dashboard templates with optional filtering
+     */
+    getTemplates(params: {
+        query?: {
+            root_entity?: rootEntityInQueryOptional;
+            name?: nameInQueryOptional;
+            page?: pageInQueryOptional;
+            limit?: limitInQueryOptional;
+        };
+        headers?: Record<string, string>;
+    }): Promise<TemplateListResponseContract>;
+    /**
+     * Search template dashboards
+     * Search for dashboards in the template org scope (TEMPLATE_ORG_SCOPE_ID).
+     * Template dashboards are dashboards that are stored in the template org scope
+     * and can be used as templates for creating new dashboards.
+     *
+     * If database_id or database_alias are not provided, only dashboards with database_id = null
+     * (standalone template dashboards) are returned.
+     *
+     */
+    searchTemplateDashboards(params: {
+        query?: {
+            dashboard_id?: string;
+            database_id?: string;
+            database_alias?: AliasContract;
+            alias?: aliasInQueryOptional;
+        };
+        headers?: Record<string, string>;
+    }): Promise<DashboardListResponseContract>;
+    /**
+     * Search template databases
+     * Search for databases in the template org scope (TEMPLATE_ORG_SCOPE_ID).
+     * Template databases are databases that are stored in the template org scope
+     * and can be used as templates for creating new databases.
+     *
+     */
+    searchTemplateDatabases(params: {
+        query?: {
+            database_id?: string;
+            alias?: aliasInQueryOptional;
+        };
+        headers?: Record<string, string>;
+    }): Promise<DatabaseListResponseContract>;
+    /**
+     * Update template
+     * Update an existing template
+     */
+    updateTemplate(params: {
+        path: {
+            template_id: templateIdInPathRequired;
+        };
+        headers?: Record<string, string>;
+        body: UpdateTemplateRequestContract;
+    }): Promise<TemplateResponseContract>;
+}

package/dist/apis/TemplatesApi.js

@@ -0,0 +1,124 @@
+"use strict";
+/**
+ * Templates API
+ *
+ * Generated from contract introspection
+ * Domain: templates
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplatesApi = void 0;
+class TemplatesApi {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Create template
+     * Create a new dashboard template
+     */
+    async createTemplate(params) {
+        return this.client.request({
+            method: "POST",
+            path: "/templates",
+            query: params.query,
+            headers: params.headers,
+            body: params.body,
+            opId: "createTemplate",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Delete template
+     * Delete a template (soft delete)
+     */
+    async deleteTemplate(params) {
+        return this.client.request({
+            method: "DELETE",
+            path: "/templates/:template_id",
+            pathParams: params.path,
+            headers: params.headers,
+            opId: "deleteTemplate",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Get template
+     * Get a specific template by ID
+     */
+    async getTemplate(params) {
+        return this.client.request({
+            method: "GET",
+            path: "/templates/:template_id",
+            pathParams: params.path,
+            headers: params.headers,
+            opId: "getTemplate",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * List templates
+     * Get a list of dashboard templates with optional filtering
+     */
+    async getTemplates(params) {
+        return this.client.request({
+            method: "GET",
+            path: "/templates",
+            query: params.query,
+            headers: params.headers,
+            opId: "getTemplates",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Search template dashboards
+     * Search for dashboards in the template org scope (TEMPLATE_ORG_SCOPE_ID).
+     * Template dashboards are dashboards that are stored in the template org scope
+     * and can be used as templates for creating new dashboards.
+     *
+     * If database_id or database_alias are not provided, only dashboards with database_id = null
+     * (standalone template dashboards) are returned.
+     *
+     */
+    async searchTemplateDashboards(params) {
+        return this.client.request({
+            method: "GET",
+            path: "/templates/dashboards",
+            query: params.query,
+            headers: params.headers,
+            opId: "searchTemplateDashboards",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Search template databases
+     * Search for databases in the template org scope (TEMPLATE_ORG_SCOPE_ID).
+     * Template databases are databases that are stored in the template org scope
+     * and can be used as templates for creating new databases.
+     *
+     */
+    async searchTemplateDatabases(params) {
+        return this.client.request({
+            method: "GET",
+            path: "/templates/databases",
+            query: params.query,
+            headers: params.headers,
+            opId: "searchTemplateDatabases",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Update template
+     * Update an existing template
+     */
+    async updateTemplate(params) {
+        return this.client.request({
+            method: "PUT",
+            path: "/templates/:template_id",
+            pathParams: params.path,
+            headers: params.headers,
+            body: params.body,
+            opId: "updateTemplate",
+            expectedContentType: "application/json",
+        });
+    }
+}
+exports.TemplatesApi = TemplatesApi;

package/dist/apis/TokensApi.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Tokens API
+ *
+ * Generated from contract introspection
+ * Domain: tokens
+ */
+import type { Client } from "../runtime/transport";
+import type { CreateTokenRequestContract, CreateTokenResponseContract, RevokeTokenResponseContract, scopeIdInQueryRequired, scopeTypeOrgInQueryRequired, TokenListResponseContract, TokenResponseContract, UpdateTokenRequestContract } from "../types";
+export declare class TokensApi {
+    private client;
+    constructor(client: Client);
+    /**
+     * Create a new API token
+     * Create a new API token with specified scopes and permissions.
+     * The token value is only returned once on creation - store it securely.
+     * At least one org scope is required in the scopes array.
+     *
+     */
+    createToken(params: {
+        headers?: Record<string, string>;
+        body: CreateTokenRequestContract;
+    }): Promise<CreateTokenResponseContract>;
+    /**
+     * Get token by ID
+     * Retrieve details of a specific API token by its global ID
+     */
+    getToken(params: {
+        path: {
+            tokenId: string;
+        };
+        headers?: Record<string, string>;
+    }): Promise<TokenResponseContract>;
+    /**
+     * List user's API tokens
+     * Retrieve a list of all API tokens for the authenticated user.
+     * Optionally filter by scope type and scope ID (both must be provided together).
+     *
+     */
+    listTokens(params: {
+        query?: {
+            scope_type: scopeTypeOrgInQueryRequired;
+            scope_id: scopeIdInQueryRequired;
+        };
+        headers?: Record<string, string>;
+    }): Promise<TokenListResponseContract>;
+    /**
+     * Revoke token
+     * Permanently revoke (soft delete) an API token.
+     * Once revoked, the token can no longer be used for authentication.
+     *
+     */
+    revokeToken(params: {
+        path: {
+            tokenId: string;
+        };
+        headers?: Record<string, string>;
+    }): Promise<RevokeTokenResponseContract>;
+    /**
+     * Update token
+     * Update token properties (name, permissions, expiration).
+     * Note: The token value itself cannot be changed.
+     *
+     */
+    updateToken(params: {
+        path: {
+            tokenId: string;
+        };
+        headers?: Record<string, string>;
+        body: UpdateTokenRequestContract;
+    }): Promise<TokenResponseContract>;
+}