@codeguide/core 0.0.1

package/dist/codeguide.d.ts

@@ -0,0 +1,14 @@
+import { GenerationService, ProjectService, UsageService, RepositoryAnalysisService, TaskService } from './services';
+import { APIServiceConfig, CodeGuideOptions } from './types';
+export declare class CodeGuide {
+    generation: GenerationService;
+    projects: ProjectService;
+    usage: UsageService;
+    repositoryAnalysis: RepositoryAnalysisService;
+    tasks: TaskService;
+    private options;
+    constructor(config: APIServiceConfig, options?: CodeGuideOptions);
+    getGuidance(prompt: string): Promise<any>;
+    isHealthy(): Promise<boolean>;
+    setOptions(options: Partial<CodeGuideOptions>): void;
+}

package/dist/codeguide.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeGuide = void 0;
+const dotenv_1 = __importDefault(require("dotenv"));
+const path_1 = __importDefault(require("path"));
+// Load environment variables from project root
+dotenv_1.default.config({
+    path: path_1.default.resolve(__dirname, '../../../.env'),
+    quiet: true,
+});
+const services_1 = require("./services");
+class CodeGuide {
+    constructor(config, options = {}) {
+        this.options = options;
+        // Initialize all services with the same config
+        this.generation = new services_1.GenerationService(config);
+        this.projects = new services_1.ProjectService(config);
+        this.usage = new services_1.UsageService(config);
+        this.repositoryAnalysis = new services_1.RepositoryAnalysisService(config);
+        this.tasks = new services_1.TaskService(config);
+    }
+    // Convenience method for backward compatibility
+    async getGuidance(prompt) {
+        const request = {
+            user_prompt: prompt,
+            ...(this.options.language && { language: this.options.language }),
+            ...(this.options.context && { context: this.options.context }),
+        };
+        if (this.options.verbose) {
+            console.log('Sending request:', JSON.stringify(request, null, 2));
+        }
+        const response = await this.generation.refinePrompt(request);
+        if (this.options.verbose) {
+            console.log('Received response:', JSON.stringify(response, null, 2));
+        }
+        return {
+            id: Date.now().toString(),
+            response: response.refined_prompt,
+            timestamp: new Date().toISOString(),
+            language: this.options.language,
+        };
+    }
+    async isHealthy() {
+        return this.usage.healthCheck();
+    }
+    setOptions(options) {
+        this.options = { ...this.options, ...options };
+    }
+}
+exports.CodeGuide = CodeGuide;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { CodeGuide } from './codeguide';
+export * from './services';
+export * from './types';

package/dist/index.js

@@ -0,0 +1,31 @@
+"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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeGuide = void 0;
+const dotenv_1 = __importDefault(require("dotenv"));
+const path_1 = __importDefault(require("path"));
+// Load environment variables from project root
+dotenv_1.default.config({
+    path: path_1.default.resolve(__dirname, '../../../.env'),
+    quiet: true,
+});
+var codeguide_1 = require("./codeguide");
+Object.defineProperty(exports, "CodeGuide", { enumerable: true, get: function () { return codeguide_1.CodeGuide; } });
+__exportStar(require("./services"), exports);
+__exportStar(require("./types"), exports);

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

@@ -0,0 +1,30 @@
+import { AxiosInstance } from 'axios';
+import { APIServiceConfig, AuthenticationMethod, AuthenticationResult } from '../../types';
+export declare abstract class BaseService {
+    protected client: AxiosInstance;
+    protected config: APIServiceConfig;
+    constructor(config: APIServiceConfig);
+    /**
+     * Determine and return authentication headers based on priority
+     * Priority: 1. Database API Key, 2. Legacy API Key, 3. Clerk JWT
+     */
+    private getAuthenticationHeaders;
+    /**
+     * Get the current authentication method being used
+     */
+    getAuthenticationMethod(): AuthenticationMethod | null;
+    /**
+     * Validate the current authentication configuration
+     */
+    validateAuthentication(): AuthenticationResult;
+    private setupInterceptors;
+    protected get<T>(url: string, config?: any): Promise<T>;
+    /**
+     * Safely format error message to avoid [object Object]
+     */
+    private formatErrorMessage;
+    protected post<T>(url: string, data?: any, config?: any): Promise<T>;
+    protected put<T>(url: string, data?: any, config?: any): Promise<T>;
+    protected delete<T>(url: string, config?: any): Promise<T>;
+    protected buildUrl(endpoint: string): string;
+}

