import { J as Json, P as PaginationInput, S as SdkModule } from '../../module-Bq-w9Ws5.cjs';
import 'graphql-request';

interface OperationContext {
    appId?: string | null;
    userId?: string | null;
    workspaceId?: string | null;
    custom?: Json;
}
type VibeType = 'PROJECT' | 'WORKSPACE' | 'REPOSITORY' | 'MONOREPO' | 'PACKAGE' | 'CUSTOM';
type VibeStatus = 'ACTIVE' | 'INACTIVE' | 'ARCHIVED' | 'ERROR';
interface Vibe {
    id: string;
    name: string;
    description?: string | null;
    path?: string | null;
    type: VibeType;
    status: VibeStatus;
    agentId?: string | null;
    parentId?: string | null;
    gitBranch?: string | null;
    gitRemote?: string | null;
    gitStatus?: Json;
    environmentVariables?: Json;
    tags?: string[] | null;
    metadata?: Json;
    workspaceId: string;
    archivedAt?: string | null;
    createdAt: string;
    updatedAt: string;
    deletedAt?: string | null;
}
interface VibeList {
    items: Vibe[];
    total: number;
    hasMore: boolean;
}
interface VibeFilterInput {
    type?: VibeType;
    status?: VibeStatus;
    agentId?: string;
    parentId?: string;
    tags?: string[];
    search?: string;
}
interface CreateVibeInput {
    name: string;
    type: VibeType;
    description?: string;
    path?: string;
    agentId?: string;
    parentId?: string;
    tags?: string[];
    metadata?: Json;
    environmentVariables?: Json;
}
interface UpdateVibeInput {
    name?: string;
    description?: string;
    path?: string;
    status?: VibeStatus;
    tags?: string[];
    metadata?: Json;
    environmentVariables?: Json;
}
type VibecontrolsSessionType = 'TMUX' | 'SSH' | 'TERMINAL' | 'SCRIPT' | 'CUSTOM';
type VibecontrolsSessionStatus = 'PENDING' | 'STARTING' | 'RUNNING' | 'STOPPED' | 'ERROR' | 'TERMINATED';
interface Session {
    id: string;
    name: string;
    type: VibecontrolsSessionType;
    status: VibecontrolsSessionStatus;
    agentId: string;
    vibeId?: string | null;
    workspaceId: string;
    command?: string | null;
    args?: string[] | null;
    workingDirectory?: string | null;
    environmentVariables?: Json;
    tmuxSessionName?: string | null;
    tmuxWindowName?: string | null;
    metadata?: Json;
    startedAt?: string | null;
    stoppedAt?: string | null;
    createdAt: string;
    updatedAt: string;
    deletedAt?: string | null;
}
interface SessionList {
    items: Session[];
    total: number;
    hasMore: boolean;
}
interface SessionFilterInput {
    type?: VibecontrolsSessionType;
    status?: VibecontrolsSessionStatus;
    agentId?: string;
    vibeId?: string;
}
interface CreateSessionInput {
    name: string;
    type: VibecontrolsSessionType;
    agentId: string;
    vibeId?: string;
    command?: string;
    args?: string[];
    workingDirectory?: string;
    environmentVariables?: Json;
    metadata?: Json;
}
interface UpdateSessionInput {
    name?: string;
    metadata?: Json;
}
interface VibecontrolsAgent {
    id: string;
    name: string;
    hostname?: string | null;
    platform?: string | null;
    architecture?: string | null;
    version?: string | null;
    tunnelUrl?: string | null;
    tunnelStatus?: string | null;
    apiUrl?: string | null;
    agentApiKey?: string | null;
    appId?: string | null;
    appClientId?: string | null;
    capabilities?: Json;
    configuration?: Json;
    isActive: boolean;
    lastHeartbeat?: string | null;
    metadata?: Json;
    workspaceId: string;
    createdAt: string;
    updatedAt: string;
    deletedAt?: string | null;
}
interface VibecontrolsAgentList {
    items: VibecontrolsAgent[];
    total: number;
    hasMore: boolean;
}
interface VibecontrolsAgentFilterInput {
    isActive?: boolean;
    platform?: string;
    search?: string;
}
interface CreateVibecontrolsAgentInput {
    name: string;
    hostname?: string;
    platform?: string;
    architecture?: string;
    version?: string;
    tunnelUrl?: string;
    apiUrl?: string;
    agentApiKey?: string;
    capabilities?: Json;
    configuration?: Json;
    metadata?: Json;
}
interface UpdateVibecontrolsAgentInput {
    name?: string;
    hostname?: string;
    tunnelUrl?: string;
    apiUrl?: string;
    agentApiKey?: string;
    capabilities?: Json;
    configuration?: Json;
    isActive?: boolean;
    metadata?: Json;
}
interface AgentHealthProbeResult {
    agentId: string;
    agentName: string;
    isHealthy: boolean;
    reachable: boolean;
    latencyMs?: number | null;
    error?: string | null;
    lastHeartbeat?: string | null;
}
interface AgentProbeResult {
    agentId?: string | null;
    reachable: boolean;
    latencyMs?: number | null;
    error?: string | null;
    version?: string | null;
    tunnelUrl?: string | null;
}
interface AgentPlugin {
    name: string;
    packageName: string;
    version?: string | null;
    description?: string | null;
    isActive: boolean;
    tags?: string[] | null;
    metadata?: Json;
}
interface AgentPluginListResult {
    agentId: string;
    plugins: AgentPlugin[];
    total: number;
}
interface AgentPluginActionResult {
    success: boolean;
    message?: string | null;
    plugin?: AgentPlugin | null;
}
interface PushAgentGatewayAuthInput {
    agentId: string;
    workspaceToken?: string;
    apiKey?: string;
    metadata?: Json;
}
interface VibecontrolsNote {
    id: string;
    title: string;
    content?: string | null;
    tags?: string[] | null;
    isPinned: boolean;
    vibeId?: string | null;
    createdBy?: string | null;
    metadata?: Json;
    workspaceId: string;
    createdAt: string;
    updatedAt: string;
    deletedAt?: string | null;
}
interface VibecontrolsNoteList {
    items: VibecontrolsNote[];
    total: number;
    hasMore: boolean;
}
interface VibecontrolsNoteFilterInput {
    vibeId?: string;
    isPinned?: boolean;
    tags?: string[];
    search?: string;
}
interface CreateVibecontrolsNoteInput {
    title: string;
    content?: string;
    tags?: string[];
    isPinned?: boolean;
    vibeId?: string;
    metadata?: Json;
}
interface UpdateVibecontrolsNoteInput {
    title?: string;
    content?: string;
    tags?: string[];
    isPinned?: boolean;
    metadata?: Json;
}
interface Target {
    id: string;
    name: string;
    type: string;
    host?: string | null;
    port?: number | null;
    username?: string | null;
    status: string;
    workspaceId: string;
    createdAt: string;
    updatedAt: string;
}
interface TargetList {
    items: Target[];
    total: number;
    hasMore: boolean;
}
interface TargetFilterInput {
    type?: string;
    status?: string;
    search?: string;
}
interface CreateTargetInput {
    name: string;
    type: string;
    host?: string;
    port?: number;
    username?: string;
    metadata?: Json;
}
interface UpdateTargetInput {
    name?: string;
    host?: string;
    port?: number;
    username?: string;
    metadata?: Json;
}
interface TargetTestResult {
    success: boolean;
    error?: string | null;
    latencyMs?: number | null;
}
interface TerminalSession {
    sessionId: string;
    ttydUrl?: string | null;
}
interface InstallResult {
    success: boolean;
    error?: string | null;
}
interface AgentConnection {
    id: string;
    sourceAgentId: string;
    targetId: string;
    protocol: string;
    status: string;
    permissions?: Json;
    createdAt: string;
    updatedAt: string;
}
interface AgentGraph {
    agents: VibecontrolsAgent[];
    connections: AgentConnection[];
}
interface ImportTargetHostInput {
    name: string;
    host: string;
    port?: number;
    username?: string;
    type?: string;
}
interface UpdateConnectionPermissionsInput {
    permissions: Json;
}
type TunnelProviderKey = 'VIBETUNNELS' | 'CLOUDFLARE';
type TunnelProtocol = 'HTTP' | 'HTTPS' | 'TCP' | 'UDP';
type TunnelStatus = 'ACTIVE' | 'DEGRADED' | 'DELETING' | 'DRAFT' | 'ERROR' | 'PROVISIONING' | 'STOPPED';
type TunnelEnvironment = 'ALPHA' | 'PROD';
type TunnelDomainType = 'CUSTOM' | 'MANAGED_SUBDOMAIN';
type TunnelDomainVerificationStatus = 'EXPIRED' | 'FAILED' | 'PENDING' | 'VERIFIED' | 'VERIFYING';
type TunnelSessionStatus = 'CONNECTED' | 'DISCONNECTED' | 'EXPIRED' | 'ISSUED' | 'REVOKED';
type TunnelShardStatus = 'ACTIVE' | 'DRAINING' | 'MAINTENANCE' | 'OFFLINE';
type TlsMode = 'FULL' | 'STRICT' | 'NONE' | string;
interface TunnelDomain {
    id: string;
    workspaceId: string;
    tunnelId?: string | null;
    type: TunnelDomainType;
    hostname: string;
    environment?: TunnelEnvironment | null;
    verificationStatus: TunnelDomainVerificationStatus;
    challengeRecordName?: string | null;
    challengeToken?: string | null;
    verifiedAt?: string | null;
    lastCheckedAt?: string | null;
    lastCheckError?: string | null;
    isPrimary: boolean;
    dnsTargetHint?: string | null;
    createdAt: string;
    updatedAt: string;
    deletedAt?: string | null;
}
interface TunnelDomainList {
    items: TunnelDomain[];
    total: number;
    hasMore: boolean;
}
interface TunnelDomainFilterInput {
    environment?: TunnelEnvironment;
    search?: string;
    tunnelId?: string;
    type?: TunnelDomainType;
    verificationStatus?: TunnelDomainVerificationStatus;
}
interface Tunnel {
    id: string;
    workspaceId: string;
    agentId?: string | null;
    slug: string;
    name: string;
    description?: string | null;
    providerKey: TunnelProviderKey;
    protocol: TunnelProtocol;
    localHost: string;
    localPort: number;
    tlsMode: TlsMode;
    status: TunnelStatus;
    lastError?: string | null;
    hasBasicAuth: boolean;
    basicAuthUser?: string | null;
    metadata?: Json;
    providerConfig?: Json;
    primaryDomain?: TunnelDomain | null;
    domains?: TunnelDomain[];
    startedAt?: string | null;
    stoppedAt?: string | null;
    createdAt: string;
    updatedAt: string;
    deletedAt?: string | null;
}
interface TunnelList {
    items: Tunnel[];
    total: number;
    hasMore: boolean;
}
interface TunnelFilterInput {
    agentId?: string;
    providerKey?: TunnelProviderKey;
    search?: string;
    status?: TunnelStatus[];
}
interface CreateTunnelInput {
    agentId: string;
    name: string;
    providerKey: TunnelProviderKey;
    localPort: number;
    description?: string;
    localHost?: string;
    protocol?: TunnelProtocol;
    environment?: TunnelEnvironment;
    managedSubdomain?: string;
    slug?: string;
    tlsMode?: TlsMode;
    basicAuthUser?: string;
    basicAuthPassword?: string;
    metadata?: Json;
    providerConfig?: Json;
}
interface UpdateTunnelInput {
    name?: string;
    description?: string;
    localHost?: string;
    localPort?: number;
    tlsMode?: TlsMode;
    basicAuthUser?: string;
    basicAuthPassword?: string;
    metadata?: Json;
    providerConfig?: Json;
}
interface TunnelProviderCapabilities {
    platforms: string[];
    supportedVisibilities: string[];
    supportsCustomDomains: boolean;
    supportsHttp: boolean;
    supportsHttps: boolean;
    supportsLiveLogs: boolean;
    supportsManagedSubdomains: boolean;
    supportsReservedSubdomain: boolean;
    supportsRotateCredentials: boolean;
    supportsSessionTokens: boolean;
    supportsTcp: boolean;
    supportsUdp: boolean;
    supportsUsageMetrics: boolean;
}
interface TunnelShard {
    id: string;
    name: string;
    providerId: string;
    environment: TunnelEnvironment;
    publicHost: string;
    controlPort: number;
    proxyPortRange: string;
    region: string;
    status: TunnelShardStatus;
    capacity: number;
    currentLoad: number;
    metadata?: Json;
    createdAt: string;
    updatedAt: string;
}
interface TunnelProvider {
    id: string;
    key: TunnelProviderKey;
    displayName: string;
    description?: string | null;
    isEnabled: boolean;
    pluginPackage: string;
    minAgentVersion?: string | null;
    capabilities: TunnelProviderCapabilities;
    shards?: TunnelShard[];
    createdAt: string;
    updatedAt: string;
}
interface TunnelSession {
    id: string;
    workspaceId: string;
    tunnelId: string;
    shardId?: string | null;
    agentId?: string | null;
    status: TunnelSessionStatus;
    tokenFingerprint: string;
    issuedAt: string;
    expiresAt: string;
    connectedAt?: string | null;
    disconnectedAt?: string | null;
    revokedAt?: string | null;
    revokedReason?: string | null;
    clientIp?: string | null;
    bytesIn: number;
    bytesOut: number;
    metadata?: Json;
}
interface TunnelSessionList {
    items: TunnelSession[];
    total: number;
    hasMore: boolean;
}
interface TunnelSessionIssueResult {
    session: TunnelSession;
    token: string;
    agentConfigHint: Json;
}
interface TunnelUsageBucket {
    tunnelId: string;
    hourBucket: string;
    bytesIn: number;
    bytesOut: number;
    connections: number;
    requests: number;
}
interface ReserveTunnelSubdomainInput {
    label: string;
    environment: TunnelEnvironment;
}
interface RegisterCustomDomainInput {
    hostname: string;
}
interface AddAgentFromTunnelInput {
    tunnelUrl: string;
    apiKey: string;
    name?: string;
    scopes?: string[];
    skipDevportalApp?: boolean;
    targetId?: string;
}
interface AddAgentFromTunnelResult {
    success: boolean;
    agent: VibecontrolsAgent;
    clientId: string;
    clientSecret: string;
    devportalApplicationId?: string | null;
    error?: string | null;
}
interface AgentTunnel {
    id: string;
    agentId: string;
    tunnelUrl?: string | null;
    status: string;
    provider?: string | null;
    createdAt: string;
    metadata?: Json;
}
interface AgentTunnelListResult {
    items: AgentTunnel[];
    total: number;
}
interface CreateAgentTunnelInput {
    agentId: string;
    provider?: string;
    metadata?: Json;
}
interface VibeDeck {
    id: string;
    name: string;
    description?: string | null;
    isDefault: boolean;
    workspaceId: string;
    createdAt: string;
    updatedAt: string;
}
interface VibeDeckList {
    items: VibeDeck[];
    total: number;
    hasMore: boolean;
}
interface VibeDeckFilterInput {
    isDefault?: boolean;
    search?: string;
}
interface CreateVibeDeckInput {
    name: string;
    description?: string;
    isDefault?: boolean;
}
interface UpdateVibeDeckInput {
    name?: string;
    description?: string;
    isDefault?: boolean;
}
interface VibeDeckButton {
    id: string;
    vibeDeckId: string;
    label: string;
    icon?: string | null;
    actionType: string;
    actionId?: string | null;
    action?: {
        id: string;
        name: string;
        actionType: string;
    } | null;
    command?: string | null;
    script?: string | null;
    webhookUrl?: string | null;
    row: number;
    column: number;
    color?: string | null;
    category?: string | null;
    tags?: string[] | null;
    confirmationRequired?: boolean | null;
    keyboardShortcut?: string | null;
    style?: Json;
    sortOrder: number;
    createdAt: string;
    updatedAt: string;
}
interface VibeDeckButtonList {
    items: VibeDeckButton[];
    total: number;
    hasMore: boolean;
}
interface VibeDeckButtonFilterInput {
    vibeDeckId?: string;
    actionType?: string;
    category?: string;
    tags?: string[];
}
interface CreateVibeDeckButtonInput {
    vibeDeckId: string;
    label: string;
    icon?: string;
    actionType: string;
    actionId?: string;
    command?: string;
    script?: string;
    webhookUrl?: string;
    row: number;
    column: number;
    color?: string;
    category?: string;
    tags?: string[];
    confirmationRequired?: boolean;
    keyboardShortcut?: string;
    style?: Json;
}
interface UpdateVibeDeckButtonInput {
    label?: string;
    icon?: string;
    actionId?: string;
    command?: string;
    script?: string;
    webhookUrl?: string;
    color?: string;
    category?: string;
    tags?: string[];
    confirmationRequired?: boolean;
    keyboardShortcut?: string;
    style?: Json;
}
interface MoveVibeDeckButtonInput {
    row: number;
    column: number;
}
interface VibeDeckButtonPositionInput {
    id: string;
    sortOrder: number;
}
interface VibeDeckButtonExecutionResult {
    success: boolean;
    output?: string | null;
    error?: string | null;
}
interface Action {
    id: string;
    name: string;
    description?: string | null;
    actionType: string;
    sourceType?: string | null;
    triggerType?: string | null;
    command?: string | null;
    script?: string | null;
    webhookUrl?: string | null;
    workflowDefinition?: Json;
    configuration?: Json;
    tags?: string[] | null;
    isActive: boolean;
    storeItemId?: string | null;
    storeVersion?: string | null;
    metadata?: Json;
    workspaceId: string;
    createdAt: string;
    updatedAt: string;
    deletedAt?: string | null;
}
interface ActionList {
    items: Action[];
    total: number;
    hasMore: boolean;
}
interface ActionFilterInput {
    actionType?: string;
    sourceType?: string;
    triggerType?: string;
    isActive?: boolean;
    tags?: string[];
    search?: string;
}
interface CreateActionInput {
    name: string;
    description?: string;
    actionType: string;
    sourceType?: string;
    triggerType?: string;
    command?: string;
    script?: string;
    webhookUrl?: string;
    workflowDefinition?: Json;
    configuration?: Json;
    tags?: string[];
    isActive?: boolean;
    metadata?: Json;
}
interface UpdateActionInput {
    name?: string;
    description?: string;
    command?: string;
    script?: string;
    webhookUrl?: string;
    workflowDefinition?: Json;
    configuration?: Json;
    tags?: string[];
    isActive?: boolean;
    metadata?: Json;
}
interface ExecuteActionInput {
    parameters?: Json;
    metadata?: Json;
}
interface ActionExecution {
    id: string;
    actionId: string;
    status: string;
    input?: Json;
    output?: Json;
    error?: string | null;
    startedAt?: string | null;
    completedAt?: string | null;
    durationMs?: number | null;
    triggeredBy?: string | null;
    metadata?: Json;
    workspaceId: string;
    createdAt: string;
    updatedAt: string;
}
interface ActionExecutionList {
    items: ActionExecution[];
    total: number;
    hasMore: boolean;
}
interface ActionExecutionFilterInput {
    actionId?: string;
    status?: string;
    triggeredBy?: string;
}
interface ScheduleConfig {
    scheduleType: string;
    cronExpression?: string;
    timezone?: string;
    scheduledAt?: string;
    interval?: number;
    intervalUnit?: string;
    startDate?: string;
    endDate?: string;
    name?: string;
}
interface ScheduledJobSummary {
    id: string;
    name: string;
    scheduleType: string;
    status: string;
    actionId?: string | null;
    cronExpression?: string | null;
    timezone?: string | null;
    scheduledAt?: string | null;
    interval?: number | null;
    intervalUnit?: string | null;
    startDate?: string | null;
    endDate?: string | null;
    nextExecutionAt?: string | null;
    lastExecutionAt?: string | null;
    priority?: number | null;
    tags?: string[] | null;
}
interface ScheduledJobList {
    jobs: ScheduledJobSummary[];
    total: number;
    hasMore: boolean;
}
interface VibeAuditLog {
    id: string;
    action: string;
    resourceType: string;
    resourceId?: string | null;
    actorId?: string | null;
    actorType?: string | null;
    status: string;
    description?: string | null;
    ipAddress?: string | null;
    userAgent?: string | null;
    requestId?: string | null;
    workspaceId: string;
    createdAt: string;
}
interface VibeAuditLogList {
    items: VibeAuditLog[];
    total: number;
    hasMore: boolean;
}
interface VibeAuditLogStatsBucket {
    action?: string;
    resourceType?: string;
    status?: string;
    count: number;
}
interface VibeAuditLogStats {
    totalLogs: number;
    logsByAction: VibeAuditLogStatsBucket[];
    logsByResourceType: VibeAuditLogStatsBucket[];
    logsByStatus: VibeAuditLogStatsBucket[];
}
interface VibeAuditLogFilterInput {
    action?: string;
    resourceType?: string;
    resourceId?: string;
    actorId?: string;
    actorType?: string;
    status?: string;
    startDate?: string;
    endDate?: string;
}
interface AnalyticsBreakdownBucket {
    key: string;
    count: number;
}
interface AnalyticsTimeSeriesPoint {
    timestamp: string;
    value: number;
}
type AnalyticsGranularity = 'HOUR' | 'DAY' | 'WEEK' | 'MONTH';
type AnalyticsEntityType = 'AGENT' | 'TARGET' | 'SESSION' | 'VIBE' | 'ACTION' | 'WEBHOOK' | 'AI_EVENT' | 'VIBE_DECK' | 'AUDIT' | 'DOCS' | 'NOTE' | 'CONFIGURATION';
interface VibecontrolsAnalyticsInput {
    startDate: string;
    endDate: string;
    granularity?: AnalyticsGranularity;
    entityTypes?: AnalyticsEntityType[];
    agentId?: string;
    vibeId?: string;
}
interface VibecontrolsAnalyticsResult {
    agents?: {
        total: number;
        active: number;
        inactive: number;
        staleHeartbeatCount: number;
        byPlatform: AnalyticsBreakdownBucket[];
        byArchitecture: AnalyticsBreakdownBucket[];
        createdOverTime: AnalyticsTimeSeriesPoint[];
    } | null;
    targets?: {
        total: number;
        connectionCount: number;
        byType: AnalyticsBreakdownBucket[];
        byStatus: AnalyticsBreakdownBucket[];
    } | null;
    sessions?: {
        total: number;
        active: number;
        avgDurationMs: number | null;
        totalCollaborators: number;
        totalShares: number;
        totalShareLinks: number;
        byType: AnalyticsBreakdownBucket[];
        byStatus: AnalyticsBreakdownBucket[];
        createdOverTime: AnalyticsTimeSeriesPoint[];
    } | null;
    vibes?: {
        total: number;
        withAgent: number;
        withoutAgent: number;
        byType: AnalyticsBreakdownBucket[];
        byStatus: AnalyticsBreakdownBucket[];
        createdOverTime: AnalyticsTimeSeriesPoint[];
    } | null;
    actions?: {
        total: number;
        totalExecutions: number;
        successRate: number | null;
        avgDurationMs: number | null;
        byActionType: AnalyticsBreakdownBucket[];
        byTriggerType: AnalyticsBreakdownBucket[];
        bySourceType: AnalyticsBreakdownBucket[];
        executionsByStatus: AnalyticsBreakdownBucket[];
        executionsOverTime: AnalyticsTimeSeriesPoint[];
    } | null;
    webhooks?: {
        total: number;
        active: number;
        inactive: number;
        totalDeliveries: number;
        totalFailures: number;
        deliverySuccessRate: number | null;
    } | null;
    aiEvents?: {
        total: number;
        bySource: AnalyticsBreakdownBucket[];
        byEventType: AnalyticsBreakdownBucket[];
        eventsOverTime: AnalyticsTimeSeriesPoint[];
    } | null;
    vibeDecks?: {
        totalDecks: number;
        totalButtons: number;
        buttonsByActionType: AnalyticsBreakdownBucket[];
    } | null;
    audit?: {
        total: number;
        byAction: AnalyticsBreakdownBucket[];
        byResourceType: AnalyticsBreakdownBucket[];
        byStatus: AnalyticsBreakdownBucket[];
        eventsOverTime: AnalyticsTimeSeriesPoint[];
    } | null;
    docs?: {
        totalSites: number;
        totalPages: number;
        totalRevisions: number;
        buildSuccessRate: number | null;
        totalBuildImages: number;
        pagesByStatus: AnalyticsBreakdownBucket[];
        revisionsByStatus: AnalyticsBreakdownBucket[];
    } | null;
    notes?: {
        total: number;
        pinned: number;
        unpinned: number;
        createdOverTime: AnalyticsTimeSeriesPoint[];
    } | null;
    configurations?: {
        total: number;
        secretCount: number;
        byScope: AnalyticsBreakdownBucket[];
    } | null;
    executionTimeMs: number;
    cached: boolean;
}
interface UISession {
    id: string;
    userId: string;
    state?: Json;
    activeVibeId?: string | null;
    activeSessionId?: string | null;
    recentVibes?: string[] | null;
    recentSessions?: string[] | null;
    workspaceId: string;
    createdAt: string;
    updatedAt: string;
}
interface SaveUISessionInput {
    state?: Json;
    activeVibeId?: string;
    activeSessionId?: string;
    recentVibes?: string[];
    recentSessions?: string[];
}
type ConfigScope = 'WORKSPACE' | 'USER' | 'AGENT' | 'VIBE' | 'GLOBAL' | string;
interface Configuration {
    id: string;
    key: string;
    value?: Json;
    scope: ConfigScope;
    scopeId?: string | null;
    isSecret: boolean;
    workspaceId: string;
    createdAt: string;
    updatedAt: string;
}
interface ConfigurationList {
    items: Configuration[];
    total: number;
    hasMore: boolean;
}
interface ConfigurationFilterInput {
    scope?: ConfigScope;
    scopeId?: string;
    key?: string;
    isSecret?: boolean;
}
interface ConfigurationInput {
    key: string;
    scope: ConfigScope;
    value: Json;
    scopeId?: string;
    isSecret?: boolean;
    context?: {
        workspaceId?: string;
        userId?: string;
        appId?: string;
        projectId?: string;
    };
}
type SecurityStage = 'ARCHIVE_OFFBOARD' | 'BUILD' | 'DEPLOY_ALPHA' | 'DEPLOY_PREVIEW' | 'DEVELOPER_LOCAL' | 'INCIDENT_RESPONSE' | 'MAIN_MERGE' | 'PACKAGE_PUBLISH' | 'PROMOTE_PROD' | 'PULL_REQUEST_DEEP' | 'PULL_REQUEST_FAST' | 'REPO_ONBOARD' | 'RUNTIME_CONTINUOUS' | 'SCHEDULED_RESCAN';
type SecuritySeverity = 'CRITICAL' | 'HIGH' | 'MEDIUM' | 'LOW' | 'INFO';
type SecurityScanStatus = 'CANCELLED' | 'ERRORED' | 'FAILED' | 'QUEUED' | 'RUNNING' | 'SUCCEEDED';
type SecurityScanConclusion = 'FAIL' | 'PASS' | 'SKIPPED' | 'WARN';
type SecurityPolicyLevel = 'ADVISORY' | 'BLOCK' | 'WARN';
type SecurityFindingCategory = 'CONFIG' | 'LICENSE' | 'POLICY' | 'SAST' | 'SECRET' | 'SUPPLYCHAIN' | 'VULN';
type SecurityFindingStatus = 'ACCEPTED' | 'FALSE_POSITIVE' | 'FIXED' | 'OPEN' | 'SUPPRESSED';
type SecurityEvidenceType = 'COSIGN_BUNDLE' | 'GRYPE_JSON' | 'OPA_DECISION' | 'PROVENANCE' | 'SARIF' | 'SBOM_CYCLONEDX' | 'SBOM_SPDX';
interface SecurityProvider {
    id: string;
    workspaceId: string;
    providerName: string;
    pluginName: string;
    stage: SecurityStage;
    toolVersion: string;
    enabled: boolean;
    isDefault: boolean;
    config: Json;
    createdAt: string;
    updatedAt: string;
}
interface SecuritySummary {
    critical: number;
    high: number;
    medium: number;
    low: number;
    info: number;
}
interface SecurityEvidence {
    id: string;
    workspaceId: string;
    scanRunId: string;
    type: SecurityEvidenceType;
    sha256: string;
    sizeBytes: number;
    s3Bucket: string;
    s3Key: string;
    retentionDays: number;
    uploadedAt: string;
    downloadUrl?: string | null;
}
interface SecurityFinding {
    id: string;
    workspaceId: string;
    vibeId: string;
    scanRunId: string;
    fingerprint: string;
    category: SecurityFindingCategory;
    severity: SecuritySeverity;
    status: SecurityFindingStatus;
    ruleId: string;
    title: string;
    description?: string | null;
    file?: string | null;
    line?: number | null;
    col?: number | null;
    cve?: string | null;
    cwe: string[];
    packageName?: string | null;
    packageVersion?: string | null;
    fixedVersion?: string | null;
    remediation?: string | null;
    redactedSample?: string | null;
    ownerTeam?: string | null;
    firstSeenAt: string;
    lastSeenAt: string;
    dueAt?: string | null;
}
interface SecurityFindingList {
    items: SecurityFinding[];
    total: number;
    hasMore: boolean;
}
interface SecurityScanRun {
    id: string;
    workspaceId: string;
    vibeId: string;
    agentId?: string | null;
    createdBy: string;
    providerName: string;
    stage: SecurityStage;
    status: SecurityScanStatus;
    conclusion?: SecurityScanConclusion | null;
    policyLevel: SecurityPolicyLevel;
    repoUrl: string;
    commit: string;
    summary: SecuritySummary;
    durationMs?: number | null;
    errorReason?: string | null;
    startedAt?: string | null;
    finishedAt?: string | null;
    createdAt: string;
    findings: SecurityFinding[];
    evidence: SecurityEvidence[];
}
interface SecurityScanRunList {
    items: SecurityScanRun[];
    total: number;
    hasMore: boolean;
}
interface SecurityException {
    id: string;
    workspaceId: string;
    vibeId: string;
    findingId: string;
    reason: string;
    compensatingControls?: string | null;
    approvedBy: string[];
    expiresAt: string;
    status: string;
    createdAt: string;
}
interface SecurityPolicyDecision {
    scanRunId: string;
    allow: boolean;
    denyReasons: string[];
    policyVersion: number;
    evaluatedAt: string;
}
interface SecurityStatus {
    vibeId: string;
    policyLevel: SecurityPolicyLevel;
    totals: SecuritySummary;
    perStage: Json;
    lastScanAt?: string | null;
}
interface RepositorySecurityConfig {
    id: string;
    workspaceId: string;
    vibeId: string;
    policyLevel: SecurityPolicyLevel;
    enabledStages: Json;
    pluginAssignments: Json;
    profile: Json;
    configYamlEquivalent: Json;
    createdAt: string;
    updatedAt: string;
}
interface SecurityEvidencePresign {
    evidenceId: string;
    uploadUrl: string;
    method: string;
    requiredHeaders: Json;
    s3Bucket: string;
    s3Key: string;
    expiresAt: string;
}
interface SecurityScanFilterInput {
    vibeId?: string;
    status?: SecurityScanStatus;
    stage?: SecurityStage;
    conclusion?: SecurityScanConclusion;
}
interface SecurityFindingFilterInput {
    vibeId?: string;
    status?: SecurityFindingStatus;
    severity?: SecuritySeverity;
    category?: SecurityFindingCategory;
    search?: string;
}
interface SecurityPaginationInput {
    limit?: number;
    offset?: number;
}
interface CreateSecurityExceptionInput {
    vibeId: string;
    findingFingerprint: string;
    reason: string;
    compensatingControls?: string;
    expiresAt: string;
}
interface SetSecurityProviderInput {
    vibeId: string;
    stage: SecurityStage;
    providerKey: string;
    config?: Json;
}
interface SecurityEvidenceRefInput {
    evidenceId: string;
    type: SecurityEvidenceType;
    sha256: string;
    sizeBytes: number;
}
interface PushSecurityFindingInput {
    fingerprint: string;
    ruleId: string;
    title: string;
    category: SecurityFindingCategory;
    severity: SecuritySeverity;
    description?: string;
    file?: string;
    line?: number;
    col?: number;
    cve?: string;
    cwe?: string[];
    packageName?: string;
    packageVersion?: string;
    fixedVersion?: string;
    remediation?: string;
    redactedSample?: string;
    rawProviderRef?: string;
}
interface PushSecurityScanRunInput {
    runId: string;
    vibeId: string;
    providerName: string;
    stage: SecurityStage;
    status: SecurityScanStatus;
    conclusion?: SecurityScanConclusion;
    policyLevel: SecurityPolicyLevel;
    repoUrl: string;
    commit: string;
    durationMs?: number;
    errorReason?: string;
    startedAt?: string;
    finishedAt?: string;
    summary: Json;
    findings: PushSecurityFindingInput[];
    evidenceRefs: SecurityEvidenceRefInput[];
}
interface UpdateRepositorySecurityConfigInput {
    policyLevel?: SecurityPolicyLevel;
    enabledStages?: SecurityStage[];
    pluginAssignments?: Json;
    configYamlEquivalent?: Json;
}
interface CIPipelineJob {
    id: string;
    name: string;
    status: string;
    conclusion?: string | null;
    startedAt?: string | null;
    completedAt?: string | null;
    durationSeconds?: number | null;
}
interface CIPipelineRun {
    id: string;
    status: string;
    conclusion?: string | null;
    workflowName?: string | null;
    branch?: string | null;
    event?: string | null;
    actor?: string | null;
    url?: string | null;
    startedAt?: string | null;
    completedAt?: string | null;
    durationSeconds?: number | null;
}
interface CIPipelineDetails extends CIPipelineRun {
    commitSha?: string | null;
    commitMessage?: string | null;
    jobs?: CIPipelineJob[] | null;
}
interface CIWorkflow {
    id: string;
    name: string;
    path?: string | null;
    state?: string | null;
}
interface CIStatus {
    recentRuns: CIPipelineRun[];
    workflows: CIWorkflow[];
    averageDurationSeconds?: number | null;
    successRate?: number | null;
    totalRunsLast30Days?: number | null;
}
interface CommitActivity {
    week?: string | null;
    total?: number | null;
    additions?: number | null;
    deletions?: number | null;
}
interface Contributor {
    login: string;
    contributions: number;
    avatarUrl?: string | null;
}
interface PullRequestSummary {
    number: number;
    title: string;
    state: string;
    author?: string | null;
    url?: string | null;
    createdAt?: string | null;
    updatedAt?: string | null;
    isDraft?: boolean | null;
    labels?: string[] | null;
    reviewers?: string[] | null;
}
interface RepoStats {
    name?: string | null;
    fullName?: string | null;
    owner?: string | null;
    description?: string | null;
    defaultBranch?: string | null;
    visibility?: string | null;
    isArchived?: boolean | null;
    isFork?: boolean | null;
    diskUsageKb?: number | null;
    stargazerCount?: number | null;
    watcherCount?: number | null;
    forkCount?: number | null;
    openIssues?: number | null;
    openPullRequests?: number | null;
    dependabotAlerts?: number | null;
    languages?: Json;
    license?: string | null;
    createdAt?: string | null;
    updatedAt?: string | null;
    pushedAt?: string | null;
    contributors?: Contributor[] | null;
    commitActivity?: CommitActivity[] | null;
    pullRequests?: PullRequestSummary[] | null;
}
type GitopsProviderType = 'AZURE_DEVOPS' | 'BITBUCKET' | 'GITHUB' | 'GITLAB';
interface GitopsProvider {
    id: string;
    workspaceId: string;
    createdBy: string;
    name: string;
    providerType: GitopsProviderType;
    repoUrl: string;
    isActive: boolean;
    vibeId?: string | null;
    metadata?: Json;
    context?: OperationContext | null;
    createdAt: string;
    updatedAt: string;
    deletedAt?: string | null;
}
interface GitopsProviderList {
    items: GitopsProvider[];
    total: number;
    hasMore: boolean;
}
interface GitopsProviderFilterInput {
    providerType?: GitopsProviderType;
    isActive?: boolean;
    vibeId?: string;
    context?: {
        workspaceId?: string;
        userId?: string;
        appId?: string;
        projectId?: string;
    };
}
interface CreateGitopsProviderInput {
    name: string;
    providerType: GitopsProviderType;
    repoUrl: string;
    vibeId?: string;
    isActive?: boolean;
    metadata?: Json;
    context?: {
        workspaceId?: string;
        userId?: string;
        appId?: string;
        projectId?: string;
    };
}
interface UpdateGitopsProviderInput {
    name?: string;
    repoUrl?: string;
    vibeId?: string;
    isActive?: boolean;
    metadata?: Json;
    context?: {
        workspaceId?: string;
        userId?: string;
        appId?: string;
        projectId?: string;
    };
}
type SettingsCategory = 'ADVANCED' | 'NOTIFICATIONS' | 'PREFERENCES' | 'PROFILE' | 'SECURITY' | 'WORKSPACE_DEFAULTS';
interface NotificationPreferences {
    emailDigest: boolean;
    digestFrequency?: string | null;
    agentOffline: boolean;
    sessionError: boolean;
    vibeStatusChange: boolean;
}
interface UserPreferences {
    theme: string;
    uiDensity: string;
    sidebarCollapsed: boolean;
    codeFont?: string | null;
    codeFontSize?: number | null;
    preferredIdeCommand?: string | null;
    defaultAgentForVibe?: Json;
    vibeIdeOverrides?: Json;
    vibeDetailTabOrder?: Json;
}
interface WorkspaceDefaults {
    defaultAgent?: string | null;
    defaultSessionType: string;
    defaultVibeType: string;
    defaultEnvironmentVariables?: string | null;
    autoStartSessions: boolean;
    autoGitSync: boolean;
    agentHeartbeatInterval: number;
    agentMaxSessions: number;
    agentAutoReconnect: boolean;
    autoUpdate: boolean;
    telemetryEnabled: boolean;
    logLevel: string;
}
interface UserProfileLite {
    displayName?: string | null;
    avatar?: string | null;
    bio?: string | null;
    language?: string | null;
    timezone?: string | null;
}
interface SecuritySettingsLite {
    mfaEnabled: boolean;
    sessionTimeout?: number | null;
    activeSessions?: number | null;
}
interface SettingsBundle {
    preferences: UserPreferences;
    notifications: NotificationPreferences;
    workspaceDefaults: WorkspaceDefaults;
    profile: UserProfileLite;
    security: SecuritySettingsLite;
}
interface SettingsSecret {
    id: string;
    key: string;
    value?: string | null;
    isSecret: boolean;
    createdAt: string;
    updatedAt: string;
}
interface SetSettingsSecretInput {
    key: string;
    value: string;
}
interface UpdatePreferencesInput {
    theme?: string;
    uiDensity?: string;
    sidebarCollapsed?: boolean;
    codeFont?: string;
    codeFontSize?: number;
    preferredIdeCommand?: string | null;
    defaultAgentForVibe?: Json;
    vibeIdeOverrides?: Json;
    vibeDetailTabOrder?: Json;
}
interface UpdateNotificationPreferencesInput {
    emailDigest?: boolean;
    digestFrequency?: string;
    agentOffline?: boolean;
    sessionError?: boolean;
    vibeStatusChange?: boolean;
}
interface UpdateWorkspaceDefaultsInput {
    defaultAgent?: string;
    defaultSessionType?: string;
    defaultVibeType?: string;
    defaultEnvironmentVariables?: string;
    autoStartSessions?: boolean;
    autoGitSync?: boolean;
    agentHeartbeatInterval?: number;
    agentMaxSessions?: number;
    agentAutoReconnect?: boolean;
    autoUpdate?: boolean;
    telemetryEnabled?: boolean;
    logLevel?: string;
}
interface VibecontrolsIntegrationToken {
    accessToken: string;
    refreshToken?: string | null;
    tokenType: string;
    providerKey: string;
    scopes: string[];
    expiresAt?: string | null;
    metadata?: Json;
}
interface VibecontrolsIntegrationTokenResult {
    success: boolean;
    connectionStatus: string;
    wasRefreshed: boolean;
    token?: VibecontrolsIntegrationToken | null;
    error?: string | null;
}
type SandboxTemplate = 'AI_BUILDER' | 'WORKFLOW_MULTI_NODE' | 'MISC_SHELL' | 'CUSTOM' | 'VIBECONTROLS';
type SandboxStatus = 'PENDING' | 'PROVISIONING' | 'RUNNING' | 'STOPPING' | 'STOPPED' | 'EXPIRED' | 'FAILED';
type SandboxMode = 'DEPLOYMENT' | 'JOB';
type StorageMode = 'NONE' | 'EPHEMERAL' | 'PERSISTENT';
interface ContainerPort {
    containerPort: number;
    name?: string | null;
    protocol?: string | null;
}
interface EnvVar {
    name: string;
    value: string;
}
interface ContainerResources {
    requestsCpu?: string | null;
    requestsMemory?: string | null;
    limitsCpu?: string | null;
    limitsMemory?: string | null;
}
interface ContainerSpec {
    name: string;
    image: string;
    ports?: ContainerPort[];
    env?: EnvVar[];
    command?: string[];
    args?: string[];
    resources?: ContainerResources;
}
interface ContainerStatus {
    name: string;
    ready: boolean;
    port?: number | null;
    restartCount?: number | null;
}
interface SandboxStorage {
    mode: StorageMode;
    sizeGi?: number | null;
    mountPath?: string | null;
    retainOnDelete: boolean;
}
interface SandboxResources {
    cpuRequest: string;
    cpuLimit: string;
    memoryRequest: string;
    memoryLimit: string;
}
interface SandboxNetwork {
    exposeService: boolean;
    internalUrl?: string | null;
    containerUrls?: Json;
    serviceName?: string | null;
}
interface Sandbox {
    id: string;
    name: string;
    description?: string | null;
    template: SandboxTemplate;
    mode: SandboxMode;
    status: SandboxStatus;
    crdName?: string | null;
    podName?: string | null;
    namespace: string;
    runtimeClass: string;
    containers: ContainerSpec[];
    containerStatuses?: ContainerStatus[];
    resources: SandboxResources;
    storage: SandboxStorage;
    network: SandboxNetwork;
    ttlSeconds: number;
    expiresAt: string;
    metadata?: Json;
    errorMessage?: string | null;
    workspaceId: string;
    context?: Json;
    createdBy: string;
    createdAt: string;
    updatedAt: string;
    stoppedAt?: string | null;
}
interface SandboxList {
    items: Sandbox[];
    total: number;
    hasMore: boolean;
}
interface SandboxFilterInput {
    template?: SandboxTemplate;
    status?: SandboxStatus;
    workspaceId?: string;
}
interface SandboxPaginationInput {
    limit?: number;
    offset?: number;
    page?: number;
}
interface SandboxStats {
    activeSandboxes: number;
    totalCreated: number;
    totalDeleted: number;
    runningNow: number;
    provisioningNow: number;
    stoppedNow: number;
    expiredCount: number;
    failedCount: number;
    totalCpuUsed: string;
    totalMemoryUsed: string;
}
interface SandboxConfig {
    id: string;
    defaultTtlSeconds: number;
    maxTtlSeconds: number;
    allowedTemplates: SandboxTemplate[];
    maxConcurrentPerUser: number;
    maxConcurrentPerWorkspace: number;
    defaultCpuRequest: string;
    defaultCpuLimit: string;
    defaultMemoryRequest: string;
    defaultMemoryLimit: string;
    workspaceId: string;
    updatedAt: string;
}
interface SandboxTemplateConfig {
    id: string;
    name: string;
    description?: string | null;
    template: SandboxTemplate;
    isDefault: boolean;
    containers: ContainerSpec[];
    resources: SandboxResources;
    storage: SandboxStorage;
    ttlSeconds: number;
    config?: Json;
    metadata?: Json;
    allowedImages?: string[];
    workspaceId: string;
    context?: Json;
    createdBy: string;
    createdAt: string;
    updatedAt: string;
}
interface SandboxTemplateConfigList {
    items: SandboxTemplateConfig[];
    total: number;
    hasMore: boolean;
}
interface ContainerPortInput {
    containerPort: number;
    name?: string;
    protocol?: string;
}
interface EnvVarInput {
    name: string;
    value: string;
}
interface ContainerResourcesInput {
    requestsCpu?: string;
    requestsMemory?: string;
    limitsCpu?: string;
    limitsMemory?: string;
}
interface ContainerSpecInput {
    name: string;
    image: string;
    ports?: ContainerPortInput[];
    env?: EnvVarInput[];
    command?: string[];
    args?: string[];
    resources?: ContainerResourcesInput;
}
interface SandboxStorageInput {
    mode?: StorageMode;
    sizeGi?: number;
    mountPath?: string;
    retainOnDelete?: boolean;
}
interface SandboxResourcesInput {
    cpuRequest?: string;
    cpuLimit?: string;
    memoryRequest?: string;
    memoryLimit?: string;
}
interface CreateSandboxInput {
    name: string;
    description?: string;
    template: SandboxTemplate;
    mode?: SandboxMode;
    containers: ContainerSpecInput[];
    resources?: SandboxResourcesInput;
    storage?: SandboxStorageInput;
    ttlSeconds?: number;
    metadata?: Json;
    context: {
        workspaceId: string;
    };
    templateId?: string;
}
interface CreateSandboxTemplateInput {
    name: string;
    description?: string;
    template: SandboxTemplate;
    isDefault?: boolean;
    containers?: ContainerSpecInput[];
    resources?: SandboxResourcesInput;
    storage?: SandboxStorageInput;
    ttlSeconds?: number;
    config?: Json;
    metadata?: Json;
    allowedImages?: string[];
    context: {
        workspaceId: string;
    };
}
interface UpdateSandboxTemplateInput {
    id: string;
    name?: string;
    description?: string;
    isDefault?: boolean;
    containers?: ContainerSpecInput[];
    resources?: SandboxResourcesInput;
    storage?: SandboxStorageInput;
    ttlSeconds?: number;
    config?: Json;
    metadata?: Json;
    allowedImages?: string[];
    context: {
        workspaceId: string;
    };
}
interface UpdateSandboxConfigInput {
    defaultTtlSeconds?: number;
    maxTtlSeconds?: number;
    allowedTemplates?: SandboxTemplate[];
    maxConcurrentPerUser?: number;
    maxConcurrentPerWorkspace?: number;
    defaultCpuRequest?: string;
    defaultCpuLimit?: string;
    defaultMemoryRequest?: string;
    defaultMemoryLimit?: string;
    context: {
        workspaceId: string;
    };
}
interface SandboxAvailableTag {
    id: string;
    key: string;
    label: string;
    color?: string | null;
}
interface SandboxTagAssignment {
    id: string;
    entityId: string;
    entityType: string;
    tagId: string;
    source: string;
    assignedAt?: string | null;
    assignedBy?: string | null;
    validFrom?: string | null;
    validTo?: string | null;
    metadata?: Json;
    tag?: {
        id: string;
    } | null;
}
interface CreateSandboxTagInput {
    label: string;
    color?: string;
}
interface GetSandboxTagsInput {
    sandboxId: string;
}
interface TagSandboxInput {
    sandboxId: string;
    tagId: string;
    source?: string;
    validFrom?: string;
    validTo?: string;
    metadata?: Json;
}
interface UntagSandboxInput {
    sandboxId: string;
    tagId: string;
}
interface ReplaceSandboxTagsInput {
    sandboxId: string;
    tagIds: string[];
}
interface SandboxNodeInfo {
    name: string;
    status: string;
    allocatableCpu: string;
    allocatableMemory: string;
    sandboxPodCount: number;
    labels?: Json;
}
interface SandboxActivity {
    id: string;
    action: string;
    actorId: string;
    status: string;
    sandboxName: string;
    sandboxId?: string | null;
    createdAt: string;
}
interface SandboxActivityList {
    items: SandboxActivity[];
    total: number;
}
type SandboxExportFormat = 'CSV' | 'JSON';
type SandboxExportJobStatus = 'PENDING' | 'RUNNING' | 'COMPLETED' | 'FAILED';
interface SandboxExportJob {
    id: string;
    workspaceId: string;
    format: SandboxExportFormat;
    status: SandboxExportJobStatus;
    requestedBy: string;
    rowCount?: number | null;
    downloadUrl?: string | null;
    errorMessage?: string | null;
    expiresAt?: string | null;
    createdAt: string;
    updatedAt: string;
}
interface ExportSandboxesInput {
    workspaceId: string;
    format: SandboxExportFormat;
    filter?: SandboxFilterInput;
    includeUsageEvents?: boolean;
    context: {
        workspaceId: string;
    };
}
interface SandboxArtifactBytes {
    filename: string;
    mimeType: string;
    size: number;
    contentBase64: string;
}
interface SandboxArtifactBytesInput {
    sandboxId: string;
    sessionId: string;
    path: string;
    onBehalfOfUserId?: string;
    context?: {
        workspaceId: string;
    };
}
interface ProxySandboxRequestInput {
    sandboxId: string;
    method: string;
    path: string;
    body?: Json;
    containerName?: string;
    context: {
        workspaceId: string;
    };
}
interface ProxySandboxResponse {
    status: number;
    body?: Json;
}
type SandboxChangeType = 'CREATED' | 'DELETED' | 'STATUS_CHANGED' | 'TTL_EXTENDED';
interface SandboxChangeEvent {
    changeType: SandboxChangeType;
    occurredAt: string;
    sandbox: Sandbox;
}
type DocsVisibility = 'PUBLIC' | 'PRIVATE' | 'WORKSPACE';
interface VibecontrolsDocsSite {
    id: string;
    vibeId?: string | null;
    name: string;
    visibility: DocsVisibility;
    runtime?: string | null;
    workspaceId: string;
    createdAt: string;
    updatedAt: string;
}
interface DocsSiteList {
    items: VibecontrolsDocsSite[];
    total: number;
    hasMore: boolean;
}
interface DocsSiteFilterInput {
    visibility?: DocsVisibility;
    vibeId?: string;
    search?: string;
}
interface CreateDocsSiteInput {
    vibeId?: string;
    name: string;
    visibility?: DocsVisibility;
    runtime?: string;
}
interface UpdateDocsSiteInput {
    name?: string;
    runtime?: string;
}
interface VibecontrolsDocsPage {
    id: string;
    siteId: string;
    title: string;
    slug?: string | null;
    content?: string | null;
    parentId?: string | null;
    sidebarPosition?: number | null;
    status: string;
    createdAt: string;
    updatedAt: string;
}
interface DocsPageFilterInput {
    parentId?: string;
    status?: string;
}
interface CreateDocsPageInput {
    siteId: string;
    title: string;
    slug?: string;
    content?: string;
    parentId?: string;
    sidebarPosition?: number;
}
interface UpdateDocsPageInput {
    title?: string;
    slug?: string;
    content?: string;
    parentId?: string;
    sidebarPosition?: number;
    status?: string;
}
interface DocsPageOrderInput {
    id: string;
    sidebarPosition: number;
}
interface VibecontrolsDocsRevision {
    id: string;
    siteId: string;
    revisionNumber: number;
    status: string;
    buildDurationMs?: number | null;
    artifactSizeBytes?: number | null;
    errorMessage?: string | null;
    publishedAt?: string | null;
    createdAt: string;
    updatedAt: string;
}
interface DocsRevisionList {
    items: VibecontrolsDocsRevision[];
    total: number;
    hasMore: boolean;
}
interface AiToolEvent {
    id: string;
    source: string;
    eventType: string;
    payload?: Json;
    agentId?: string | null;
    workspaceId: string;
    createdAt: string;
}
interface AiToolEventList {
    items: AiToolEvent[];
    total: number;
    hasMore: boolean;
}
interface AiToolEventFilterInput {
    source?: string;
    eventType?: string;
    agentId?: string;
}
interface CreateAiToolEventInput {
    source: string;
    eventType: string;
    payload?: Json;
    agentId?: string;
}
interface Webhook {
    id: string;
    name: string;
    url: string;
    events: string[];
    agentIds?: string[] | null;
    isActive: boolean;
    signingKey?: string | null;
    retryPolicy?: Json;
    deliveryCount: number;
    failureCount: number;
    lastDelivery?: string | null;
    lastError?: string | null;
    workspaceId: string;
    createdAt: string;
    updatedAt: string;
    deletedAt?: string | null;
}
interface WebhookList {
    items: Webhook[];
    total: number;
    hasMore: boolean;
}
interface WebhookFilterInput {
    isActive?: boolean;
    events?: string[];
    search?: string;
}
interface CreateWebhookInput {
    name: string;
    url: string;
    events: string[];
    agentIds?: string[];
    signingKey?: string;
    retryPolicy?: Json;
    isActive?: boolean;
}
interface UpdateWebhookInput {
    name?: string;
    url?: string;
    events?: string[];
    agentIds?: string[];
    signingKey?: string;
    retryPolicy?: Json;
    isActive?: boolean;
}
interface WebhookDelivery {
    id: string;
    webhookId: string;
    event: string;
    payload?: Json;
    statusCode?: number | null;
    response?: string | null;
    error?: string | null;
    attemptCount: number;
    deliveredAt?: string | null;
    createdAt: string;
}
type CatalogVisibility = 'INTERNAL' | 'PRIVATE' | 'PUBLIC';
type ComponentLifecycle = 'ACTIVE' | 'DEPRECATED' | 'END_OF_LIFE' | 'EXPERIMENTAL';
type ComponentType = 'API' | 'CUSTOM' | 'DATABASE' | 'DEPENDENCY' | 'DOCUMENTATION' | 'FRONTEND' | 'INFRASTRUCTURE' | 'JOB' | 'LIBRARY' | 'PACKAGE' | 'SERVICE' | 'TOOL' | 'WORKFLOW';
type ScorecardOwnerType = 'CATALOG' | 'COMPONENT' | 'VIBE';
type ScorecardMetricStatus = 'FAILING' | 'PASSING' | 'UNKNOWN' | 'WARNING';
type ScorecardMetricType = 'CICD_HEALTH' | 'CUSTOM' | 'DEPENDENCY_FRESHNESS' | 'DOCUMENTATION_COVERAGE' | 'INCIDENT_COUNT' | 'SECURITY_SCORE' | 'SLO_COMPLIANCE' | 'TEST_COVERAGE';
type VibecontrolsTemplateCategory = 'BACKEND' | 'CUSTOM' | 'FRONTEND' | 'FULLSTACK' | 'INFRASTRUCTURE' | 'LIBRARY' | 'MICROSERVICE' | 'STARTER';
type VibecontrolsTemplateStatus = 'ARCHIVED' | 'DRAFT' | 'PUBLISHED';
type VibecontrolsGitHubRepoScope = 'ORG' | 'USER';
interface ContextInput {
    appId?: string;
    userId?: string;
    workspaceId?: string;
    custom?: Json;
}
interface VibecontrolsCatalog {
    id: string;
    name: string;
    description?: string | null;
    visibility: CatalogVisibility;
    ownerId?: string | null;
    ownerName?: string | null;
    componentCount: number;
    vibeCount: number;
    tags: string[];
    metadata?: Json;
    workspaceId: string;
    createdAt: string;
    updatedAt: string;
    deletedAt?: string | null;
    createdBy: string;
    updatedBy?: string | null;
    onBehalfOf: string;
}
interface VibecontrolsCatalogList {
    items: VibecontrolsCatalog[];
    total: number;
    hasMore: boolean;
}
interface CatalogFilterInput {
    search?: string;
    tags?: string[];
    visibility?: CatalogVisibility;
}
interface CreateCatalogInput {
    name: string;
    description?: string;
    visibility?: CatalogVisibility;
    ownerId?: string;
    ownerName?: string;
    tags?: string[];
    metadata?: Json;
    context?: ContextInput;
}
interface UpdateCatalogInput {
    name?: string;
    description?: string;
    visibility?: CatalogVisibility;
    ownerId?: string;
    ownerName?: string;
    tags?: string[];
    metadata?: Json;
    context?: ContextInput;
}
interface VibecontrolsCatalogComponent {
    id: string;
    catalogId: string;
    componentId: string;
    addedAt: string;
    addedBy: string;
    metadata?: Json;
    workspaceId: string;
}
interface VibecontrolsCatalogVibe {
    id: string;
    catalogId: string;
    vibeId: string;
    addedAt: string;
    addedBy: string;
    metadata?: Json;
    workspaceId: string;
}
interface VibecontrolsDependencyGraphNode {
    id: string;
    name: string;
    type: string;
    version?: string | null;
}
interface VibecontrolsDependencyGraphEdge {
    source: string;
    target: string;
    version?: string | null;
    dependencyType?: string | null;
}
interface VibecontrolsDependencyGraph {
    nodes: VibecontrolsDependencyGraphNode[];
    edges: VibecontrolsDependencyGraphEdge[];
}
interface VibecontrolsSBOMEntry {
    name: string;
    version?: string | null;
    type?: string | null;
    license?: string | null;
}
interface VibecontrolsSBOM {
    format: string;
    generatedAt: string;
    totalCount: number;
    components: VibecontrolsSBOMEntry[];
}
interface VibecontrolsComponent {
    id: string;
    name: string;
    description?: string | null;
    type: ComponentType;
    lifecycle: ComponentLifecycle;
    version?: string | null;
    language?: string | null;
    framework?: string | null;
    repositoryUrl?: string | null;
    documentationUrl?: string | null;
    dependencies?: Json;
    sbomData?: Json;
    tags: string[];
    metadata?: Json;
    ownerId?: string | null;
    ownerName?: string | null;
    teamId?: string | null;
    teamName?: string | null;
    catalogCount: number;
    workspaceId: string;
    createdAt: string;
    updatedAt: string;
    deletedAt?: string | null;
}
interface VibecontrolsComponentList {
    items: VibecontrolsComponent[];
    total: number;
    hasMore: boolean;
}
interface ComponentFilterInput {
    search?: string;
    tags?: string[];
    type?: ComponentType;
    lifecycle?: ComponentLifecycle;
    teamId?: string;
    context?: Json;
}
interface CreateComponentInput {
    name: string;
    description?: string;
    type?: ComponentType;
    lifecycle?: ComponentLifecycle;
    version?: string;
    language?: string;
    framework?: string;
    repositoryUrl?: string;
    documentationUrl?: string;
    dependencies?: Json;
    sbomData?: Json;
    tags?: string[];
    metadata?: Json;
    ownerId?: string;
    ownerName?: string;
    teamId?: string;
    teamName?: string;
    context?: ContextInput;
}
interface UpdateComponentInput {
    name?: string;
    description?: string;
    type?: ComponentType;
    lifecycle?: ComponentLifecycle;
    version?: string;
    language?: string;
    framework?: string;
    repositoryUrl?: string;
    documentationUrl?: string;
    dependencies?: Json;
    sbomData?: Json;
    tags?: string[];
    metadata?: Json;
    ownerId?: string;
    ownerName?: string;
    teamId?: string;
    teamName?: string;
    context?: ContextInput;
}
interface VibecontrolsForkGitHubRepoInput {
    repoName: string;
    scope: VibecontrolsGitHubRepoScope;
    orgName?: string;
    sourceRepoUrl?: string;
    description?: string;
    connectionId?: string;
    token?: string;
}
interface VibecontrolsForkRepoResult {
    isForked: boolean;
    repoFullName: string;
    repoUrl: string;
}
interface VibecontrolsTemplate {
    id: string;
    name: string;
    description?: string | null;
    category: VibecontrolsTemplateCategory;
    status: VibecontrolsTemplateStatus;
    version?: string | null;
    setupInstructions?: string | null;
    sourceRepositoryUrl?: string | null;
    fileTree?: Json;
    variables?: Json;
    componentSnapshot?: Json;
    cloneCount: number;
    tags: string[];
    metadata?: Json;
    createdAt: string;
    updatedAt: string;
}
interface VibecontrolsTemplateList {
    items: VibecontrolsTemplate[];
    total: number;
    hasMore: boolean;
}
interface VibecontrolsTemplateFilterInput {
    search?: string;
    tags?: string[];
    category?: VibecontrolsTemplateCategory;
    status?: VibecontrolsTemplateStatus;
}
interface VibecontrolsPublishTemplateInput {
    name: string;
    description?: string;
    category?: VibecontrolsTemplateCategory;
    version?: string;
    setupInstructions?: string;
    sourceRepositoryUrl?: string;
    fileTree?: Json;
    variables?: Json;
    tags?: string[];
    metadata?: Json;
    context?: ContextInput;
}
interface VibecontrolsUpdateTemplateInput {
    name?: string;
    description?: string;
    category?: VibecontrolsTemplateCategory;
    status?: VibecontrolsTemplateStatus;
    version?: string;
    setupInstructions?: string;
    sourceRepositoryUrl?: string;
    fileTree?: Json;
    variables?: Json;
    tags?: string[];
    metadata?: Json;
}
interface VibecontrolsCloneTemplateInput {
    name: string;
    description?: string;
    workspaceId?: string;
    variableValues?: Json;
    metadata?: Json;
    context?: ContextInput;
}
interface VibecontrolsScorecardMetric {
    id: string;
    name: string;
    description?: string | null;
    type: ScorecardMetricType;
    status: ScorecardMetricStatus;
    value?: number | null;
    threshold?: number | null;
    unit?: string | null;
    iframeUrl?: string | null;
    iframeHeight?: number | null;
    lastUpdatedAt?: string | null;
    createdAt: string;
    updatedAt: string;
}
interface VibecontrolsScorecard {
    id: string;
    ownerId: string;
    ownerType: ScorecardOwnerType;
    overallScore?: number | null;
    lastEvaluatedAt?: string | null;
    metrics: VibecontrolsScorecardMetric[];
    metadata?: Json;
    workspaceId: string;
    createdAt: string;
    updatedAt: string;
}
interface UpsertScorecardInput {
    ownerId: string;
    ownerType: ScorecardOwnerType;
    metadata?: Json;
    context?: ContextInput;
}
interface AddScorecardMetricInput {
    name: string;
    description?: string;
    type?: ScorecardMetricType;
    status?: ScorecardMetricStatus;
    value?: number;
    threshold?: number;
    unit?: string;
    iframeUrl?: string;
    iframeHeight?: number;
    metadata?: Json;
    context?: ContextInput;
}
interface UpdateScorecardMetricInput {
    name?: string;
    description?: string;
    type?: ScorecardMetricType;
    status?: ScorecardMetricStatus;
    value?: number;
    threshold?: number;
    unit?: string;
    iframeUrl?: string;
    iframeHeight?: number;
    metadata?: Json;
}
type SessionSharePermission = 'VIEW' | 'INTERACT';
type ShareStatus = 'ACTIVE' | 'EXPIRED' | 'PENDING' | 'REVOKED';
type CollaboratorRole = 'OWNER' | 'EDITOR' | 'VIEWER';
type SessionExportFormat = 'CSV' | 'JSON';
interface SessionShare {
    id: string;
    sessionId: string;
    sharedWithId: string;
    permission: SessionSharePermission;
    status: ShareStatus;
    message?: string | null;
    createdBy: string;
    createdAt: string;
    expiresAt?: string | null;
    lastAccessAt?: string | null;
    accessCount: number;
    revokedAt?: string | null;
    revokedBy?: string | null;
}
interface SessionShareLink {
    id: string;
    sessionId: string;
    token: string;
    shareUrl: string;
    name?: string | null;
    permission: SessionSharePermission;
    status: ShareStatus;
    hasPassword: boolean;
    maxUses?: number | null;
    useCount: number;
    expiresAt: string;
    lastUsedAt?: string | null;
    createdBy: string;
    createdAt: string;
}
interface SessionCollaborator {
    id: string;
    sessionId: string;
    userId: string;
    username?: string | null;
    avatarUrl?: string | null;
    role: CollaboratorRole;
    hasControl: boolean;
    joinedAt: string;
    lastActiveAt: string;
}
interface ShareSessionInput {
    sessionId: string;
    sharedWithEmail: string;
    permission?: SessionSharePermission;
    message?: string;
    expiresAt?: string;
}
interface CreateSessionShareLinkInput {
    sessionId: string;
    permission?: SessionSharePermission;
    name?: string;
    password?: string;
    maxUses?: number;
    expiresInHours?: number;
}
interface UpdateSessionShareInput {
    permission?: SessionSharePermission;
    expiresAt?: string;
}
interface SharedWithMeFilterInput {
    permission?: SessionSharePermission;
    status?: ShareStatus;
}
interface SessionShareEdge {
    cursor: string;
    node: SessionShare;
}
interface SessionShareConnection {
    edges: SessionShareEdge[];
    totalCount: number;
    pageInfo: {
        hasNextPage: boolean;
        hasPreviousPage: boolean;
        startCursor?: string | null;
        endCursor?: string | null;
    };
}
interface JoinSessionInput {
    shareId?: string;
    shareToken?: string;
    password?: string;
}
interface BulkSessionResult {
    succeeded: number;
    failed: number;
    errors: string[];
}
interface TerminalResult {
    connectionId: string;
    sessionId: string;
    status: string;
    host?: string | null;
    localPort?: number | null;
    remotePort?: number | null;
    ttydUrl?: string | null;
}
interface SessionExportInput {
    filter?: SessionFilterInput;
    format?: SessionExportFormat;
}
interface SessionExport {
    count: number;
    data: string;
    format: SessionExportFormat;
    generatedAt: string;
}
type AiPromptCategory = 'CODING' | 'CUSTOM' | 'DEBUGGING' | 'DEPLOYMENT' | 'DOCUMENTATION' | 'GENERAL' | 'REVIEW' | 'RUNBOOK' | 'TESTING';
type AiPromptStatus = 'ACTIVE' | 'ARCHIVED' | 'DRAFT';
interface AiPrompt {
    id: string;
    name: string;
    description?: string | null;
    content: string;
    category: AiPromptCategory;
    status: AiPromptStatus;
    isShared: boolean;
    tags: string[];
    variables?: Json;
    metadata?: Json;
    context?: OperationContext | null;
    createdBy: string;
    onBehalfOf: string;
    updatedBy?: string | null;
    workspaceId: string;
    usageCount: number;
    lastUsedAt?: string | null;
    createdAt: string;
    updatedAt: string;
    deletedAt?: string | null;
}
interface AiPromptList {
    items: AiPrompt[];
    total: number;
    hasMore: boolean;
}
interface AIPromptFilterInput {
    category?: AiPromptCategory;
    status?: AiPromptStatus;
    createdBy?: string;
    isShared?: boolean;
    search?: string;
    tags?: string[];
    workspaceId?: string;
}
interface CreateAIPromptInput {
    name: string;
    content: string;
    description?: string;
    category?: AiPromptCategory;
    status?: AiPromptStatus;
    isShared?: boolean;
    tags?: string[];
    variables?: Json;
    metadata?: Json;
    context?: ContextInput;
}
interface UpdateAIPromptInput {
    name?: string;
    content?: string;
    description?: string;
    category?: AiPromptCategory;
    status?: AiPromptStatus;
    isShared?: boolean;
    tags?: string[];
    variables?: Json;
    metadata?: Json;
    context?: ContextInput;
}
interface AIPromptRenderResult {
    promptId: string;
    rendered: string;
}
type VibeDeckSharePermission = 'EXECUTE' | 'VIEW';
type VibeDeckShareStatus = 'ACTIVE' | 'EXPIRED' | 'REVOKED';
type VibeDeckShareVisibility = 'PUBLIC' | 'RESTRICTED' | 'SIGNED_LINK';
type VibeDeckButtonActionType = string;
interface VibeDeckShareLink {
    id: string;
    vibeDeckId: string;
    token: string;
    shareUrl: string;
    name?: string | null;
    permission: VibeDeckSharePermission;
    status: VibeDeckShareStatus;
    visibility: VibeDeckShareVisibility;
    hasPassword: boolean;
    allowIframe: boolean;
    maxUses?: number | null;
    useCount: number;
    expiresAt?: string | null;
    lastUsedAt?: string | null;
    createdBy: string;
    createdAt: string;
}
interface CreateVibeDeckShareLinkInput {
    vibeDeckId: string;
    permission?: VibeDeckSharePermission;
    visibility?: VibeDeckShareVisibility;
    name?: string;
    password?: string;
    maxUses?: number;
    expiresInHours?: number;
    allowIframe?: boolean;
}
interface UpdateVibeDeckShareLinkInput {
    permission?: VibeDeckSharePermission;
    visibility?: VibeDeckShareVisibility;
    name?: string;
    password?: string;
    maxUses?: number;
    expiresAt?: string;
    allowIframe?: boolean;
}
interface VibeDeckShareLinkValidation {
    isValid: boolean;
    error?: string | null;
    requiresPassword: boolean;
    permission?: VibeDeckSharePermission | null;
    allowIframe?: boolean | null;
    expiresAt?: string | null;
    vibeDeckId?: string | null;
    vibeDeckName?: string | null;
    ownerName?: string | null;
}
interface SharedVibeDeckButton {
    id: string;
    label: string;
    actionType: VibeDeckButtonActionType;
    row: number;
    column: number;
    rowSpan: number;
    colSpan: number;
    icon?: string | null;
    color?: string | null;
    category?: string | null;
    confirmationRequired: boolean;
}
interface SharedVibeDeck {
    id: string;
    name: string;
    description?: string | null;
    icon?: string | null;
    buttonSize?: string | null;
    colorTheme?: string | null;
    gridColumns: number;
    gridRows: number;
    permission: VibeDeckSharePermission;
    buttons: SharedVibeDeckButton[];
}
interface VibeDeckButtonExecution {
    success: boolean;
    output?: string | null;
    error?: string | null;
}

