export type UUID = string;
/**
 * Base model providing identity and timestamp fields for all domain entities
 */
export type BaseEntity = {
    /**
     * Unique identifier for this entity (UUID v4 format)
     */
    id: UUID;
    /**
     * Timestamp when this entity was created (read-only, set by system)
     */
    createdAt: any;
    /**
     * Timestamp when this entity was last updated (read-only, set by system)
     */
    updatedAt: any;
};
/**
 * Entity that supports soft deletion with a deletedAt timestamp
 */
export type SoftDeletableEntity = BaseEntity & {
    /**
     * Timestamp when this entity was soft-deleted (null if not deleted)
     */
    deletedAt?: any;
};
/**
 * Entity with audit trail tracking who created and modified it
 */
export type AuditableEntity = BaseEntity & {
    /**
     * UUID of the user who created this entity (null for system-created)
     */
    createdBy?: UUID;
    /**
     * UUID of the user who last updated this entity (null for system-updated)
     */
    updatedBy?: UUID;
};
/**
 * Request model for conversational AI interactions
 */
export type AskRequest = {
    /**
     * The natural language query to be processed by the AI agent
     */
    query: string;
};
/**
 * Response model for conversational AI interactions
 */
export type AskResponse = {
    /**
     * The AI-generated response content (typically Markdown-formatted)
     */
    content: string;
    /**
     * Whether the operation completed successfully
     */
    success: boolean;
};
/**
 * Acceptance criterion for validating completion of an action item
 */
export type AcceptanceCriteria = BaseEntity & {
    /**
     * Description of what must be true for this criterion to be satisfied
     */
    description: string;
    /**
     * Whether this criterion has been verified as complete
     */
    verified: boolean;
};
/**
 * Granular, atomic step within a Task representing a single unit of work
 */
export type ActionItem = BaseEntity & {
    /**
     * Short name describing the action (verb-noun pattern recommended)
     */
    name: string;
    /**
     * Detailed description of the work to be performed
     */
    description: string;
    /**
     * Git branch name where this action item's work is performed
     */
    branch: string;
    /**
     * Action items that must complete before this one can start
     */
    dependsOn: ActionItem[];
    /**
     * Acceptance criteria for verifying completion of this action item
     */
    acceptanceCriteria: AcceptanceCriteria[];
};
export declare enum ArtifactCategory {
    PRD = "PRD",
    API = "API",
    Design = "Design",
    Other = "Other"
}
export declare enum ArtifactFormat {
    Markdown = "md",
    Text = "txt",
    Yaml = "yaml",
    Other = "Other"
}
export declare enum ArtifactState {
    Todo = "Todo",
    Elaborating = "Elaborating",
    Done = "Done"
}
/**
 * Generated document or file attached to a Feature
 */
export type Artifact = BaseEntity & {
    /**
     * Human-readable name identifying this artifact
     */
    name: string;
    /**
     * Type description providing additional context (e.g., 'documentation', 'api-spec')
     */
    type: string;
    /**
     * Category classification (PRD, API, Design, or Other)
     */
    category: ArtifactCategory;
    /**
     * File format for the artifact content
     */
    format: ArtifactFormat;
    /**
     * Brief summary of the artifact's content and purpose
     */
    summary: string;
    /**
     * Relative file path where the artifact is stored
     */
    path: string;
    /**
     * Current state in the artifact generation lifecycle
     */
    state: ArtifactState;
};
export declare enum MessageRole {
    Assistant = "assistant",
    User = "user"
}
/**
 * A message in a conversation thread between user and AI assistant
 */
export type Message = BaseEntity & {
    /**
     * Role of the message sender (User or Assistant)
     */
    role: MessageRole;
    /**
     * The text content of the message
     */
    content: string;
    /**
     * Optional choices presented to the user for selection
     */
    options?: string[];
    /**
     * Optional user's freeform text answer
     */
    answer?: string;
    /**
     * Optional index of the selected option from the options array (0-based)
     */
    selectedOption?: number;
};
export declare enum RequirementType {
    Functional = "Functional",
    NonFunctional = "NonFunctional"
}
export declare enum ResearchState {
    NotStarted = "NotStarted",
    Running = "Running",
    Finished = "Finished"
}
/**
 * A research topic exploration for gathering technical information
 */
export type Research = BaseEntity & {
    /**
     * The topic or subject being researched
     */
    topic: string;
    /**
     * Current state of the research activity (NotStarted, Running, Finished)
     */
    state: ResearchState;
    /**
     * Summary of research findings and recommendations
     */
    summary: string;
    /**
     * Artifacts produced during the research activity
     */
    artifacts: Artifact[];
};
/**
 * A user or inferred requirement attached to a feature
 */