package/dist/services/base/base-service.js

@@ -0,0 +1,187 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseService = void 0;
+const axios_1 = __importDefault(require("axios"));
+class BaseService {
+    constructor(config) {
+        this.config = config;
+        // Ensure baseUrl includes the API version
+        const baseUrl = config.baseUrl;
+        this.client = axios_1.default.create({
+            baseURL: baseUrl,
+            timeout: config.timeout || 3600000, // 1 hour timeout for document generation
+            headers: this.getAuthenticationHeaders(),
+        });
+        this.setupInterceptors();
+    }
+    /**
+     * Determine and return authentication headers based on priority
+     * Priority: 1. Database API Key, 2. Legacy API Key, 3. Clerk JWT
+     */
+    getAuthenticationHeaders() {
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        // Priority 1: Database API Key (format: sk_...)
+        if (this.config.databaseApiKey && this.config.databaseApiKey.startsWith('sk_')) {
+            headers['Authorization'] = `Bearer ${this.config.databaseApiKey}`;
+            return headers;
+        }
+        return headers;
+    }
+    /**
+     * Get the current authentication method being used
+     */
+    getAuthenticationMethod() {
+        // Priority 1: Database API Key
+        if (this.config.databaseApiKey && this.config.databaseApiKey.startsWith('sk_')) {
+            return {
+                type: 'database-api-key',
+                priority: 1,
+                headers: {
+                    Authorization: `Bearer ${this.config.databaseApiKey}`,
+                    'Content-Type': 'application/json',
+                },
+            };
+        }
+        // Priority 2: Legacy API Key + User ID
+        if (this.config.apiKey && this.config.userId) {
+            return {
+                type: 'legacy-api-key',
+                priority: 2,
+                headers: {
+                    'X-API-Key': this.config.apiKey,
+                    'X-User-ID': this.config.userId,
+                    'Content-Type': 'application/json',
+                },
+            };
+        }
+        // Priority 3: Clerk JWT Token
+        if (this.config.jwtToken) {
+            return {
+                type: 'clerk-jwt',
+                priority: 3,
+                headers: {
+                    Authorization: `Bearer ${this.config.jwtToken}`,
+                    'Content-Type': 'application/json',
+                },
+            };
+        }
+        // Fallback: Legacy API key without user ID
+        if (this.config.apiKey) {
+            return {
+                type: 'legacy-api-key',
+                priority: 2,
+                headers: {
+                    'X-API-Key': this.config.apiKey,
+                    'Content-Type': 'application/json',
+                },
+            };
+        }
+        return null;
+    }
+    /**
+     * Validate the current authentication configuration
+     */
+    validateAuthentication() {
+        const method = this.getAuthenticationMethod();
+        if (!method) {
+            return {
+                success: false,
+                error: 'No authentication method configured. Please provide either databaseApiKey, apiKey + userId, or jwtToken.',
+            };
+        }
+        // Validate database API key format
+        if (method.type === 'database-api-key') {
+            if (!this.config.databaseApiKey?.startsWith('sk_')) {
+                return {
+                    success: false,
+                    error: 'Database API key must start with "sk_"',
+                };
+            }
+        }
+        // Validate legacy API key requires user ID
+        if (method.type === 'legacy-api-key' && !this.config.userId) {
+            return {
+                success: false,
+                error: 'Legacy API key authentication requires both apiKey and userId',
+            };
+        }
+        return {
+            success: true,
+            method,
+        };
+    }
+    setupInterceptors() {
+        this.client.interceptors.response.use((response) => response, error => {
+            if (axios_1.default.isAxiosError(error)) {
+                const authMethod = this.getAuthenticationMethod();
+                const status = error.response?.status;
+                const detail = error.response?.data?.detail;
+                const message = error.response?.data?.message || error.message;
+                // Handle authentication-specific errors
+                if (status === 401) {
+                    if (authMethod?.type === 'database-api-key') {
+                        throw new Error(`Database API key authentication failed: ${this.formatErrorMessage(detail, 'Invalid, expired, or inactive API key')}`);
+                    }
+                    else if (authMethod?.type === 'legacy-api-key') {
+                        throw new Error(`Legacy API key authentication failed: ${this.formatErrorMessage(detail, 'Invalid API key or user ID')}`);
+                    }
+                    else if (authMethod?.type === 'clerk-jwt') {
+                        throw new Error(`Clerk JWT authentication failed: ${this.formatErrorMessage(detail, 'Invalid or expired token')}`);
+                    }
+                    else {
+                        throw new Error(`Authentication failed: ${this.formatErrorMessage(detail || message, 'Authentication failed')}`);
+                    }
+                }
+                // Handle subscription/permission errors
+                if (status === 403) {
+                    throw new Error(`Access denied: ${this.formatErrorMessage(detail, 'Insufficient permissions or subscription required')}`);
+                }
+                // Handle rate limiting
+                if (status === 429) {
+                    throw new Error(`Rate limit exceeded: ${this.formatErrorMessage(detail, 'Too many requests. Please try again later.')}`);
+                }
+                // Handle usage limit errors
+                if (detail?.includes('credits') || detail?.includes('usage')) {
+                    throw new Error(`Usage limit exceeded: ${this.formatErrorMessage(detail, 'Usage limit exceeded')}`);
+                }
+                // Generic API error
+                throw new Error(`API Error: ${this.formatErrorMessage(detail || message, 'Unknown API error')}`);
+            }
+            throw error;
+        });
+    }
+    async get(url, config) {
+        const response = await this.client.get(url, config);
+        return response.data;
+    }
+    /**
+     * Safely format error message to avoid [object Object]
+     */
+    formatErrorMessage(value, fallback) {
+        if (value && typeof value === 'object') {
+            return JSON.stringify(value);
+        }
+        return value || fallback;
+    }
+    async post(url, data, config) {
+        const response = await this.client.post(url, data, config);
+        return response.data;
+    }
+    async put(url, data, config) {
+        const response = await this.client.put(url, data, config);
+        return response.data;
+    }
+    async delete(url, config) {
+        const response = await this.client.delete(url, config);
+        return response.data;
+    }
+    buildUrl(endpoint) {
+        return endpoint.startsWith('/') ? endpoint : `/${endpoint}`;
+    }
+}
+exports.BaseService = BaseService;

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