interface ActionsApi {
    list(filter?: ActionFilterInput, pagination?: PaginationInput): Promise<ActionList>;
    get(id: string): Promise<Action>;
    create(input: CreateActionInput): Promise<Action>;
    update(id: string, input: UpdateActionInput): Promise<Action>;
    delete(id: string): Promise<boolean>;
    duplicate(id: string, name?: string): Promise<Action>;
    execute(id: string, input?: ExecuteActionInput): Promise<ActionExecution>;
    installFromStore(storeItemId: string, version?: string, name?: string): Promise<Action>;
    listExecutions(filter?: ActionExecutionFilterInput, pagination?: PaginationInput): Promise<ActionExecutionList>;
    getExecution(id: string): Promise<ActionExecution>;
    cancelExecution(id: string): Promise<ActionExecution>;
    scheduleAction(actionId: string, config: ScheduleConfig): Promise<ScheduledJobSummary>;
    unscheduleAction(scheduledJobId: string): Promise<boolean>;
    listSchedules(filter?: {
        actionId?: string;
    }, pagination?: PaginationInput): Promise<ScheduledJobList>;
    aiPrompts: {
        list(filter?: AIPromptFilterInput, pagination?: PaginationInput): Promise<AiPromptList>;
        get(id: string): Promise<AiPrompt | null>;
        create(input: CreateAIPromptInput): Promise<AiPrompt>;
        update(id: string, input: UpdateAIPromptInput): Promise<AiPrompt>;
        delete(id: string): Promise<boolean>;
        duplicate(id: string, name: string): Promise<AiPrompt>;
        render(id: string, variables?: Json): Promise<AIPromptRenderResult>;
        recordUsage(id: string): Promise<AiPrompt>;
    };
}