export type Requirement = BaseEntity & {
    /**
     * URL-friendly short identifier for the requirement
     */
    slug: string;
    /**
     * The original user query that generated this requirement
     */
    userQuery: string;
    /**
     * Classification type of the requirement (Functional or NonFunctional)
     */
    type: RequirementType;
    /**
     * Research activities conducted to clarify or validate this requirement
     */
    researches: Research[];
};
/**
 * AI model configuration for different SDLC agents
 */
export type ModelConfiguration = {
    /**
     * Model for codebase analysis agent
     */
    analyze: string;
    /**
     * Model for requirements gathering agent
     */
    requirements: string;
    /**
     * Model for planning agent
     */
    plan: string;
    /**
     * Model for implementation agent
     */
    implement: string;
};
/**
 * User profile information
 */
export type UserProfile = {
    /**
     * User's display name (optional)
     */
    name?: string;
    /**
     * User's email address (optional)
     */
    email?: string;
    /**
     * GitHub username (optional, for PR attribution)
     */
    githubUsername?: string;
};
/**
 * Environment and tooling preferences
 */
export type EnvironmentConfig = {
    /**
     * Preferred code editor
     */
    defaultEditor: string;
    /**
     * Preferred shell
     */
    shellPreference: string;
};
/**
 * System configuration
 */
export type SystemConfig = {
    /**
     * CLI auto-update preference
     */
    autoUpdate: boolean;
    /**
     * Log level for CLI output
     */
    logLevel: string;
};
export declare enum AgentType {
    ClaudeCode = "claude-code",
    GeminiCli = "gemini-cli",
    Aider = "aider",
    Continue = "continue",
    Cursor = "cursor"
}
export declare enum AgentAuthMethod {
    Session = "session",
    Token = "token"
}
/**
 * AI coding agent configuration
 */
export type AgentConfig = {
    /**
     * Selected AI coding agent
     */
    type: AgentType;
    /**
     * Authentication method for the agent
     */
    authMethod: AgentAuthMethod;
    /**
     * API token for token-based auth (optional)
     */
    token?: string;
};
/**
 * Global Shep platform settings (singleton)
 */
export type Settings = BaseEntity & {
    /**
     * AI model configuration for different agents
     */
    models: ModelConfiguration;
    /**
     * User profile information
     */
    user: UserProfile;
    /**
     * Environment and tooling preferences
     */
    environment: EnvironmentConfig;
    /**
     * System-level parameters
     */
    system: SystemConfig;
    /**
     * AI coding agent selection and authentication
     */
    agent: AgentConfig;
};
export declare enum TaskState {
    Todo = "Todo",
    WIP = "Work in Progress",
    Done = "Done",
    Review = "Review"
}
/**
 * A discrete unit of work within an implementation plan
 */
export type Task = BaseEntity & {
    /**
     * Optional human-readable title for the task
     */
    title?: string;
    /**
     * Optional detailed description of what the task entails
     */
    description?: string;
    /**
     * Tasks that must be completed before this task can begin
     */
    dependsOn: Task[];
    /**
     * Granular action items that comprise this task
     */
    actionItems: ActionItem[];
    /**
     * The base branch from which this task's working branch was created
     */
    baseBranch: string;
    /**
     * Current state of task execution (Todo, WIP, Review, Done)
     */
    state: TaskState;
    /**
     * Git branch where work for this task is performed
     */
    branch: string;
};
/**
 * A significant event in the feature's timeline tracking user interactions and milestones
 */
export type TimelineEvent = BaseEntity & {
    /**
     * The user query or action that triggered this timeline event
     */
    userQuery: string;
    /**
     * Timestamp when this event occurred (read-only, set by system)
     */
    timestamp: any;
};
export declare enum PlanState {
    Requirements = "Requirements",
    ClarificationRequired = "ClarificationRequired",
    Ready = "Ready"
}
/**
 * Individual task representation within a Gantt chart visualization
 */
export type GanttTask = {
    /**
     * Unique identifier for the Gantt task
     */
    id: UUID;
    /**
     * Display name of the task shown in the Gantt chart
     */
    name: string;
    /**
     * Scheduled start time for the task
     */
    start: any;
    /**
     * Scheduled end time for the task
     */
    end: any;
    /**
     * IDs of tasks that this task depends on (must complete before this task can start)
     */
    dependencies: UUID[];
    /**
     * Completion progress as a fraction (0.0 = not started, 1.0 = complete)
     */
    progress: number;
};
/**
 * Container for Gantt chart visualization data including tasks and time bounds
 */
export type GanttViewData = {
    /**
     * Collection of tasks to display in the Gantt chart
     */
    tasks: GanttTask[];
    /**
     * Start date of the overall work plan (left boundary of the chart)
     */
    startDate: any;
    /**
     * End date of the overall work plan (right boundary of the chart)
     */
    endDate: any;
};
/**
 * Implementation plan for a feature containing tasks, artifacts, and requirements
 */