@@ -0,0 +1 @@
+export { BaseService } from './base-service';

package/dist/services/base/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseService = void 0;
+var base_service_1 = require("./base-service");
+Object.defineProperty(exports, "BaseService", { enumerable: true, get: function () { return base_service_1.BaseService; } });

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

@@ -0,0 +1,15 @@
+import { BaseService } from '../base/base-service';
+import { RefinePromptRequest, RefinePromptResponse, GenerateTitleRequest, GenerateTitleResponse, GenerateQuestionnaireRequest, GenerateQuestionnaireResponse, GeneratePRDRequest, GeneratePRDResponse, GenerateCategoryRequest, GenerateCategoryResponse, GenerateOutlineRequest, GenerateOutlineResponse, GenerateDocumentRequest, GenerateDocumentResponse, GenerateMultipleDocumentsRequest, GenerateMultipleDocumentsResponse, GenerateMissingDocumentsRequest, GenerateMissingDocumentsResponse, BackgroundGenerationRequest, BackgroundGenerationResponse, BackgroundGenerationStatusResponse } from './generation-types';
+export declare class GenerationService extends BaseService {
+    refinePrompt(request: RefinePromptRequest): Promise<RefinePromptResponse>;
+    generateTitle(request: GenerateTitleRequest): Promise<GenerateTitleResponse>;
+    generateQuestionnaire(request: GenerateQuestionnaireRequest): Promise<GenerateQuestionnaireResponse>;
+    generatePRD(request: GeneratePRDRequest): Promise<GeneratePRDResponse>;
+    generateCategory(request: GenerateCategoryRequest): Promise<GenerateCategoryResponse>;
+    generateOutline(request: GenerateOutlineRequest): Promise<GenerateOutlineResponse>;
+    generateDocument(request: GenerateDocumentRequest): Promise<GenerateDocumentResponse>;
+    generateMultipleDocuments(request: GenerateMultipleDocumentsRequest): Promise<GenerateMultipleDocumentsResponse>;
+    generateMissingDocuments(request: GenerateMissingDocumentsRequest): Promise<GenerateMissingDocumentsResponse>;
+    startBackgroundGeneration(request: BackgroundGenerationRequest): Promise<BackgroundGenerationResponse>;
+    getBackgroundGenerationStatus(jobId: string): Promise<BackgroundGenerationStatusResponse>;
+}