interface AgentsApi {
    list(filter?: VibecontrolsAgentFilterInput): Promise<VibecontrolsAgentList>;
    get(id: string): Promise<VibecontrolsAgent>;
    create(input: CreateVibecontrolsAgentInput): Promise<VibecontrolsAgent>;
    register(input: CreateVibecontrolsAgentInput): Promise<VibecontrolsAgent>;
    update(id: string, input: UpdateVibecontrolsAgentInput): Promise<VibecontrolsAgent>;
    delete(id: string): Promise<boolean>;
    deactivate(id: string): Promise<VibecontrolsAgent>;
    heartbeat(id: string): Promise<VibecontrolsAgent>;
    healthProbes(): Promise<AgentHealthProbeResult[]>;
    probeConnection(id: string): Promise<AgentProbeResult>;
    probeTunnel(url: string, agentApiKey?: string): Promise<AgentProbeResult>;
    listPlugins(agentId: string): Promise<AgentPluginListResult>;
    installPlugin(agentId: string, packageName: string): Promise<AgentPluginActionResult>;
    removePlugin(agentId: string, packageName: string): Promise<AgentPluginActionResult>;
    pushGatewayAuth(input: PushAgentGatewayAuthInput): Promise<boolean>;
}

interface AiToolEventsApi {
    list(filter?: AiToolEventFilterInput, pagination?: PaginationInput): Promise<AiToolEventList>;
    get(id: string): Promise<AiToolEvent>;
    recent(agentId: string, limit?: number): Promise<AiToolEvent[]>;
    create(input: CreateAiToolEventInput): Promise<AiToolEvent>;
    deleteOld(beforeDate: string): Promise<number>;
}