export type Plan = BaseEntity & {
    /**
     * High-level overview describing the implementation approach
     */
    overview: string;
    /**
     * User and inferred requirements that this plan addresses
     */
    requirements: Requirement[];
    /**
     * Documents and artifacts to be produced as part of this plan
     */
    artifacts: Artifact[];
    /**
     * Work items (tasks) that comprise this implementation plan
     */
    tasks: Task[];
    /**
     * Current state of the plan execution lifecycle
     */
    state: PlanState;
    /**
     * Optional Gantt chart visualization data for work scheduling
     */
    workPlan?: GanttViewData;
};
export declare enum SdlcLifecycle {
    Requirements = "Requirements",
    Research = "Research",
    Implementation = "Implementation",
    Review = "Review",
    DeployAndQA = "Deploy & QA",
    Maintain = "Maintain"
}
/**
 * Central entity tracking a piece of work through the SDLC lifecycle (Aggregate Root)
 */
export type Feature = BaseEntity & {
    /**
     * Human-readable name identifying this feature
     */
    name: string;
    /**
     * URL-friendly identifier derived from name (unique within repository)
     */
    slug: string;
    /**
     * Detailed description explaining the feature's purpose and scope
     */
    description: string;
    /**
     * Absolute file system path to the repository
     */
    repositoryPath: string;
    /**
     * Git branch name where this feature's work is performed
     */
    branch: string;
    /**
     * Current stage in the SDLC lifecycle
     */
    lifecycle: SdlcLifecycle;
    /**
     * Conversation history with the AI assistant
     */
    messages: Message[];
    /**
     * Implementation plan containing tasks, artifacts, and requirements (optional)
     */
    plan?: Plan;
    /**
     * Generated documents and artifacts attached to this feature
     */
    relatedArtifacts: Artifact[];
};
export declare enum AgentStatus {
    Idle = "Idle",
    Running = "Running",
    Paused = "Paused",
    Stopped = "Stopped"
}
/**
 * A running agent instance that processes work and responds to queries
 */
export type AgentInstance = {
    /**
     * Unique identifier for this agent instance
     */
    id: UUID;
    /**
     * Git branch this agent is operating on for code changes
     */
    branch: string;
    /**
     * Current operational status of the agent (Idle, Running, Paused, or Stopped)
     */
    status: AgentStatus;
    /**
     * Timestamp when this agent instance was created
     */
    createdAt: any;
};
/**
 * Deployment target wrapping a single ActionItem for granular deployments
 */
export type DeployTargetActionItem = {
    /**
     * Discriminator indicating this is an action item target
     */
    kind: 'actionItem';
    /**
     * The action item to deploy - represents an atomic unit of work
     */
    actionItem: ActionItem;
};
/**
 * Deployment target wrapping a single Task for task-level deployments
 */
export type DeployTargetTask = {
    /**
     * Discriminator indicating this is a task target
     */
    kind: 'task';
    /**
     * The task to deploy - includes all action items within the task
     */
    task: Task;
};
/**
 * Deployment target wrapping multiple Tasks for batch deployments
 */
export type DeployTargetTasks = {
    /**
     * Discriminator indicating this is a multi-task target
     */
    kind: 'tasks';
    /**
     * The tasks to deploy - enables batch deployment of related work
     */
    tasks: Task[];
};
export declare enum FeatureAgentState {
    GatheringRequirements = "GatheringRequirements",
    ClarificationsRequired = "ClarificationsRequired",
    DoingResearch = "DoingResearch",
    AwaitingReview = "AwaitingReview",
    ExecutingWorkPlan = "ExecutingWorkPlan",
    Ready = "Ready"
}
/**
 * Main orchestrating agent - the 'brain' that manages the complete SDLC workflow for a feature
 */
export type FeatureAgent = {
    /**
     * Unique identifier for this feature agent instance
     */
    id: UUID;
    /**
     * The feature being managed by this agent throughout its lifecycle
     */
    feature: Feature;
    /**
     * Sub-agents spawned to handle specific tasks within the workflow
     */
    agents: AgentInstance[];
    /**
     * Current operational state determining what the agent is doing
     */
    state: FeatureAgentState;
    /**
     * Timestamp when this feature agent was created
     */
    createdAt: any;
};
/**
 * Agent for handling local deployment of features, tasks, or action items
 */
export type LocalDeployAgent = {
    /**
     * Unique identifier for this deployment agent instance
     */
    id: UUID;
    /**
     * URL where the deployment is accessible once available (null before deployment)
     */
    url?: string;
    /**
     * Timestamp when this deployment agent was created
     */
    createdAt: any;
};
export declare enum PortProtocol {
    TCP = "TCP",
    UDP = "UDP"
}
/**
 * Port mapping configuration for exposing container services to the network
 */
