@codeguide/core 0.0.1

package/dist/services/projects/project-service.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectService = void 0;
+const base_service_1 = require("../base/base-service");
+class ProjectService extends base_service_1.BaseService {
+    async getAllProjects() {
+        const response = await this.get('/projects');
+        return response.data;
+    }
+    async getPaginatedProjects(params) {
+        const queryParams = new URLSearchParams();
+        if (params.page !== undefined)
+            queryParams.append('page', params.page.toString());
+        if (params.page_size !== undefined)
+            queryParams.append('page_size', params.page_size.toString());
+        if (params.search_query)
+            queryParams.append('search_query', params.search_query);
+        if (params.status)
+            queryParams.append('status', params.status);
+        if (params.start_date)
+            queryParams.append('start_date', params.start_date);
+        if (params.end_date)
+            queryParams.append('end_date', params.end_date);
+        if (params.sort_by_date)
+            queryParams.append('sort_by_date', params.sort_by_date);
+        const url = `/projects/paginated${queryParams.toString() ? `?${queryParams.toString()}` : ''}`;
+        return this.get(url);
+    }
+    async getProjectById(projectId) {
+        const response = await this.get(`/projects/${projectId}`);
+        return response.data;
+    }
+    async createProject(request) {
+        const response = await this.post('/projects', request);
+        return response.data;
+    }
+    async updateProject(projectId, request) {
+        const response = await this.put(`/projects/${projectId}`, request);
+        return response.data;
+    }
+    async deleteProject(projectId) {
+        return this.delete(`/projects/${projectId}`);
+    }
+    async getProjectDocuments(projectId, params) {
+        const queryParams = new URLSearchParams();
+        if (params?.current_version_only !== undefined) {
+            queryParams.append('current_version_only', params.current_version_only.toString());
+        }
+        const url = `/projects/${projectId}/documents${queryParams.toString() ? `?${queryParams.toString()}` : ''}`;
+        return this.get(url);
+    }
+}
+exports.ProjectService = ProjectService;

package/dist/services/projects/project-types.d.ts

@@ -0,0 +1,97 @@
+export interface Project {
+    id: string;
+    title: string;
+    description: string;
+    user_id: string;
+    created_at: string;
+    updated_at: string;
+    project_documents: ProjectDocument[];
+    category?: Category;
+    codie_tool?: CodieTool;
+    github_url?: string;
+    status?: string;
+    tools_selected?: string[];
+    ai_questionaire?: Record<string, any>;
+    project_outline?: Record<string, any>;
+}
+export interface ProjectDocument {
+    id: string;
+    created_at: string;
+    updated_at: string | null;
+    project_id: string;
+    user_id: string;
+    title: string;
+    document_type: string;
+    description: string | null;
+    content: string;
+    custom_document_type: string;
+    last_action: string;
+    is_current_version: boolean;
+    status: string;
+}
+export interface GetProjectDocumentsRequest {
+    current_version_only?: boolean;
+}
+export interface GetProjectDocumentsResponse {
+    status: string;
+    data: ProjectDocument[];
+}
+export interface Category {
+    id: string;
+    name: string;
+    description?: string;
+}
+export interface CodieTool {
+    id: string;
+    name: string;
+    description?: string;
+    category?: string;
+}
+export interface CreateProjectRequest {
+    title: string;
+    description: string;
+    category_id?: string;
+    codie_tool_id?: string;
+    tools_selected?: string[];
+    ai_questionaire?: Record<string, any>;
+    project_outline?: Record<string, any>;
+    github_url?: string;
+}
+export interface UpdateProjectRequest {
+    title?: string;
+    description?: string;
+    category_id?: string;
+    codie_tool_id?: string;
+    tools_selected?: string[];
+    ai_questionaire?: Record<string, any>;
+    project_outline?: Record<string, any>;
+    github_url?: string;
+    status?: string;
+}
+export interface ProjectListResponse {
+    status: string;
+    data: Project[];
+}
+export interface ProjectResponse {
+    status: string;
+    data: Project;
+}
+export interface PaginatedProjectsRequest {
+    page?: number;
+    page_size?: number;
+    search_query?: string;
+    status?: string;
+    start_date?: string;
+    end_date?: string;
+    sort_by_date?: 'asc' | 'desc';
+}
+export interface PaginatedProjectsResponse {
+    status: string;
+    data: Project[];
+    pagination: {
+        total: number;
+        page: number;
+        page_size: number;
+        total_pages: number;
+    };
+}