interface AnalyticsApi {
    get(input: VibecontrolsAnalyticsInput): Promise<VibecontrolsAnalyticsResult>;
    getOverview(input?: Partial<VibecontrolsAnalyticsInput>): Promise<VibecontrolsAnalyticsResult>;
    getForEntities(entityTypes: VibecontrolsAnalyticsInput['entityTypes'], input?: Partial<VibecontrolsAnalyticsInput>): Promise<VibecontrolsAnalyticsResult>;
}

interface AuditApi {
    list(filter?: VibeAuditLogFilterInput, pagination?: PaginationInput): Promise<VibeAuditLogList>;
    get(id: string): Promise<VibeAuditLog>;
    stats(filter?: VibeAuditLogFilterInput): Promise<VibeAuditLogStats>;
    delete(id: string, reason?: string): Promise<boolean>;
    bulkDelete(ids: string[], reason?: string): Promise<boolean>;
    export(filter?: VibeAuditLogFilterInput, format?: string): Promise<string>;
}

interface CatalogsApi {
    list(filter?: CatalogFilterInput, pagination?: PaginationInput): Promise<VibecontrolsCatalogList>;
    get(id: string): Promise<VibecontrolsCatalog | null>;
    dependencyGraph(catalogId: string): Promise<VibecontrolsDependencyGraph>;
    sbom(catalogId: string): Promise<VibecontrolsSBOM>;
    create(input: CreateCatalogInput): Promise<VibecontrolsCatalog>;
    update(id: string, input: UpdateCatalogInput): Promise<VibecontrolsCatalog>;
    delete(id: string): Promise<boolean>;
    addComponent(catalogId: string, componentId: string): Promise<VibecontrolsCatalogComponent>;
    removeComponent(catalogId: string, componentId: string): Promise<boolean>;
    addVibe(catalogId: string, vibeId: string): Promise<VibecontrolsCatalogVibe>;
    removeVibe(catalogId: string, vibeId: string): Promise<boolean>;
}