package/dist/services/generation/generation-service.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenerationService = void 0;
+const base_service_1 = require("../base/base-service");
+class GenerationService extends base_service_1.BaseService {
+    async refinePrompt(request) {
+        return this.post('/generate/refine-prompt', request);
+    }
+    async generateTitle(request) {
+        return this.post('/generate/title', request);
+    }
+    async generateQuestionnaire(request) {
+        return this.post('/generate/questionnaire', request);
+    }
+    async generatePRD(request) {
+        return this.post('/generate/prd', request);
+    }
+    async generateCategory(request) {
+        return this.post('/generate/category', request);
+    }
+    async generateOutline(request) {
+        return this.post('/generate/outline', request);
+    }
+    async generateDocument(request) {
+        return this.post('/generate/document', request);
+    }
+    async generateMultipleDocuments(request) {
+        return this.post('/generate/multiple-documents', request);
+    }
+    async generateMissingDocuments(request) {
+        return this.post('/generate/generate-missing-documents', request);
+    }
+    async startBackgroundGeneration(request) {
+        return this.post('/generate/background', request);
+    }
+    async getBackgroundGenerationStatus(jobId) {
+        return this.get(`/generate/background/${jobId}/status`);
+    }
+}
+exports.GenerationService = GenerationService;

package/dist/services/generation/generation-types.d.ts

@@ -0,0 +1,111 @@
+export interface RefinePromptRequest {
+    user_prompt: string;
+    image_urls?: string[];
+    language?: string;
+    context?: string;
+}
+export interface RefinePromptResponse {
+    refined_prompt: string;
+}
+export interface GenerateTitleRequest {
+    description: string;
+    is_deep_research?: boolean;
+}
+export interface GenerateTitleResponse {
+    title: string;
+}
+export interface GenerateQuestionnaireRequest {
+    project_context: string;
+}
+export interface GenerateQuestionnaireResponse {
+    questions: string[];
+}
+export interface GeneratePRDRequest {
+    description: string;
+    selected_tools: string[];
+    answers: Record<string, any>;
+    outline?: string;
+}
+export interface GeneratePRDResponse {
+    content: string;
+}
+export interface GenerateCategoryRequest {
+    title: string;
+    existing_categories?: string[];
+}
+export interface GenerateCategoryResponse {
+    category: string;
+}
+export interface GenerateOutlineRequest {
+    project_type: string;
+    description: string;
+    selected_tools: string[];
+    answers: Record<string, any>;
+    custom_document_type?: string;
+    title?: string;
+    outline?: string;
+    prd?: string;
+    app_flow?: string;
+    tech_stack_doc?: string;
+    starter_kit?: string;
+}
+export interface GenerateOutlineResponse {
+    outline: string;
+}
+export interface GenerateDocumentRequest {
+    project_type?: string;
+    description: string;
+    selected_tools: string[];
+    answers: Record<string, any>;
+    outline?: string;
+    custom_document_type?: string;
+    prd?: string;
+    app_flow?: string;
+    tech_stack_doc?: string;
+    title?: string;
+    starter_kit?: string;
+}
+export interface GenerateDocumentResponse {
+    content: string;
+}
+export interface GenerateMultipleDocumentsRequest {
+    project_id: string;
+    description: string;
+    selected_tools: string[];
+    document_types: string[];
+    answers: Record<string, any>;
+    outline?: string;
+    prd?: string;
+    app_flow?: string;
+    tech_stack_doc?: string;
+    starter_kit?: string;
+}
+export interface GenerateMultipleDocumentsResponse {
+    success: boolean;
+    error?: string;
+}
+export interface BackgroundGenerationRequest {
+    project_id: string;
+    document_types?: string[];
+}
+export interface BackgroundGenerationResponse {
+    job_id: string;
+    status: string;
+    message: string;
+}
+export interface BackgroundGenerationStatusResponse {
+    job_id: string;
+    status: string;
+    progress: Record<string, any>;
+    results: Record<string, any>;
+    error?: string;
+}
+export interface GenerateMissingDocumentsRequest {
+    project_id: string;
+}
+export interface GenerateMissingDocumentsResponse {
+    success: boolean;
+    message?: string;
+    error?: string;
+    generated_documents?: string[];
+}