package/dist/services/projects/project-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/services/repository-analysis/index.d.ts

@@ -0,0 +1,2 @@
+export { RepositoryAnalysisService } from './repository-service';
+export * from './repository-types';

package/dist/services/repository-analysis/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RepositoryAnalysisService = void 0;
+var repository_service_1 = require("./repository-service");
+Object.defineProperty(exports, "RepositoryAnalysisService", { enumerable: true, get: function () { return repository_service_1.RepositoryAnalysisService; } });
+__exportStar(require("./repository-types"), exports);

package/dist/services/repository-analysis/repository-service.d.ts

@@ -0,0 +1,10 @@
+import { BaseService } from '../base/base-service';
+import { AnalyzeRepositoryRequest, AnalyzeRepositoryResponse, RepositoryAnalysisStatusResponse, RepositoryAnalysisResultResponse, RepositoryListResponse, RepositoryDetailsResponse, DeleteRepositoryResponse } from './repository-types';
+export declare class RepositoryAnalysisService extends BaseService {
+    analyzeRepository(request: AnalyzeRepositoryRequest): Promise<AnalyzeRepositoryResponse>;
+    getAnalysisStatus(taskId: string): Promise<RepositoryAnalysisStatusResponse>;
+    getAnalysisResult(taskId: string): Promise<RepositoryAnalysisResultResponse>;
+    listRepositories(skip?: number, limit?: number): Promise<RepositoryListResponse>;
+    getRepositoryDetails(repoId: string): Promise<RepositoryDetailsResponse>;
+    deleteRepository(repoId: string): Promise<DeleteRepositoryResponse>;
+}

package/dist/services/repository-analysis/repository-service.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RepositoryAnalysisService = void 0;
+const base_service_1 = require("../base/base-service");
+class RepositoryAnalysisService extends base_service_1.BaseService {
+    async analyzeRepository(request) {
+        return this.post('/repository-analysis/analyze', request);
+    }
+    async getAnalysisStatus(taskId) {
+        return this.get(`/repository-analysis/tasks/${taskId}`);
+    }
+    async getAnalysisResult(taskId) {
+        return this.get(`/repository-analysis/tasks/${taskId}/result`);
+    }
+    async listRepositories(skip, limit) {
+        const queryParams = new URLSearchParams();
+        if (skip !== undefined)
+            queryParams.append('skip', skip.toString());
+        if (limit !== undefined)
+            queryParams.append('limit', limit.toString());
+        const url = `/repository-analysis/repositories${queryParams.toString() ? `?${queryParams.toString()}` : ''}`;
+        return this.get(url);
+    }
+    async getRepositoryDetails(repoId) {
+        return this.get(`/repository-analysis/repositories/${repoId}`);
+    }
+    async deleteRepository(repoId) {
+        return this.delete(`/repository-analysis/repositories/${repoId}`);
+    }
+}
+exports.RepositoryAnalysisService = RepositoryAnalysisService;

package/dist/services/repository-analysis/repository-types.d.ts

@@ -0,0 +1,90 @@
+export interface AnalyzeRepositoryRequest {
+    repository_url: string;
+    generate_documents?: boolean;
+    create_codespace_task?: boolean;
+    project_id?: string;
+}
+export interface AnalyzeRepositoryResponse {
+    task_id: string;
+    status: string;
+    message: string;
+}
+export interface RepositoryAnalysisStatusResponse {
+    task_id: string;
+    status: string;
+    message: string;
+    progress?: number;
+}
+export interface RepositoryAnalysisResultResponse {
+    task_id: string;
+    status: string;
+    result: {
+        repository: RepositoryInfo;
+        documents: RepositoryDocument[];
+        statistics: RepositoryStatistics;
+    };
+}
+export interface RepositoryInfo {
+    id: string;
+    name: string;
+    full_name: string;
+    description?: string;
+    language?: string;
+    stars: number;
+    forks: number;
+    open_issues: number;
+    default_branch: string;
+    created_at: string;
+    updated_at: string;
+    clone_url: string;
+    homepage?: string;
+    owner: {
+        login: string;
+        id: number;
+        avatar_url: string;
+    };
+}
+export interface RepositoryDocument {
+    id: string;
+    filename: string;
+    path: string;
+    content: string;
+    language?: string;
+    size: number;
+    type: string;
+    created_at: string;
+    updated_at: string;
+}
+export interface RepositoryStatistics {
+    total_files: number;
+    total_lines_of_code: number;
+    languages: Record<string, number>;
+    file_types: Record<string, number>;
+    dependencies: string[];
+    complexity_metrics: {
+        average_complexity: number;
+        max_complexity: number;
+        min_complexity: number;
+    };
+}
+export interface RepositoryListResponse {
+    repositories: RepositoryInfo[];
+    total: number;
+}
+export interface RepositoryDetailsResponse {
+    id: string;
+    repository_url: string;
+    user_id: string;
+    created_at: string;
+    updated_at: string;
+    analysis_results?: {
+        repository: RepositoryInfo;
+        documents: RepositoryDocument[];
+        statistics: RepositoryStatistics;
+        analyzed_at: string;
+    };
+}
+export interface DeleteRepositoryResponse {
+    status: string;
+    message: string;
+}