interface ComponentsApi {
    list(filter?: ComponentFilterInput, pagination?: PaginationInput): Promise<VibecontrolsComponentList>;
    get(id: string): Promise<VibecontrolsComponent | null>;
    create(input: CreateComponentInput): Promise<VibecontrolsComponent>;
    update(id: string, input: UpdateComponentInput): Promise<VibecontrolsComponent>;
    delete(id: string): Promise<boolean>;
    forkGitHubRepo(input: VibecontrolsForkGitHubRepoInput): Promise<VibecontrolsForkRepoResult>;
    publishAsTemplate(componentId: string, input: VibecontrolsPublishTemplateInput): Promise<VibecontrolsTemplate>;
}

interface SecurityApi {
    providers(): Promise<SecurityProvider[]>;
    scan(id: string): Promise<SecurityScanRun | null>;
    myScans(filter?: SecurityScanFilterInput, pagination?: SecurityPaginationInput): Promise<SecurityScanRunList>;
    allScans(filter?: SecurityScanFilterInput, pagination?: SecurityPaginationInput): Promise<SecurityScanRunList>;
    findings(filter?: SecurityFindingFilterInput, pagination?: SecurityPaginationInput): Promise<SecurityFindingList>;
    policyDecision(scanRunId: string): Promise<SecurityPolicyDecision>;
    status(vibeId: string): Promise<SecurityStatus>;
    repositoryConfig(vibeId: string): Promise<RepositorySecurityConfig | null>;
    runScan(vibeId: string, stage: SecurityStage): Promise<SecurityScanRun>;
    cancelScan(id: string): Promise<SecurityScanRun>;
    createException(input: CreateSecurityExceptionInput): Promise<SecurityException>;
    revokeException(id: string): Promise<boolean>;
    pushScanRun(input: PushSecurityScanRunInput): Promise<SecurityScanRun>;
    setProvider(input: SetSecurityProviderInput): Promise<SecurityProvider>;
    updateFindingStatus(id: string, status: SecurityFindingStatus): Promise<SecurityFinding>;
    updateRepositoryConfig(vibeId: string, input: UpdateRepositorySecurityConfigInput): Promise<RepositorySecurityConfig>;
    presignEvidence(scanRunId: string, sha256: string, sizeBytes: number, type: SecurityEvidenceType): Promise<SecurityEvidencePresign>;
}

