@vaiftech/client 1.0.3 → 1.0.5

package/dist/index.d.mts

@@ -2628,6 +2628,12 @@ interface Environment {
     id: string;
     projectId: string;
     name: string;
+    type?: string;
+    url?: string;
+    customDomain?: string | null;
+    customDomainVerified?: boolean;
+    isActive?: boolean;
+    config?: Record<string, unknown>;
     createdAt: string;
     updatedAt: string;
 }
@@ -4103,6 +4109,7 @@ interface CheckEntitlementResponse {
 interface CheckoutInput {
     orgId: string;
     plan: "starter" | "pro" | "agency" | "studio_plus";
+    interval?: "monthly" | "yearly";
     successUrl?: string;
     cancelUrl?: string;
 }
@@ -4112,6 +4119,19 @@ interface CheckoutInput {
 interface CheckoutResponse {
     url: string;
 }
+/**
+ * Checkout session verification response
+ */
+interface CheckoutVerifyResponse {
+    ok: boolean;
+    status: "complete" | "expired" | "open";
+    paymentStatus: "paid" | "unpaid" | "no_payment_required";
+    plan: string;
+    interval: string;
+    subscriptionId: string | null;
+    subscriptionStatus: string | null;
+    currentPeriodEnd: string | null;
+}
 /**
  * Portal input
  */
@@ -4132,6 +4152,124 @@ interface PortalResponse {
 interface PlansResponse {
     plans: PlanDefinition[];
 }
+/**
+ * AI usage summary for billing dashboard
+ */
+interface AIUsageSummary {
+    ok: boolean;
+    plan: PlanName;
+    periodStart: string;
+    periodEnd: string;
+    daysRemaining: number;
+    creditsIncluded: number;
+    creditsUsed: number;
+    creditsRemaining: number;
+    percentUsed: number;
+    customBudgetCents: number | null;
+    hardStopEnabled: boolean;
+    overagesEnabled: boolean;
+    dailyAverageCents: number;
+    projectedMonthEndCents: number;
+    withinBudget: boolean;
+    aiEnabled: boolean;
+    providersAllowed: string[];
+    maxRequestTokens: number;
+    maxOutputTokens: number;
+}
+/**
+ * AI usage history entry (daily)
+ */
+interface AIUsageHistoryEntry {
+    date: string;
+    requests: number;
+    totalTokens: number;
+    costCents: number;
+    creditsCharged: number;
+}
+/**
+ * AI usage history response
+ */
+interface AIUsageHistoryResponse {
+    ok: boolean;
+    orgId: string;
+    periodStart: string;
+    periodEnd: string;
+    history: AIUsageHistoryEntry[];
+}
+/**
+ * AI usage breakdown item
+ */
+interface AIUsageBreakdownItem {
+    requests: number;
+    totalTokens: number;
+    costCents: number;
+    creditsCharged: number;
+}
+/**
+ * AI usage breakdown by feature
+ */
+interface AIUsageByFeature extends AIUsageBreakdownItem {
+    featureTag: string;
+}
+/**
+ * AI usage breakdown by provider
+ */
+interface AIUsageByProvider extends AIUsageBreakdownItem {
+    provider: string;
+}
+/**
+ * AI usage breakdown by model
+ */
+interface AIUsageByModel extends AIUsageBreakdownItem {
+    model: string;
+    provider: string;
+}
+/**
+ * AI usage breakdown response
+ */
+interface AIUsageBreakdownResponse {
+    ok: boolean;
+    orgId: string;
+    periodStart: string;
+    periodEnd: string;
+    byFeature: AIUsageByFeature[];
+    byProvider: AIUsageByProvider[];
+    byModel: AIUsageByModel[];
+}
+/**
+ * Recent AI request
+ */
+interface RecentAIRequest {
+    id: string;
+    projectId: string | null;
+    userId: string | null;
+    provider: string;
+    model: string;
+    taskType: string;
+    featureTag: string | null;
+    environment: string | null;
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+    costCents: number;
+    creditsCharged: number;
+    requestId: string | null;
+    cached: boolean;
+    createdAt: string;
+}
+/**
+ * Recent AI requests response
+ */
+interface RecentAIRequestsResponse {
+    ok: boolean;
+    orgId: string;
+    requests: RecentAIRequest[];
+    pagination: {
+        limit: number;
+        offset: number;
+        total: number;
+    };
+}
 /**
  * Billing module interface
  */
@@ -4156,10 +4294,30 @@ interface BillingModule {
      * Create a Stripe checkout session for upgrading
      */
     createCheckout(input: CheckoutInput): Promise<CheckoutResponse>;
+    /**
+     * Verify a checkout session after redirect (call this on billing page load with session_id param)
+     */
+    verifyCheckoutSession(sessionId: string): Promise<CheckoutVerifyResponse>;
     /**
      * Open Stripe billing portal for managing subscription
      */
     openPortal(input: PortalInput): Promise<PortalResponse>;
+    /**
+     * Get AI credits usage summary for billing dashboard
+     */
+    getAIUsageSummary(orgId: string): Promise<AIUsageSummary>;
+    /**
+     * Get AI usage history (daily) for charts
+     */
+    getAIUsageHistory(orgId: string, days?: number): Promise<AIUsageHistoryResponse>;
+    /**
+     * Get AI usage breakdown by feature, provider, and model
+     */
+    getAIUsageBreakdown(orgId: string): Promise<AIUsageBreakdownResponse>;
+    /**
+     * Get recent AI requests for detailed inspection
+     */
+    getRecentAIRequests(orgId: string, limit?: number, offset?: number): Promise<RecentAIRequestsResponse>;
 }
 
 /**
@@ -4535,6 +4693,43 @@ interface DLQListOptions {
     limit?: number;
     offset?: number;
 }
+/**
+ * Feature flag
+ */
+interface FeatureFlag$1 {
+    id: string;
+    key: string;
+    enabled: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * Admin user (super admin)
+ */
+interface SuperAdmin {
+    id: string;
+    userId: string;
+    role: string;
+    permissions: string[];
+    notes: string | null;
+    isActive: boolean;
+    lastAccessAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+    email?: string;
+    name?: string;
+}
+/**
+ * System setting
+ */
+interface SystemSetting {
+    key: string;
+    value: unknown;
+    category: string;
+    description: string | null;
+    isSecret: boolean;
+    updatedAt: string | null;
+}
 /**
  * Admin module interface
  */
@@ -4633,6 +4828,41 @@ interface AdminModule {
         ok: boolean;
         messageId: string;
     }>;
+    listFeatureFlags(): Promise<FeatureFlag$1[]>;
+    createFeatureFlag(key: string, enabled: boolean): Promise<{
+        ok: boolean;
+    }>;
+    updateFeatureFlag(key: string, enabled: boolean): Promise<{
+        ok: boolean;
+    }>;
+    deleteFeatureFlag(key: string): Promise<{
+        ok: boolean;
+        key: string;
+    }>;
+    listAdmins(): Promise<SuperAdmin[]>;
+    addAdmin(userId: string, role?: string, notes?: string): Promise<{
+        ok: boolean;
+        admin: SuperAdmin;
+    }>;
+    updateAdmin(adminId: string, data: {
+        role?: string;
+        permissions?: string[];
+        isActive?: boolean;
+        notes?: string;
+    }): Promise<{
+        ok: boolean;
+    }>;
+    removeAdmin(adminId: string): Promise<{
+        ok: boolean;
+    }>;
+    getSettings(category?: string): Promise<{
+        settings: Record<string, SystemSetting[]>;
+        total: number;
+    }>;
+    updateSetting(key: string, value: unknown): Promise<{
+        ok: boolean;
+        key: string;
+    }>;
 }
 
 /**
@@ -5050,6 +5280,348 @@ interface BudgetStatus {
     hardStop: boolean;
     percentUsed: number;
 }
+/**
+ * AI model tiers
+ */
+type AIModelTier = "free" | "paid" | "enterprise";
+/**
+ * AI model provider
+ */
+type AIModelProvider = "openai" | "anthropic";
+/**
+ * Generation types supported by the AI workspace
+ */
+type GenerationType = "schema" | "storage" | "functions" | "backend" | "fullstack";
+/**
+ * Model capabilities
+ */
+interface AIModelCapabilities {
+    streaming: boolean;
+    vision: boolean;
+    toolUse: boolean;
+    reasoning: boolean;
+    codeGeneration: boolean;
+}
+/**
+ * An AI model available in the platform
+ */
+interface AIModel {
+    id: string;
+    provider: AIModelProvider;
+    displayName: string;
+    description: string;
+    tier: AIModelTier;
+    creditMultiplier: number;
+    maxInputTokens: number;
+    maxOutputTokens: number;
+    capabilities: AIModelCapabilities;
+    bestFor: string[];
+}
+/**
+ * Available models response
+ */
+interface AvailableModelsResult {
+    models: AIModel[];
+    recommended: {
+        primary: string;
+        reasoning: string;
+        quick: string;
+    };
+    plan: string;
+    modelTier: AIModelTier;
+    maxContextTokens: number;
+}
+/**
+ * Workspace session types
+ */
+type WorkspaceSessionType = "backend_generation" | "schema_design" | "code_review";
+/**
+ * Workspace session status
+ */
+type WorkspaceSessionStatus = "active" | "completed" | "error" | "cancelled";
+/**
+ * Turn types in a workspace session
+ */
+type WorkspaceTurnType = "user_input" | "clarification" | "reasoning" | "generation";
+/**
+ * A turn in a workspace session
+ */
+interface WorkspaceTurn {
+    id: string;
+    sessionId: string;
+    turnIndex: number;
+    turnType: WorkspaceTurnType;
+    inputContent?: string;
+    reasoningContent?: string;
+    outputContent?: string;
+    generatedCode?: Record<string, string>;
+    clarificationQuestions?: ClarificationQuestion[];
+    clarificationResponses?: ClarificationResponses;
+    inputTokens: number;
+    outputTokens: number;
+    creditsCharged: string;
+    modelUsed?: string;
+    durationMs?: number;
+    status: string;
+    createdAt: string;
+}
+/**
+ * A workspace session
+ */
+interface WorkspaceSession {
+    id: string;
+    projectId: string;
+    userId: string;
+    sessionType: WorkspaceSessionType;
+    title?: string;
+    description?: string;
+    status: WorkspaceSessionStatus;
+    generationConfig: Record<string, unknown>;
+    contextSnapshot: ProjectContext;
+    primaryModelId?: string;
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    totalCreditsUsed: string;
+    outputArtifacts: Array<{
+        type: string;
+        id: string;
+    }>;
+    createdAt: string;
+    updatedAt: string;
+    completedAt?: string;
+}
+/**
+ * Input for creating a workspace session
+ */
+interface CreateWorkspaceSessionInput {
+    projectId: string;
+    sessionType: WorkspaceSessionType;
+    title?: string;
+    description?: string;
+    primaryModelId?: string;
+    generationConfig?: {
+        framework?: "express" | "fastify" | "hono";
+        language?: "typescript" | "javascript";
+        packageManager?: "npm" | "yarn" | "pnpm" | "bun";
+    };
+}
+/**
+ * Input for submitting a prompt
+ */
+interface SubmitPromptInput {
+    prompt: string;
+    modelId?: string;
+}
+/**
+ * Clarification question types
+ */
+type ClarificationQuestionType = "multiple_choice" | "text" | "boolean" | "multi_select";
+/**
+ * Clarification categories
+ */
+type ClarificationCategory = "architecture" | "features" | "data_model" | "auth" | "api_design" | "storage" | "realtime" | "deployment" | "integrations";
+/**
+ * A clarification question
+ */
+interface ClarificationQuestion {
+    id: string;
+    question: string;
+    type: ClarificationQuestionType;
+    category: ClarificationCategory;
+    options?: string[];
+    defaultValue?: string | string[];
+    required: boolean;
+    helpText?: string;
+}
+/**
+ * User's responses to clarification questions
+ */
+interface ClarificationResponses {
+    [questionId: string]: string | string[] | boolean;
+}
+/**
+ * Extracted requirements from a prompt
+ */
+interface ExtractedRequirements {
+    projectType?: string;
+    features: string[];
+    dataEntities: string[];
+    authMethod?: string;
+    apiStyle?: string;
+    frameworks?: string[];
+    integrations: string[];
+    unclear: string[];
+}
+/**
+ * Clarification analysis result
+ */
+interface ClarificationAnalysisResult {
+    needsClarification: boolean;
+    confidence: "low" | "medium" | "high";
+    questions: ClarificationQuestion[];
+    extractedRequirements: ExtractedRequirements;
+    suggestedApproach?: string;
+}
+/**
+ * Submit prompt result
+ */
+interface SubmitPromptResult {
+    turn: WorkspaceTurn;
+    needsClarification: boolean;
+    questions: ClarificationQuestion[];
+    suggestedApproach?: string;
+    extractedRequirements: ExtractedRequirements;
+}
+/**
+ * Submit clarification result
+ */
+interface SubmitClarificationResult {
+    turn: WorkspaceTurn;
+    config: BackendGenerationConfig;
+    readyToGenerate: boolean;
+}
+/**
+ * Backend generation configuration
+ */
+interface BackendGenerationConfig {
+    framework: "express" | "fastify" | "hono";
+    language: "typescript" | "javascript";
+    packageManager: "npm" | "yarn" | "pnpm" | "bun";
+    authMethod: "none" | "jwt" | "session" | "oauth" | "api_key";
+    apiStyle: "rest" | "graphql" | "trpc";
+    includeRealtime: boolean;
+    features: {
+        validation: boolean;
+        errorHandling: boolean;
+        logging: boolean;
+        cors: boolean;
+        rateLimit: boolean;
+        tests: boolean;
+        docker: boolean;
+    };
+}
+/**
+ * A generated backend
+ */
+interface GeneratedBackend {
+    id: string;
+    projectId: string;
+    sessionId?: string;
+    userId: string;
+    name: string;
+    description?: string;
+    framework: string;
+    language: string;
+    packageManager: string;
+    files: Record<string, string>;
+    fileCount: number;
+    totalLines: number;
+    connectionConfig: Record<string, unknown>;
+    dependencies: Record<string, string>;
+    devDependencies: Record<string, string>;
+    status: "draft" | "ready" | "deployed";
+    githubRepoUrl?: string;
+    deployedUrl?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * Generate backend result
+ */
+interface GenerateBackendResult {
+    backend: GeneratedBackend;
+    files: Array<{
+        path: string;
+        content: string;
+        language: string;
+    }>;
+    totalLines: number;
+}
+/**
+ * Input for generating a backend
+ */
+interface GenerateBackendInput {
+    name: string;
+    config?: Partial<BackendGenerationConfig>;
+}
+/**
+ * Project context for AI operations
+ */
+interface ProjectContext {
+    project: {
+        id: string;
+        name: string;
+        slug: string;
+        features: Record<string, boolean>;
+    };
+    schema: {
+        tables: Array<{
+            name: string;
+            columns: Array<{
+                name: string;
+                type: string;
+                nullable: boolean;
+            }>;
+            primaryKey: string[];
+            foreignKeys: Array<{
+                columns: string[];
+                referencesTable: string;
+                referencesColumns: string[];
+            }>;
+        }>;
+        totalRelationships: number;
+    };
+    storage: {
+        buckets: Array<{
+            name: string;
+            public: boolean;
+            size?: number;
+        }>;
+    };
+    functions: {
+        list: Array<{
+            name: string;
+            description?: string;
+        }>;
+        totalFunctions: number;
+    };
+    tokenCounts: {
+        schema: number;
+        storage: number;
+        functions: number;
+        code: number;
+        total: number;
+    };
+}
+/**
+ * Context summary
+ */
+interface ContextSummary {
+    tables: number;
+    columns: number;
+    relationships: number;
+    buckets: number;
+    functions: number;
+    tokens: number;
+}
+/**
+ * Get context result
+ */
+interface GetContextResult {
+    context: ProjectContext;
+    summary: ContextSummary;
+    formatted: string;
+    tokenCounts: ProjectContext["tokenCounts"];
+}
+/**
+ * Token estimation result
+ */
+interface EstimateTokensResult {
+    promptTokens: number;
+    contextTokens: number;
+    totalTokens: number;
+    estimatedCost: number;
+}
 /**
  * AI module interface for the VAIF client
  */
@@ -5174,6 +5746,153 @@ interface AIModule {
     deleteConversation(conversationId: string): Promise<{
         ok: boolean;
     }>;
+    /**
+     * Get available AI models for the current user's plan
+     *
+     * @example
+     * ```ts
+     * const result = await vaif.ai.getAvailableModels();
+     * console.log(result.models); // Available models
+     * console.log(result.recommended); // Recommended models for different tasks
+     * ```
+     */
+    getAvailableModels(): Promise<AvailableModelsResult>;
+    /**
+     * Get details for a specific model
+     */
+    getModel(modelId: string): Promise<{
+        model: AIModel;
+    }>;
+    /**
+     * Get full project context for AI operations
+     *
+     * @example
+     * ```ts
+     * const result = await vaif.ai.getProjectContext('proj_123');
+     * console.log(result.summary); // { tables: 5, columns: 25, ... }
+     * console.log(result.tokenCounts.total); // Total tokens used for context
+     * ```
+     */
+    getProjectContext(projectId: string): Promise<GetContextResult>;
+    /**
+     * Estimate tokens for a prompt
+     */
+    estimateTokens(prompt: string, projectId?: string): Promise<EstimateTokensResult>;
+    /**
+     * Analyze a prompt and get clarification questions before generation
+     *
+     * @example
+     * ```ts
+     * const result = await vaif.ai.analyzeForClarification({
+     *   prompt: 'Create a chat application backend',
+     *   projectId: 'proj_123'
+     * });
+     * if (result.needsClarification) {
+     *   console.log(result.questions); // Questions to ask user
+     * }
+     * ```
+     */
+    analyzeForClarification(input: {
+        prompt: string;
+        projectId: string;
+    }): Promise<ClarificationAnalysisResult>;
+    /**
+     * Get AI-generated prompt suggestions based on generation types
+     *
+     * @example
+     * ```ts
+     * const result = await vaif.ai.getSuggestions({
+     *   projectId: 'proj_123',
+     *   generationTypes: ['schema', 'backend']
+     * });
+     * console.log(result.suggestions); // Array of contextual prompt suggestions
+     * ```
+     */
+    getSuggestions(input: {
+        projectId: string;
+        generationTypes: GenerationType[];
+    }): Promise<{
+        suggestions: string[];
+    }>;
+    /**
+     * Create a new AI workspace session
+     *
+     * @example
+     * ```ts
+     * const result = await vaif.ai.workspace.create({
+     *   projectId: 'proj_123',
+     *   sessionType: 'backend_generation',
+     *   title: 'Chat App Backend'
+     * });
+     * console.log(result.session.id);
+     * ```
+     */
+    workspace: {
+        /**
+         * Create a new workspace session
+         */
+        create(input: CreateWorkspaceSessionInput): Promise<{
+            session: WorkspaceSession;
+        }>;
+        /**
+         * Get a workspace session with its turns
+         */
+        get(sessionId: string): Promise<{
+            session: WorkspaceSession;
+            turns: WorkspaceTurn[];
+        }>;
+        /**
+         * List workspace sessions for a project
+         */
+        list(projectId: string): Promise<{
+            sessions: WorkspaceSession[];
+        }>;
+        /**
+         * Submit a prompt to a workspace session
+         */
+        submitPrompt(sessionId: string, input: SubmitPromptInput): Promise<SubmitPromptResult>;
+        /**
+         * Submit clarification responses
+         */
+        submitClarification(sessionId: string, responses: ClarificationResponses): Promise<SubmitClarificationResult>;
+        /**
+         * Generate backend code for a session
+         */
+        generate(sessionId: string, input: GenerateBackendInput): Promise<GenerateBackendResult>;
+    };
+    /**
+     * Generated backend operations
+     */
+    backends: {
+        /**
+         * Get a generated backend by ID
+         */
+        get(backendId: string): Promise<{
+            backend: GeneratedBackend;
+        }>;
+        /**
+         * List generated backends for a project
+         */
+        list(projectId: string): Promise<{
+            backends: Array<{
+                id: string;
+                name: string;
+                description?: string;
+                framework: string;
+                language: string;
+                fileCount: number;
+                totalLines: number;
+                status: string;
+                createdAt: string;
+            }>;
+        }>;
+        /**
+         * Delete a generated backend
+         */
+        delete(backendId: string): Promise<{
+            ok: boolean;
+        }>;
+    };
 }
 
 /**