package/dist/services/repository-analysis/repository-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/services/tasks/index.d.ts

@@ -0,0 +1,2 @@
+export { TaskService } from './task-service';
+export * from './task-types';

package/dist/services/tasks/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskService = void 0;
+var task_service_1 = require("./task-service");
+Object.defineProperty(exports, "TaskService", { enumerable: true, get: function () { return task_service_1.TaskService; } });
+__exportStar(require("./task-types"), exports);

package/dist/services/tasks/task-service.d.ts

@@ -0,0 +1,30 @@
+import { BaseService } from '../base/base-service';
+import { TaskGroup, ProjectTask, CreateTaskGroupRequest, UpdateTaskGroupRequest, CreateProjectTaskRequest, UpdateProjectTaskRequest, PaginatedTaskGroupsRequest, PaginatedTaskGroupsResponse, PaginatedProjectTasksRequest, PaginatedProjectTasksResponse, GenerateTasksRequest, GenerateTasksResponse, GetTasksByProjectRequest, GetTasksByProjectResponse, StartTaskRequest, StartTaskResponse, UpdateTaskRequest, UpdateTaskResponse } from './task-types';
+export declare class TaskService extends BaseService {
+    getAllTaskGroups(): Promise<TaskGroup[]>;
+    getPaginatedTaskGroups(params: PaginatedTaskGroupsRequest): Promise<PaginatedTaskGroupsResponse>;
+    getTaskGroupById(taskGroupId: string): Promise<TaskGroup>;
+    createTaskGroup(request: CreateTaskGroupRequest): Promise<TaskGroup>;
+    updateTaskGroup(taskGroupId: string, request: UpdateTaskGroupRequest): Promise<TaskGroup>;
+    deleteTaskGroup(taskGroupId: string): Promise<{
+        status: string;
+        message: string;
+    }>;
+    getAllProjectTasks(filters?: {
+        task_group_id?: string;
+        parent_task_id?: string;
+        status?: string;
+    }): Promise<ProjectTask[]>;
+    getPaginatedProjectTasks(params: PaginatedProjectTasksRequest): Promise<PaginatedProjectTasksResponse>;
+    getProjectTaskById(taskId: string): Promise<ProjectTask>;
+    createProjectTask(request: CreateProjectTaskRequest): Promise<ProjectTask>;
+    updateProjectTask(taskId: string, request: UpdateProjectTaskRequest): Promise<ProjectTask>;
+    deleteProjectTask(taskId: string): Promise<{
+        status: string;
+        message: string;
+    }>;
+    generateTasks(request: GenerateTasksRequest): Promise<GenerateTasksResponse>;
+    getTasksByProject(request: GetTasksByProjectRequest): Promise<GetTasksByProjectResponse>;
+    startTask(request: StartTaskRequest): Promise<StartTaskResponse>;
+    updateTask(taskId: string, request: UpdateTaskRequest): Promise<UpdateTaskResponse>;
+}