package/dist/services/generation/generation-types.js

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

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

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

package/dist/services/generation/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.GenerationService = void 0;
+var generation_service_1 = require("./generation-service");
+Object.defineProperty(exports, "GenerationService", { enumerable: true, get: function () { return generation_service_1.GenerationService; } });
+__exportStar(require("./generation-types"), exports);

package/dist/services/index.d.ts

@@ -0,0 +1,11 @@
+export { BaseService } from './base';
+export { GenerationService } from './generation';
+export { ProjectService } from './projects';
+export { UsageService } from './usage';
+export { RepositoryAnalysisService } from './repository-analysis';
+export { TaskService } from './tasks';
+export * from './generation';
+export * from './projects';
+export * from './usage';
+export * from './repository-analysis';
+export * from './tasks';

package/dist/services/index.js

@@ -0,0 +1,45 @@
+"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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskService = exports.RepositoryAnalysisService = exports.UsageService = exports.ProjectService = exports.GenerationService = exports.BaseService = void 0;
+const dotenv_1 = __importDefault(require("dotenv"));
+const path_1 = __importDefault(require("path"));
+// Load environment variables from project root
+dotenv_1.default.config({
+    path: path_1.default.resolve(__dirname, '../../../.env'),
+    quiet: true,
+});
+var base_1 = require("./base");
+Object.defineProperty(exports, "BaseService", { enumerable: true, get: function () { return base_1.BaseService; } });
+var generation_1 = require("./generation");
+Object.defineProperty(exports, "GenerationService", { enumerable: true, get: function () { return generation_1.GenerationService; } });
+var projects_1 = require("./projects");
+Object.defineProperty(exports, "ProjectService", { enumerable: true, get: function () { return projects_1.ProjectService; } });
+var usage_1 = require("./usage");
+Object.defineProperty(exports, "UsageService", { enumerable: true, get: function () { return usage_1.UsageService; } });
+var repository_analysis_1 = require("./repository-analysis");
+Object.defineProperty(exports, "RepositoryAnalysisService", { enumerable: true, get: function () { return repository_analysis_1.RepositoryAnalysisService; } });
+var tasks_1 = require("./tasks");
+Object.defineProperty(exports, "TaskService", { enumerable: true, get: function () { return tasks_1.TaskService; } });
+// Re-export all types for convenience
+__exportStar(require("./generation"), exports);
+__exportStar(require("./projects"), exports);
+__exportStar(require("./usage"), exports);
+__exportStar(require("./repository-analysis"), exports);
+__exportStar(require("./tasks"), exports);

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

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

package/dist/services/projects/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.ProjectService = void 0;
+var project_service_1 = require("./project-service");
+Object.defineProperty(exports, "ProjectService", { enumerable: true, get: function () { return project_service_1.ProjectService; } });
+__exportStar(require("./project-types"), exports);

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

@@ -0,0 +1,14 @@
+import { BaseService } from '../base/base-service';
+import { Project, CreateProjectRequest, UpdateProjectRequest, PaginatedProjectsRequest, PaginatedProjectsResponse, GetProjectDocumentsRequest, GetProjectDocumentsResponse } from './project-types';
+export declare class ProjectService extends BaseService {
+    getAllProjects(): Promise<Project[]>;
+    getPaginatedProjects(params: PaginatedProjectsRequest): Promise<PaginatedProjectsResponse>;
+    getProjectById(projectId: string): Promise<Project>;
+    createProject(request: CreateProjectRequest): Promise<Project>;
+    updateProject(projectId: string, request: UpdateProjectRequest): Promise<Project>;
+    deleteProject(projectId: string): Promise<{
+        status: string;
+        message: string;
+    }>;
+    getProjectDocuments(projectId: string, params?: GetProjectDocumentsRequest): Promise<GetProjectDocumentsResponse>;
+}