interface CIApi {
    getStatus(providerId: string, agentId: string, limit?: number): Promise<CIStatus | null>;
    getPipelineRuns(providerId: string, agentId: string, options?: {
        branch?: string;
        limit?: number;
    }): Promise<CIPipelineRun[]>;
    getPipelineDetails(providerId: string, agentId: string, runId: string): Promise<CIPipelineDetails | null>;
    getRepoStats(providerId: string, agentId: string): Promise<RepoStats | null>;
    refreshStatus(providerId: string, agentId: string): Promise<CIStatus>;
    refreshRepoStats(providerId: string, agentId: string): Promise<RepoStats>;
}

interface GitopsApi {
    list(filter?: GitopsProviderFilterInput, pagination?: PaginationInput): Promise<GitopsProviderList>;
    get(id: string): Promise<GitopsProvider | null>;
    create(input: CreateGitopsProviderInput): Promise<GitopsProvider>;
    update(id: string, input: UpdateGitopsProviderInput): Promise<GitopsProvider>;
    delete(id: string): Promise<boolean>;
}

interface SettingsApi {
    mine(): Promise<SettingsBundle>;
    mineByCategory(category: SettingsCategory): Promise<Json>;
    listSecrets(): Promise<SettingsSecret[]>;
    setSecret(input: SetSettingsSecretInput): Promise<SettingsSecret>;
    deleteSecret(key: string): Promise<boolean>;
    reset(category: SettingsCategory): Promise<boolean>;
    updatePreferences(input: UpdatePreferencesInput): Promise<UserPreferences>;
    updateNotificationPreferences(input: UpdateNotificationPreferencesInput): Promise<NotificationPreferences>;
    updateWorkspaceDefaults(input: UpdateWorkspaceDefaultsInput): Promise<WorkspaceDefaults>;
    resolveIntegrationToken(connectionId: string): Promise<VibecontrolsIntegrationTokenResult>;
}