package/dist/services/tasks/task-service.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskService = void 0;
+const base_service_1 = require("../base/base-service");
+class TaskService extends base_service_1.BaseService {
+    // Task Groups
+    async getAllTaskGroups() {
+        const response = await this.get('/task-groups');
+        return response.data;
+    }
+    async getPaginatedTaskGroups(params) {
+        const queryParams = new URLSearchParams();
+        if (params.page !== undefined)
+            queryParams.append('page', params.page.toString());
+        if (params.page_size !== undefined)
+            queryParams.append('page_size', params.page_size.toString());
+        if (params.project_id)
+            queryParams.append('project_id', params.project_id);
+        const url = `/task-groups/paginated${queryParams.toString() ? `?${queryParams.toString()}` : ''}`;
+        return this.get(url);
+    }
+    async getTaskGroupById(taskGroupId) {
+        const response = await this.get(`/task-groups/${taskGroupId}`);
+        return response.data;
+    }
+    async createTaskGroup(request) {
+        const response = await this.post('/task-groups', request);
+        return response.data;
+    }
+    async updateTaskGroup(taskGroupId, request) {
+        const response = await this.put(`/task-groups/${taskGroupId}`, request);
+        return response.data;
+    }
+    async deleteTaskGroup(taskGroupId) {
+        return this.delete(`/task-groups/${taskGroupId}`);
+    }
+    // Project Tasks
+    async getAllProjectTasks(filters) {
+        const queryParams = new URLSearchParams();
+        if (filters?.task_group_id)
+            queryParams.append('task_group_id', filters.task_group_id);
+        if (filters?.parent_task_id)
+            queryParams.append('parent_task_id', filters.parent_task_id);
+        if (filters?.status)
+            queryParams.append('status', filters.status);
+        const url = `/project-tasks${queryParams.toString() ? `?${queryParams.toString()}` : ''}`;
+        const response = await this.get(url);
+        return response.data;
+    }
+    async getPaginatedProjectTasks(params) {
+        const queryParams = new URLSearchParams();
+        if (params.page !== undefined)
+            queryParams.append('page', params.page.toString());
+        if (params.page_size !== undefined)
+            queryParams.append('page_size', params.page_size.toString());
+        if (params.task_group_id)
+            queryParams.append('task_group_id', params.task_group_id);
+        if (params.parent_task_id)
+            queryParams.append('parent_task_id', params.parent_task_id);
+        if (params.status)
+            queryParams.append('status', params.status);
+        if (params.search_query)
+            queryParams.append('search_query', params.search_query);
+        const url = `/project-tasks/paginated${queryParams.toString() ? `?${queryParams.toString()}` : ''}`;
+        return this.get(url);
+    }
+    async getProjectTaskById(taskId) {
+        const response = await this.get(`/project-tasks/${taskId}`);
+        return response.data;
+    }
+    async createProjectTask(request) {
+        const response = await this.post('/project-tasks', request);
+        return response.data;
+    }
+    async updateProjectTask(taskId, request) {
+        const response = await this.put(`/project-tasks/${taskId}`, request);
+        return response.data;
+    }
+    async deleteProjectTask(taskId) {
+        return this.delete(`/project-tasks/${taskId}`);
+    }
+    // Generate Tasks
+    async generateTasks(request) {
+        return this.post('/project-tasks/generate-tasks', request);
+    }
+    // Get Tasks by Project
+    async getTasksByProject(request) {
+        const queryParams = new URLSearchParams();
+        if (request.status)
+            queryParams.append('status', request.status);
+        if (request.task_group_id)
+            queryParams.append('task_group_id', request.task_group_id);
+        const url = `/project-tasks/by-project/${request.project_id}${queryParams.toString() ? `?${queryParams.toString()}` : ''}`;
+        return this.get(url);
+    }
+    // Start Task
+    async startTask(request) {
+        return this.post(`/project-tasks/${request.task_id}/start`, request);
+    }
+    // Update Task
+    async updateTask(taskId, request) {
+        return this.put(`/project-tasks/${taskId}`, request);
+    }
+}
+exports.TaskService = TaskService;

package/dist/services/tasks/task-types.d.ts