export type PortMap = {
    /**
     * Service name identifier (e.g., 'web', 'api', 'db', 'redis')
     */
    name: string;
    /**
     * Port number to expose on the host or container network
     */
    port: number;
    /**
     * Network protocol for the port (defaults to TCP if not specified)
     */
    protocol?: PortProtocol;
};
export declare enum DeployMethod {
    DockerCompose = "DockerCompose",
    Docker = "Docker",
    Kubernetes = "Kubernetes",
    Script = "Script",
    Manual = "Manual"
}
/**
 * Configuration defining how to deploy an application with method and instructions
 */
export type DeploySkill = {
    /**
     * Unique identifier for the deployment skill configuration
     */
    id: UUID;
    /**
     * List of port mappings for services to expose when deployed
     */
    ports: PortMap[];
    /**
     * Method to use for deployment (DockerCompose, Docker, Kubernetes, Script, or Manual)
     */
    method: DeployMethod;
    /**
     * Deployment instructions or commands to execute for this deployment method
     */
    instructions: string;
    /**
     * Timestamp when the deployment skill was created
     */
    createdAt: any;
};
export declare enum DeploymentState {
    Booting = "Booting",
    Ready = "Ready",
    Stopped = "Stopped"
}
/**
 * A running deployment instance with network configuration and lifecycle management
 */
export type Deployment = {
    /**
     * Unique identifier for the deployment instance
     */
    id: UUID;
    /**
     * Current state of the deployment (Booting, Ready, or Stopped)
     */
    state: DeploymentState;
    /**
     * URL where the deployment is accessible (e.g., 'http://localhost:30100/' or 'http://172.33.0.20:5173')
     */
    url: string;
    /**
     * List of port mappings for services exposed by this deployment
     */
    ports: PortMap[];
    /**
     * Timestamp when the deployment was created
     */
    createdAt: any;
    /**
     * Timestamp when the deployment was stopped (only present when state is Stopped)
     */
    stoppedAt?: any;
};
export declare enum AgentRunStatus {
    pending = "pending",
    running = "running",
    completed = "completed",
    failed = "failed",
    interrupted = "interrupted",
    cancelled = "cancelled"
}
/**
 * Agent execution run record
 */
export type AgentRun = BaseEntity & {
    /**
     * Agent executor type used (claude-code, gemini-cli, etc.)
     */
    agentType: AgentType;
    /**
     * Agent workflow name (analyze-repository, requirements, etc.)
     */
    agentName: string;
    /**
     * Current execution status
     */
    status: AgentRunStatus;
    /**
     * Input prompt sent to agent executor
     */
    prompt: string;
    /**
     * Final result output (optional, populated on completion)
     */
    result?: string;
    /**
     * Executor session ID for resumption (optional)
     */
    sessionId?: string;
    /**
     * LangGraph thread_id for checkpoint lookup and crash resume
     */
    threadId: string;
    /**
     * Process ID for crash recovery (optional)
     */
    pid?: number;
    /**
     * Last heartbeat timestamp for crash detection (optional)
     */
    lastHeartbeat?: any;
    /**
     * Execution start timestamp (optional)
     */
    startedAt?: any;
    /**
     * Execution completion timestamp (optional)
     */
    completedAt?: any;
    /**
     * Error message if execution failed (optional)
     */
    error?: string;
};
/**
 * Streaming event emitted during agent execution
 */
export type AgentRunEvent = {
    /**
     * Event type: progress, result, or error
     */
    type: 'progress' | 'result' | 'error';
    /**
     * Event content
     */
    content: string;
    /**
     * Event timestamp
     */
    timestamp: any;
};
/**
 * Agent workflow registration metadata
 */
export type AgentDefinition = {
    /**
     * Unique agent workflow name (e.g., analyze-repository)
     */
    name: string;
    /**
     * Human-readable description of what this agent does
     */
    description: string;
};
export declare enum AgentFeature {
    sessionResume = "session-resume",
    streaming = "streaming",
    toolScoping = "tool-scoping",
    structuredOutput = "structured-output",
    systemPrompt = "system-prompt"
}
export type DeployTarget = DeployTargetActionItem | DeployTargetTask | DeployTargetTasks;
export type Askable = {
    Ask(request: AskRequest): AskResponse;
};
export type FeatureAgentOperations = {
    NewFeatureWizard(): Feature;
    GatherRequirements(): Requirement[];
    DoResearch(): Research;
    CreatePlan(): Plan;
    BeginImplementation(): void;
    Ask(query: string): AskResponse;
};
export type LocalDeployAgentOperations = {
    Deploy(target: DeployTarget, skill: DeploySkill): Deployment;
    Analyze(repositoryPath: string): DeploySkill;
    Ask(query: string): AskResponse;
};
//# sourceMappingURL=output.d.ts.map