interface ConfigurationApi {
    list(filter: ConfigurationFilterInput, pagination?: PaginationInput): Promise<ConfigurationList>;
    get(key: string, scope: ConfigScope, scopeId?: string): Promise<Configuration>;
    getValue(key: string, scope: ConfigScope, scopeId?: string): Promise<Json>;
    byScope(scope: ConfigScope, scopeId?: string): Promise<Configuration[]>;
    set(key: string, scope: ConfigScope, value: Json, options?: {
        scopeId?: string;
        isSecret?: boolean;
        context?: ConfigurationInput['context'];
    }): Promise<Configuration>;
    delete(key: string, scope: ConfigScope, scopeId?: string): Promise<boolean>;
    bulkSet(configs: ConfigurationInput[]): Promise<Configuration[]>;
    bulkDelete(keys: string[], scope: ConfigScope, scopeId?: string): Promise<number>;
    security: SecurityApi;
    ci: CIApi;
    gitops: GitopsApi;
    settings: SettingsApi;
}

interface DocsApi {
    getSite(vibeId: string): Promise<VibecontrolsDocsSite>;
    listSites(filter?: DocsSiteFilterInput, pagination?: PaginationInput): Promise<DocsSiteList>;
    createSite(input: CreateDocsSiteInput): Promise<VibecontrolsDocsSite>;
    updateSite(id: string, input: UpdateDocsSiteInput): Promise<VibecontrolsDocsSite>;
    updateSiteVisibility(id: string, visibility: DocsVisibility): Promise<VibecontrolsDocsSite>;
    deleteSite(id: string): Promise<boolean>;
    getPage(id: string): Promise<VibecontrolsDocsPage>;
    listPages(siteId: string, filter?: DocsPageFilterInput): Promise<VibecontrolsDocsPage[]>;
    createPage(input: CreateDocsPageInput): Promise<VibecontrolsDocsPage>;
    updatePage(id: string, input: UpdateDocsPageInput): Promise<VibecontrolsDocsPage>;
    deletePage(id: string): Promise<boolean>;
    reorderPages(siteId: string, orders: DocsPageOrderInput[]): Promise<boolean>;
    getRevision(id: string): Promise<VibecontrolsDocsRevision>;
    listRevisions(siteId: string, pagination?: PaginationInput): Promise<DocsRevisionList>;
    compileSite(siteId: string): Promise<VibecontrolsDocsRevision>;
    publishRevision(revisionId: string): Promise<VibecontrolsDocsRevision>;
    rollbackRevision(siteId: string, revisionNumber: number): Promise<VibecontrolsDocsRevision>;
    getContent(siteId: string, path: string): Promise<string>;
    generateSignedUrl(siteId: string): Promise<string>;
}

interface NotesApi {
    list(filter?: VibecontrolsNoteFilterInput, pagination?: PaginationInput): Promise<VibecontrolsNoteList>;
    get(id: string): Promise<VibecontrolsNote>;
    search(query: string, vibeId?: string, limit?: number): Promise<VibecontrolsNote[]>;
    byTags(tags: string[], vibeId?: string): Promise<VibecontrolsNote[]>;
    pinned(vibeId?: string): Promise<VibecontrolsNote[]>;
    create(input: CreateVibecontrolsNoteInput): Promise<VibecontrolsNote>;
    update(id: string, input: UpdateVibecontrolsNoteInput): Promise<VibecontrolsNote>;
    delete(id: string): Promise<boolean>;
    pin(id: string): Promise<VibecontrolsNote>;
    unpin(id: string): Promise<VibecontrolsNote>;
    bulkDelete(ids: string[]): Promise<number>;
}

interface SandboxesApi {
    list(filter: SandboxFilterInput | undefined, pagination: SandboxPaginationInput | undefined, context: {
        workspaceId: string;
    }): Promise<SandboxList>;
    get(id: string, context: {
        workspaceId: string;
    }): Promise<Sandbox | null>;
    create(input: CreateSandboxInput): Promise<Sandbox>;
    delete(id: string, context: {
        workspaceId: string;
    }): Promise<boolean>;
    start(id: string, context: {
        workspaceId: string;
    }): Promise<Sandbox>;
    stop(id: string, context: {
        workspaceId: string;
    }): Promise<Sandbox>;
    extendTTL(id: string, additionalSeconds: number, context: {
        workspaceId: string;
    }): Promise<Sandbox>;
    getLogs(id: string, containerName: string, context: {
        workspaceId: string;
    }, tailLines?: number): Promise<string>;
    getStats(context: {
        workspaceId: string;
    }): Promise<SandboxStats>;
    getConfig(context: {
        workspaceId: string;
    }): Promise<SandboxConfig>;
    updateConfig(input: UpdateSandboxConfigInput): Promise<SandboxConfig>;
    listTemplates(context: {
        workspaceId: string;
    }, template?: SandboxTemplate, pagination?: SandboxPaginationInput): Promise<SandboxTemplateConfigList>;
    getTemplate(id: string, context: {
        workspaceId: string;
    }): Promise<SandboxTemplateConfig | null>;
    createTemplate(input: CreateSandboxTemplateInput): Promise<SandboxTemplateConfig>;
    updateTemplate(input: UpdateSandboxTemplateInput): Promise<SandboxTemplateConfig>;
    deleteTemplate(id: string, context: {
        workspaceId: string;
    }): Promise<boolean>;
    availableTags(query?: string, limit?: number): Promise<SandboxAvailableTag[]>;
    getTags(input: GetSandboxTagsInput): Promise<SandboxTagAssignment[]>;
    createTag(input: CreateSandboxTagInput): Promise<SandboxAvailableTag>;
    tag(input: TagSandboxInput): Promise<SandboxTagAssignment>;
    untag(input: UntagSandboxInput): Promise<boolean>;
    replaceTags(input: ReplaceSandboxTagsInput): Promise<SandboxTagAssignment[]>;
    listAll(context: {
        workspaceId: string;
    }, filter?: SandboxFilterInput, pagination?: SandboxPaginationInput): Promise<SandboxList>;
    listNodes(context: {
        workspaceId: string;
    }): Promise<SandboxNodeInfo[]>;
    getActive(context: {
        workspaceId: string;
    }): Promise<Sandbox[]>;
    getRecentActivity(context: {
        workspaceId: string;
    }, limit?: number): Promise<SandboxActivityList>;
    exportSandboxes(input: ExportSandboxesInput): Promise<SandboxExportJob>;
    getExportJob(workspaceId: string, jobId: string, context: {
        workspaceId: string;
    }): Promise<SandboxExportJob>;
    listExportJobs(workspaceId: string, context: {
        workspaceId: string;
    }, pagination?: SandboxPaginationInput): Promise<SandboxExportJob[]>;
    getArtifactBytes(input: SandboxArtifactBytesInput): Promise<SandboxArtifactBytes>;
    proxyRequest(input: ProxySandboxRequestInput): Promise<ProxySandboxResponse>;
}

interface ScorecardsApi {
    get(ownerId: string, ownerType: ScorecardOwnerType): Promise<VibecontrolsScorecard | null>;
    upsert(input: UpsertScorecardInput): Promise<VibecontrolsScorecard>;
    addMetric(scorecardId: string, input: AddScorecardMetricInput): Promise<VibecontrolsScorecardMetric>;
    updateMetric(id: string, input: UpdateScorecardMetricInput): Promise<VibecontrolsScorecardMetric>;
    removeMetric(id: string): Promise<boolean>;
}

interface SessionsApi {
    list(filter?: SessionFilterInput, pagination?: PaginationInput): Promise<SessionList>;
    get(id: string): Promise<Session>;
    create(input: CreateSessionInput): Promise<Session>;
    update(id: string, input: UpdateSessionInput): Promise<Session>;
    delete(id: string): Promise<boolean>;
    updateStatus(id: string, status: VibecontrolsSessionStatus): Promise<Session>;
    start(id: string): Promise<Session>;
    stop(id: string): Promise<Session>;
    kill(id: string): Promise<boolean>;
    share(input: ShareSessionInput): Promise<SessionShare>;
    updateShare(id: string, input: UpdateSessionShareInput): Promise<SessionShare>;
    revokeShare(id: string): Promise<SessionShare>;
    createShareLink(input: CreateSessionShareLinkInput): Promise<SessionShareLink>;
    revokeShareLink(id: string): Promise<SessionShareLink>;
    listShares(sessionId: string): Promise<SessionShare[]>;
    listShareLinks(sessionId: string): Promise<SessionShareLink[]>;
    listCollaborators(sessionId: string): Promise<SessionCollaborator[]>;
    sharedWithMe(filter?: SharedWithMeFilterInput, pagination?: PaginationInput): Promise<SessionShareConnection>;
    join(input: JoinSessionInput): Promise<SessionCollaborator>;
    leave(sessionId: string): Promise<boolean>;
    requestControl(sessionId: string): Promise<boolean>;
    releaseControl(sessionId: string): Promise<boolean>;
    transferControl(sessionId: string, toUserId: string): Promise<boolean>;
    startTerminal(id: string): Promise<Session>;
    stopTerminal(id: string): Promise<Session>;
    restartTerminal(id: string): Promise<Session>;
    startTargetTerminal(targetId: string, shell?: string): Promise<TerminalResult>;
    stopTargetTerminal(sessionId: string): Promise<boolean>;
    bulkRestart(ids: string[]): Promise<BulkSessionResult>;
    bulkStop(ids: string[]): Promise<BulkSessionResult>;
    bulkTerminate(ids: string[]): Promise<BulkSessionResult>;
    export(input: SessionExportInput): Promise<SessionExport>;
}

interface TargetsApi {
    list(workspaceId: string, filter?: TargetFilterInput, limit?: number, offset?: number): Promise<TargetList>;
    get(id: string): Promise<Target>;
    getAgentGraph(workspaceId: string, rootAgentId?: string): Promise<AgentGraph>;
    create(workspaceId: string, input: CreateTargetInput): Promise<Target>;
    update(id: string, input: UpdateTargetInput): Promise<Target>;
    delete(id: string): Promise<boolean>;
    test(id: string): Promise<TargetTestResult>;
    scanSSHConfig(agentId: string, configPath?: string): Promise<ImportTargetHostInput[]>;
    importFromConfig(agentId: string, hosts: ImportTargetHostInput[], workspaceId: string): Promise<Target[]>;
    installAgent(sourceAgentId: string, targetId: string, agentPort?: number): Promise<InstallResult>;
    uninstallAgent(targetId: string): Promise<InstallResult>;
    startTerminal(targetId: string, shell?: string): Promise<TerminalSession>;
    stopTerminal(sessionId: string): Promise<boolean>;
    connectAgent(sourceAgentId: string, targetId: string, protocol: string): Promise<AgentConnection>;
    disconnectAgent(connectionId: string): Promise<boolean>;
    updateConnectionPermissions(connectionId: string, input: UpdateConnectionPermissionsInput): Promise<AgentConnection>;
    generateGraphContextUrl(workspaceId: string, expiresInMinutes?: number): Promise<string>;
}

interface TemplatesApi {
    list(filter?: VibecontrolsTemplateFilterInput, pagination?: PaginationInput): Promise<VibecontrolsTemplateList>;
    get(id: string): Promise<VibecontrolsTemplate | null>;
    update(id: string, input: VibecontrolsUpdateTemplateInput): Promise<VibecontrolsTemplate>;
    delete(id: string): Promise<boolean>;
    instantiate(templateId: string, input: VibecontrolsCloneTemplateInput): Promise<VibecontrolsComponent>;
}

interface TunnelsApi {
    list(filter?: TunnelFilterInput, pagination?: PaginationInput): Promise<TunnelList>;
    get(id: string): Promise<Tunnel | null>;
    bySlug(slug: string): Promise<Tunnel | null>;
    create(input: CreateTunnelInput): Promise<Tunnel>;
    update(id: string, input: UpdateTunnelInput): Promise<Tunnel>;
    delete(id: string): Promise<boolean>;
    start(id: string): Promise<Tunnel>;
    stop(id: string): Promise<Tunnel>;
    rotateCredentials(id: string): Promise<Tunnel>;
    issueSession(tunnelId: string, ttlSeconds?: number): Promise<TunnelSessionIssueResult>;
    revokeSession(sessionId: string, reason?: string): Promise<boolean>;
    listSessions(tunnelId: string, pagination?: PaginationInput): Promise<TunnelSessionList>;
    providers(): Promise<TunnelProvider[]>;
    provider(key: TunnelProviderKey): Promise<TunnelProvider | null>;
    shards(environment?: TunnelEnvironment): Promise<TunnelShard[]>;
    usage(tunnelId: string, from: string, to: string): Promise<TunnelUsageBucket[]>;
    audit(tunnelId: string, pagination?: PaginationInput): Promise<VibeAuditLogList>;
    listDomains(tunnelId?: string, filter?: TunnelDomainFilterInput, pagination?: PaginationInput): Promise<TunnelDomainList>;
    getDomain(id: string): Promise<TunnelDomain | null>;
    reserveSubdomain(input: ReserveTunnelSubdomainInput): Promise<TunnelDomain>;
    registerCustomDomain(input: RegisterCustomDomainInput): Promise<TunnelDomain>;
    verifyDomain(domainId: string): Promise<TunnelDomain>;
    attachDomain(tunnelId: string, domainId: string, makePrimary?: boolean): Promise<Tunnel>;
    detachDomain(tunnelId: string, domainId: string): Promise<Tunnel>;
    deleteDomain(domainId: string): Promise<boolean>;
    probeAgent(url: string, agentApiKey?: string): Promise<AgentProbeResult>;
    addAgentFromTunnel(input: AddAgentFromTunnelInput): Promise<AddAgentFromTunnelResult>;
    listAgentTunnels(): Promise<AgentTunnelListResult>;
    createAgentTunnel(input: CreateAgentTunnelInput): Promise<AgentTunnel>;
    stopAgentTunnel(agentId: string, tunnelId: string): Promise<boolean>;
    deleteAgentTunnel(agentId: string, tunnelId: string): Promise<boolean>;
}