@@ -0,0 +1,144 @@
+export interface TaskGroup {
+    id: string;
+    name: string;
+    description?: string;
+    user_id: string;
+    project_id: string;
+    created_at: string;
+    updated_at: string;
+    project_tasks: ProjectTask[];
+}
+export interface ProjectTask {
+    id: string;
+    title: string;
+    description?: string;
+    status: string;
+    user_id: string;
+    task_group_id: string;
+    parent_task_id?: string;
+    ordinal: number;
+    created_at: string;
+    updated_at: string;
+    subtasks?: ProjectTask[];
+}
+export interface CreateTaskGroupRequest {
+    name: string;
+    description?: string;
+    project_id: string;
+}
+export interface UpdateTaskGroupRequest {
+    name?: string;
+    description?: string;
+    project_id?: string;
+}
+export interface CreateProjectTaskRequest {
+    title: string;
+    description?: string;
+    task_group_id: string;
+    parent_task_id?: string;
+    ordinal?: number;
+}
+export interface UpdateProjectTaskRequest {
+    title?: string;
+    description?: string;
+    status?: string;
+    task_group_id?: string;
+    parent_task_id?: string;
+    ordinal?: number;
+}
+export interface TaskGroupListResponse {
+    status: string;
+    data: TaskGroup[];
+}
+export interface TaskGroupResponse {
+    status: string;
+    data: TaskGroup;
+}
+export interface ProjectTaskListResponse {
+    status: string;
+    data: ProjectTask[];
+}
+export interface ProjectTaskResponse {
+    status: string;
+    data: ProjectTask;
+}
+export interface PaginatedTaskGroupsRequest {
+    page?: number;
+    page_size?: number;
+    project_id?: string;
+}
+export interface PaginatedTaskGroupsResponse {
+    status: string;
+    data: TaskGroup[];
+    pagination: {
+        total: number;
+        page: number;
+        page_size: number;
+        total_pages: number;
+    };
+}
+export interface PaginatedProjectTasksRequest {
+    page?: number;
+    page_size?: number;
+    task_group_id?: string;
+    parent_task_id?: string;
+    status?: string;
+    search_query?: string;
+}
+export interface PaginatedProjectTasksResponse {
+    status: string;
+    data: ProjectTask[];
+    pagination: {
+        total: number;
+        page: number;
+        page_size: number;
+        total_pages: number;
+    };
+}
+export interface GenerateTasksRequest {
+    project_id: string;
+}
+export interface GenerateTasksResponse {
+    status: string;
+    message: string;
+    data?: {
+        task_groups_created: number;
+        tasks_created: number;
+    };
+}
+export interface GetTasksByProjectRequest {
+    project_id: string;
+    status?: string;
+    task_group_id?: string;
+}
+export interface GetTasksByProjectResponse {
+    status: string;
+    data: {
+        task_groups: TaskGroup[];
+        tasks: ProjectTask[];
+    };
+}
+export interface StartTaskRequest {
+    task_id: string;
+}
+export interface StartTaskResponse {
+    status: string;
+    message: string;
+    data: {
+        task: ProjectTask;
+    };
+}
+export interface UpdateTaskRequest {
+    task_id: string;
+    status?: string;
+    ai_result?: string;
+    title?: string;
+    description?: string;
+}
+export interface UpdateTaskResponse {
+    status: string;
+    message: string;
+    data: {
+        task: ProjectTask;
+    };
+}

package/dist/services/tasks/task-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/services/usage/index.d.ts

@@ -0,0 +1,2 @@
+export { UsageService } from './usage-service';
+export * from './usage-types';

package/dist/services/usage/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UsageService = void 0;
+var usage_service_1 = require("./usage-service");
+Object.defineProperty(exports, "UsageService", { enumerable: true, get: function () { return usage_service_1.UsageService; } });
+__exportStar(require("./usage-types"), exports);

package/dist/services/usage/usage-service.d.ts

@@ -0,0 +1,14 @@
+import { BaseService } from '../base/base-service';
+import { TrackUsageRequest, TrackUsageResponse, CreditBalanceResponse, CreditCheckRequest, CreditCheckResponse, UsageSummaryRequest, UsageSummaryResponse, AuthorizationResponse, FreeUserStatusResponse, CalculateUsageRequest, CalculateUsageResponse, TrackCodespaceUsageRequest, TrackCodespaceUsageResponse, CodespaceTaskUsageResponse } from './usage-types';
+export declare class UsageService extends BaseService {
+    trackUsage(request: TrackUsageRequest): Promise<TrackUsageResponse>;
+    getCreditBalance(): Promise<CreditBalanceResponse>;
+    checkCredits(params: CreditCheckRequest): Promise<CreditCheckResponse>;
+    getUsageSummary(params?: UsageSummaryRequest): Promise<UsageSummaryResponse>;
+    getAuthorization(): Promise<AuthorizationResponse>;
+    getFreeUserStatus(): Promise<FreeUserStatusResponse>;
+    calculateUsageCost(params: CalculateUsageRequest): Promise<CalculateUsageResponse>;
+    trackCodespaceUsage(request: TrackCodespaceUsageRequest): Promise<TrackCodespaceUsageResponse>;
+    getCodespaceTaskUsage(codespaceTaskId: string): Promise<CodespaceTaskUsageResponse>;
+    healthCheck(): Promise<boolean>;
+}