interface UiSessionApi {
    getCurrent(): Promise<UISession>;
    getById(id: string): Promise<UISession>;
    save(input: SaveUISessionInput): Promise<UISession>;
    clear(): Promise<boolean>;
    updateActiveVibe(vibeId?: string): Promise<UISession>;
    updateActiveSession(sessionId?: string): Promise<UISession>;
    addRecentVibe(vibeId: string): Promise<UISession>;
    addRecentSession(sessionId: string): Promise<UISession>;
}

interface VibeDecksApi {
    list(filter?: VibeDeckFilterInput, pagination?: PaginationInput): Promise<VibeDeckList>;
    get(id: string): Promise<VibeDeck>;
    getDefault(): Promise<VibeDeck>;
    create(input: CreateVibeDeckInput): Promise<VibeDeck>;
    update(id: string, input: UpdateVibeDeckInput): Promise<VibeDeck>;
    delete(id: string): Promise<boolean>;
    setDefault(id: string): Promise<VibeDeck>;
    duplicate(id: string): Promise<VibeDeck>;
    listButtons(filter?: VibeDeckButtonFilterInput, pagination?: PaginationInput): Promise<VibeDeckButtonList>;
    getButton(id: string): Promise<VibeDeckButton>;
    createButton(input: CreateVibeDeckButtonInput): Promise<VibeDeckButton>;
    updateButton(id: string, input: UpdateVibeDeckButtonInput): Promise<VibeDeckButton>;
    deleteButton(id: string): Promise<boolean>;
    moveButton(id: string, input: MoveVibeDeckButtonInput): Promise<VibeDeckButton>;
    reorderButtons(vibeDeckId: string, positions: VibeDeckButtonPositionInput[]): Promise<boolean>;
    executeButton(id: string): Promise<VibeDeckButtonExecutionResult>;
    shareLinks: {
        list(vibeDeckId: string): Promise<VibeDeckShareLink[]>;
        create(input: CreateVibeDeckShareLinkInput): Promise<VibeDeckShareLink>;
        update(id: string, input: UpdateVibeDeckShareLinkInput): Promise<VibeDeckShareLink>;
        revoke(id: string): Promise<VibeDeckShareLink>;
        validate(token: string): Promise<VibeDeckShareLinkValidation>;
        getShared(token: string, password?: string): Promise<SharedVibeDeck | null>;
        executeSharedButton(token: string, buttonId: string, password?: string): Promise<VibeDeckButtonExecution>;
    };
}

interface VibesApi {
    list(filter?: VibeFilterInput, pagination?: PaginationInput): Promise<VibeList>;
    get(id: string): Promise<Vibe>;
    create(input: CreateVibeInput): Promise<Vibe>;
    update(id: string, input: UpdateVibeInput): Promise<Vibe>;
    delete(id: string): Promise<boolean>;
    updateStatus(id: string, status: VibeStatus): Promise<Vibe>;
    archive(id: string): Promise<Vibe>;
    restore(id: string): Promise<Vibe>;
    move(id: string, newParentId?: string): Promise<Vibe>;
    hierarchy(rootId?: string): Promise<Vibe[]>;
    search(query: string, limit?: number): Promise<Vibe[]>;
    updateGit(id: string, gitData: {
        gitBranch?: string;
        gitRemote?: string;
        gitStatus?: Json;
    }): Promise<Vibe>;
}

interface WebhookDeliveryList {
    items: WebhookDelivery[];
    total: number;
    hasMore: boolean;
}
interface WebhooksApi {
    list(filter?: WebhookFilterInput, pagination?: PaginationInput): Promise<WebhookList>;
    get(id: string): Promise<Webhook>;
    byEvent(event: string): Promise<Webhook[]>;
    active(): Promise<Webhook[]>;
    create(input: CreateWebhookInput): Promise<Webhook>;
    update(id: string, input: UpdateWebhookInput): Promise<Webhook>;
    delete(id: string): Promise<boolean>;
    testDelivery(id: string): Promise<WebhookDelivery>;
    trigger(id: string, payload: Json): Promise<WebhookDelivery>;
    resetFailures(id: string): Promise<Webhook>;
    listDeliveries(webhookId: string, pagination?: PaginationInput): Promise<WebhookDeliveryList>;
}

interface VibecontrolsApi {
    vibes: VibesApi;
    sessions: SessionsApi;
    agents: AgentsApi;
    notes: NotesApi;
    targets: TargetsApi;
    tunnels: TunnelsApi;
    vibeDecks: VibeDecksApi;
    actions: ActionsApi;
    audit: AuditApi;
    analytics: AnalyticsApi;
    uiSession: UiSessionApi;
    configuration: ConfigurationApi;
    sandboxes: SandboxesApi;
    docs: DocsApi;
    aiToolEvents: AiToolEventsApi;
    webhooks: WebhooksApi;
    catalogs: CatalogsApi;
    components: ComponentsApi;
    templates: TemplatesApi;
    scorecards: ScorecardsApi;
}
declare const vibecontrolsModule: SdkModule<VibecontrolsApi>;

export { type Action, type ActionExecution, type ActionExecutionFilterInput, type ActionExecutionList, type ActionFilterInput, type ActionList, type ActionsApi, type AddAgentFromTunnelInput, type AddAgentFromTunnelResult, type AddScorecardMetricInput, type AgentTunnel, type AgentTunnelListResult, type AgentsApi, type AiToolEvent, type AiToolEventFilterInput, type AiToolEventList, type AiToolEventsApi, type AnalyticsApi, type AnalyticsBreakdownBucket, type AnalyticsEntityType, type AnalyticsGranularity, type AnalyticsTimeSeriesPoint, type AuditApi, type CIPipelineDetails, type CIPipelineJob, type CIPipelineRun, type CIStatus, type CIWorkflow, type CatalogFilterInput, type CatalogVisibility, type CatalogsApi, type CommitActivity, type ComponentFilterInput, type ComponentLifecycle, type ComponentType, type ComponentsApi, type ConfigScope, type Configuration, type ConfigurationApi, type ConfigurationFilterInput, type ConfigurationInput, type ConfigurationList, type ContextInput, type Contributor, type CreateActionInput, type CreateAgentTunnelInput, type CreateAiToolEventInput, type CreateCatalogInput, type CreateComponentInput, type CreateDocsPageInput, type CreateDocsSiteInput, type CreateGitopsProviderInput, type CreateSandboxInput, type CreateSandboxTagInput, type CreateSandboxTemplateInput, type CreateSecurityExceptionInput, type CreateSessionInput, type CreateTargetInput, type CreateTunnelInput, type CreateVibeDeckButtonInput, type CreateVibeDeckInput, type CreateVibeInput, type CreateVibecontrolsAgentInput, type CreateVibecontrolsNoteInput, type CreateWebhookInput, type DocsApi, type DocsPageFilterInput, type DocsPageOrderInput, type DocsRevisionList, type DocsSiteFilterInput, type DocsSiteList, type DocsVisibility, type ExecuteActionInput, type ExportSandboxesInput, type GetSandboxTagsInput, type GitopsProvider, type GitopsProviderFilterInput, type GitopsProviderList, type GitopsProviderType, type MoveVibeDeckButtonInput, type NotesApi, type NotificationPreferences, type OperationContext, type ProxySandboxRequestInput, type ProxySandboxResponse, type PullRequestSummary, type PushSecurityFindingInput, type PushSecurityScanRunInput, type RegisterCustomDomainInput, type ReplaceSandboxTagsInput, type RepoStats, type RepositorySecurityConfig, type ReserveTunnelSubdomainInput, type Sandbox, type SandboxActivity, type SandboxActivityList, type SandboxArtifactBytes, type SandboxArtifactBytesInput, type SandboxAvailableTag, type SandboxChangeEvent, type SandboxChangeType, type SandboxConfig, type SandboxExportFormat, type SandboxExportJob, type SandboxExportJobStatus, type SandboxFilterInput, type SandboxList, type SandboxMode, type SandboxNodeInfo, type SandboxPaginationInput, type SandboxStats, type SandboxStatus, type SandboxTagAssignment, type SandboxTemplate, type SandboxTemplateConfig, type SandboxTemplateConfigList, type SandboxesApi, type SaveUISessionInput, type ScheduleConfig, type ScheduledJobList, type ScheduledJobSummary, type ScorecardMetricStatus, type ScorecardMetricType, type ScorecardOwnerType, type ScorecardsApi, type SecurityEvidence, type SecurityEvidencePresign, type SecurityEvidenceRefInput, type SecurityEvidenceType, type SecurityException, type SecurityFinding, type SecurityFindingCategory, type SecurityFindingFilterInput, type SecurityFindingList, type SecurityFindingStatus, type SecurityPaginationInput, type SecurityPolicyDecision, type SecurityPolicyLevel, type SecurityProvider, type SecurityScanConclusion, type SecurityScanFilterInput, type SecurityScanRun, type SecurityScanRunList, type SecurityScanStatus, type SecuritySettingsLite, type SecuritySeverity, type SecurityStage, type SecurityStatus, type SecuritySummary, type Session, type SessionFilterInput, type SessionList, type SessionsApi, type SetSecurityProviderInput, type SetSettingsSecretInput, type SettingsBundle, type SettingsCategory, type SettingsSecret, type StorageMode, type TagSandboxInput, type Target, type TargetFilterInput, type TargetList, type TargetsApi, type TemplatesApi, type TlsMode, type Tunnel, type TunnelDomain, type TunnelDomainFilterInput, type TunnelDomainList, type TunnelDomainType, type TunnelDomainVerificationStatus, type TunnelEnvironment, type TunnelFilterInput, type TunnelList, type TunnelProtocol, type TunnelProvider, type TunnelProviderCapabilities, type TunnelProviderKey, type TunnelSession, type TunnelSessionIssueResult, type TunnelSessionList, type TunnelSessionStatus, type TunnelShard, type TunnelShardStatus, type TunnelStatus, type TunnelUsageBucket, type TunnelsApi, type UISession, type UiSessionApi, type UntagSandboxInput, type UpdateActionInput, type UpdateCatalogInput, type UpdateComponentInput, type UpdateDocsPageInput, type UpdateDocsSiteInput, type UpdateGitopsProviderInput, type UpdateNotificationPreferencesInput, type UpdatePreferencesInput, type UpdateRepositorySecurityConfigInput, type UpdateSandboxConfigInput, type UpdateSandboxTemplateInput, type UpdateScorecardMetricInput, type UpdateSessionInput, type UpdateTargetInput, type UpdateTunnelInput, type UpdateVibeDeckButtonInput, type UpdateVibeDeckInput, type UpdateVibeInput, type UpdateVibecontrolsAgentInput, type UpdateVibecontrolsNoteInput, type UpdateWebhookInput, type UpdateWorkspaceDefaultsInput, type UpsertScorecardInput, type UserPreferences, type UserProfileLite, type Vibe, type VibeAuditLog, type VibeAuditLogFilterInput, type VibeAuditLogList, type VibeAuditLogStats, type VibeDeck, type VibeDeckButton, type VibeDeckButtonExecutionResult, type VibeDeckButtonFilterInput, type VibeDeckButtonList, type VibeDeckButtonPositionInput, type VibeDeckFilterInput, type VibeDeckList, type VibeDecksApi, type VibeFilterInput, type VibeList, type VibeStatus, type VibeType, type VibecontrolsAgent, type VibecontrolsAgentFilterInput, type VibecontrolsAgentList, type VibecontrolsAnalyticsInput, type VibecontrolsAnalyticsResult, type VibecontrolsApi, type VibecontrolsCatalog, type VibecontrolsCatalogComponent, type VibecontrolsCatalogList, type VibecontrolsCatalogVibe, type VibecontrolsCloneTemplateInput, type VibecontrolsComponent, type VibecontrolsComponentList, type VibecontrolsDependencyGraph, type VibecontrolsDependencyGraphEdge, type VibecontrolsDependencyGraphNode, type VibecontrolsDocsPage, type VibecontrolsDocsRevision, type VibecontrolsDocsSite, type VibecontrolsForkGitHubRepoInput, type VibecontrolsForkRepoResult, type VibecontrolsGitHubRepoScope, type VibecontrolsIntegrationToken, type VibecontrolsIntegrationTokenResult, type VibecontrolsNote, type VibecontrolsNoteFilterInput, type VibecontrolsNoteList, type VibecontrolsPublishTemplateInput, type VibecontrolsSBOM, type VibecontrolsSBOMEntry, type VibecontrolsScorecard, type VibecontrolsScorecardMetric, type VibecontrolsSessionStatus, type VibecontrolsSessionType, type VibecontrolsTemplate, type VibecontrolsTemplateCategory, type VibecontrolsTemplateFilterInput, type VibecontrolsTemplateList, type VibecontrolsTemplateStatus, type VibecontrolsUpdateTemplateInput, type VibesApi, type Webhook, type WebhookDelivery, type WebhookDeliveryList, type WebhookFilterInput, type WebhookList, type WebhooksApi, type WorkspaceDefaults, vibecontrolsModule as default };