@inferencesh/sdk 0.1.0

package/dist/types.d.ts

@@ -0,0 +1,3019 @@
+export interface ACL {
+    id: string;
+    created_at: string;
+    updated_at: string;
+    deleted_at?: string;
+    resource_id: string;
+    owner_id: string;
+    group_id?: string;
+    owner_read: boolean;
+    owner_write: boolean;
+    owner_exec: boolean;
+    group_read: boolean;
+    group_write: boolean;
+    group_exec: boolean;
+    other_read: boolean;
+    other_write: boolean;
+    other_exec: boolean;
+}
+/**
+ * Agent represents a configurable AI agent in the system
+ */
+export interface AgentApp {
+    id: string;
+    version_id: string;
+    variant: string;
+    app?: App;
+    description: string;
+}
+export interface AgentAppDTO {
+    id: string;
+    version_id: string;
+    variant: string;
+    app?: AppDTO;
+    description: string;
+}
+export interface SubAgent {
+    id: string;
+    version_id: string;
+    agent?: Agent;
+    description: string;
+}
+export interface SubAgentDTO {
+    id: string;
+    version_id: string;
+    agent?: AgentDTO;
+    description: string;
+}
+export interface Agent {
+    BaseModel: BaseModel;
+    PermissionModel: PermissionModel;
+    /**
+     * Basic info
+     */
+    name: string;
+    project_id?: string;
+    project?: Project;
+    version_id: string;
+    version?: AgentVersion;
+    is_active: boolean;
+}
+/**
+ * AgentDTO for API responses
+ */
+export interface AgentDTO {
+    id: string;
+    created_at: string;
+    updated_at: string;
+    deleted_at?: string;
+    user_id: string;
+    user?: UserRelationDTO;
+    acl?: ACL;
+    name: string;
+    project_id?: string;
+    project?: ProjectDTO;
+    version_id: string;
+    version?: AgentVersionDTO;
+    is_active: boolean;
+}
+export interface AgentVersion {
+    BaseModel: BaseModel;
+    PermissionModel: PermissionModel;
+    description: string;
+    system_prompt: string;
+    prompt_template: string;
+    example_prompts: string[];
+    core_app?: AgentApp;
+    core_app_input?: any;
+    sub_agents: (SubAgent | undefined)[];
+    tool_apps: (AgentApp | undefined)[];
+}
+export interface AgentVersionDTO {
+    id: string;
+    created_at: string;
+    updated_at: string;
+    deleted_at?: string;
+    user_id: string;
+    user?: UserRelationDTO;
+    acl?: ACL;
+    description: string;
+    system_prompt: string;
+    prompt_template: string;
+    example_prompts: string[];
+    core_app?: AgentApp;
+    core_app_input?: any;
+    sub_agents: (SubAgentDTO | undefined)[];
+    tool_apps: (AgentAppDTO | undefined)[];
+}
+/**
+ * TimeWindow represents a single analytics time window
+ */
+export interface TimeWindow {
+    start: string;
+    end: string;
+    count: number;
+}
+/**
+ * TaskStatusWindow represents a single analytics time window with task status
+ */
+export interface TaskStatusWindow {
+    start: string;
+    status: TaskStatus;
+    count: number;
+}
+/**
+ * AppUsage represents usage statistics for an app
+ */
+export interface AppUsage {
+    app_id: string;
+    app_username: string;
+    app_name: string;
+    version_id: string;
+    variant: string;
+    task_count: number;
+}
+/**
+ * TimeSeriesMetrics contains all time-series data
+ */
+export interface TimeSeriesMetrics {
+    active_users: TimeWindow[];
+    new_users: TimeWindow[];
+    tasks_by_status: TaskStatusWindow[];
+    new_engines: TimeWindow[];
+}
+/**
+ * TotalMetrics contains total counts for the time window
+ */
+export interface TotalMetrics {
+    active_users: number;
+    new_users: number;
+    tasks: number;
+    new_engines: number;
+    /**
+     * Total running engines
+     */
+    running_engines: number;
+    /**
+     * Private running engines (acl_other_exec = false or null)
+     */
+    private_running_engines: number;
+    /**
+     * Cloud running engines (acl_other_exec = true)
+     */
+    cloud_running_engines: number;
+    top_apps: AppUsage[];
+}
+/**
+ * RealtimeMetrics contains current system state
+ */
+export interface RealtimeMetrics {
+    /**
+     * Total tasks
+     */
+    queued_tasks: number;
+    running_tasks: number;
+    /**
+     * Private tasks (engines with acl_other_exec = false or null)
+     */
+    private_queued_tasks: number;
+    private_running_tasks: number;
+    /**
+     * Cloud tasks (engines with acl_other_exec = true)
+     */
+    cloud_queued_tasks: number;
+    cloud_running_tasks: number;
+    /**
+     * User metrics
+     */
+    total_users: number;
+    users_with_no_engines: number;
+    users_with_no_tasks: number;
+}
+/**
+ * AnalyticsResponse contains all analytics data
+ */
+export interface AnalyticsResponse {
+    time_series: TimeSeriesMetrics;
+    totals: TotalMetrics;
+    realtime: RealtimeMetrics;
+}
+/**
+ * AnalyticsRequest represents the query parameters for analytics
+ */
+export interface AnalyticsRequest {
+    start: string;
+    end: string;
+    resolution: string;
+}
+/**
+ * Define a private context key type
+ */
+/**
+ * AuthenticatedUser represents the user data we store in context
+ */
+export interface AuthenticatedUser {
+    id: string;
+    api_key: string;
+    role: string;
+}
+export interface APIRequest<T extends any> {
+    timestamp: string;
+    data: T;
+}
+export interface APIResponse<T extends any> {
+    success: boolean;
+    status: number;
+    data?: T;
+    error?: APIError;
+}
+export interface APIError {
+    code: string;
+    message: string;
+}
+export interface WorkerGPUConfig {
+    gpus: number[];
+}
+export interface WorkerCPUConfig {
+    count: number;
+}
+export interface WorkerConfig {
+    gpu: WorkerGPUConfig[];
+    cpu: WorkerCPUConfig;
+}
+export interface EngineConfig {
+    id: string;
+    name: string;
+    api_url: string;
+    engine_port: string;
+    workers: WorkerConfig;
+    api_key: string;
+    container_mode: boolean;
+    network_name: string;
+    cache_path: string;
+    gpus: string[];
+}
+export interface RemoteEngineCreateRequest {
+    name: string;
+    instance_type?: InstanceType;
+    start_time: string;
+    end_time: string;
+}
+export interface StripeCheckoutCreateRequest {
+    amount: number;
+    success_url: string;
+    cancel_url: string;
+}
+export interface StripeCheckoutCompleteRequest {
+    session_id: string;
+}
+export interface EngineCreateResponse {
+    engine_state?: EngineState;
+}
+export interface EngineRegisterRequest {
+    local_engine_state?: LocalEngineState;
+    api_url: string;
+    system_info?: SystemInfo;
+    worker_config: WorkerConfig;
+}
+export interface EngineRegisterResponse {
+    engine_state?: EngineState;
+}
+export interface CreateApiKeyRequest {
+    name: string;
+}
+export interface CreateTaskRequest {
+    app_id: string;
+    version_id?: string;
+    variant?: string;
+    infra: Infra;
+    workers: string[];
+    webhook?: string;
+    input: any;
+    flow_id?: string;
+    flow_run_id?: string;
+    chat_id?: string;
+    agent_id?: string;
+    agent_version_id?: string;
+    tool_call_id?: string;
+}
+export interface CreateAgentMessageRequest {
+    chat_id?: string;
+    agent_id?: string;
+    agent_version_id?: string;
+    tool_call_id?: string;
+    input: ChatTaskInput;
+    integration_context?: IntegrationContext;
+}
+/**
+ * WidgetActionRequest represents a user's response to a widget
+ * Uses WidgetAction and WidgetFormData from chat.go
+ */
+export interface WidgetActionRequest {
+    action: WidgetAction;
+    form_data?: WidgetFormData;
+}
+export interface ApiTaskRequest {
+    app: string;
+    version?: string;
+    variant?: string;
+    infra?: Infra;
+    workers?: string[];
+    webhook?: string;
+    input: any;
+}
+export interface CreateFlowRequest {
+    name: string;
+}
+export interface CreateFlowRunRequest {
+    flow: string;
+    input: any;
+}
+/**
+ * Request/Response Types
+ */
+export interface EngineAPIRequest {
+    data: {
+        [key: string]: any;
+    };
+    metadata: EngineAPIRequestMetadata;
+}
+export interface WorkerAPIRequest {
+    input: {
+        [key: string]: any;
+    };
+    metadata: WorkerAPIRequestMetadata;
+}
+export interface EngineAPIRequestMetadata {
+    worker_id: string;
+    app_id: string;
+    app_version_id: string;
+    app_variant: string;
+    gpu_ids: string[];
+    task_id: string;
+}
+export interface WorkerAPIRequestMetadata {
+    worker_id: string;
+    app_id: string;
+    app_version_id: string;
+    app_variant: string;
+    gpu_ids: string[];
+    task_id: string;
+}
+export interface AppsGetResponse {
+    apps: App[];
+    total: number;
+}
+export interface PartialFile {
+    uri: string;
+    path?: string;
+    content_type?: string;
+    size?: number;
+    filename?: string;
+}
+export interface FileCreateRequest {
+    files: PartialFile[];
+}
+export interface RunTaskRequest {
+    task: TaskDTO;
+    user_env: any;
+}
+export interface CreateChatMessageResponse {
+    user_message?: ChatMessageDTO;
+    assistant_message?: ChatMessageDTO;
+}
+export interface SchedulerMetrics {
+    tasks_queued: number;
+    tasks_processed: number;
+    tasks_failed: number;
+    processing_errors: number;
+    last_error?: string;
+    last_error_time?: string;
+    queue_metrics?: QueueMetrics[];
+    updated_at: string;
+}
+export interface QueueMetrics {
+    enqueued: number;
+    dequeued: number;
+    expired: number;
+    dlq: number;
+    in_flight: number;
+}
+export interface BlogPostCreateRequest {
+    title: string;
+    content: string;
+    excerpt: string;
+    status: BlogPostStatus;
+    metadata: BlogPostMetadata;
+    slug: string;
+    category_title?: string;
+    category_slug?: string;
+    sub_category_title?: string;
+    sub_category_slug?: string;
+    acl?: ACL;
+    is_featured: boolean;
+}
+export type BlogPostUpdateRequest = BlogPostCreateRequest;
+export interface BlogPostCommentCreateRequest {
+    blog_post_id: string;
+    content: string;
+}
+export type BlogPostCommentUpdateRequest = BlogPostCommentCreateRequest;
+export interface TransactionCreateRequest {
+    user_id: string;
+    group_id?: string;
+    type: TransactionType;
+    amount: number;
+    reference: string;
+    notes: string;
+    metadata: {
+        [key: string]: any;
+    };
+}
+export interface PublicEnginesForResourcesRequest {
+    resources: AppResources;
+}
+export interface PublicEnginesForResourcesResponse {
+    can_run: boolean;
+    min_price: number;
+    max_price: number;
+    error?: string;
+}
+export interface EnginesForResourcesRequest {
+    resources: AppResources;
+}
+export interface PrivateEngineResponse {
+    workers: WorkerStateSummary[];
+}
+export interface CloudEngineResponse {
+    can_run: boolean;
+    min_price: number;
+    max_price: number;
+}
+export interface EnginesForResourcesResponse {
+    private: PrivateEngineResponse;
+    cloud: CloudEngineResponse;
+    error?: string;
+}
+export interface TeamCreateRequest {
+    name: string;
+}
+export interface FeatureTaskRequest {
+    is_featured: boolean;
+}
+export interface TeamMemberAddRequest {
+    email: string;
+    role: TeamRole;
+}
+export interface TeamMemberUpdateRoleRequest {
+    role: TeamRole;
+}
+/**
+ * HandleSlackEventRequest models the outer event envelope and its inner event ("event") as received from Slack Events API.
+ * It is designed for maximum compatibility with the event_callback style JSON, url_verification, and app_rate_limited events.
+ */
+export interface HandleSlackEventRequest {
+    type: string;
+    token: string;
+    team_id?: string;
+    api_app_id?: string;
+    event?: any;
+    authed_users?: string[];
+    authed_teams?: string[];
+    authorizations?: SlackEventAuthorization[];
+    event_context?: string;
+    event_id?: string;
+    event_time?: number;
+    challenge?: string;
+    is_ext_shared_channel?: boolean;
+    context_team_id?: string;
+    context_enterprise_id?: string;
+    /**
+     * App Rate Limiting
+     */
+    minute_rate_limited?: number;
+}
+export interface SlackEventAuthorization {
+    enterprise_id?: string;
+    team_id: string;
+    user_id: string;
+    is_bot: boolean;
+    is_enterprise_install?: boolean;
+}
+/**
+ * Example: define inner events you want to care about and unmarshal HandleSlackEventRequest.Event as needed.
+ * Common message event payload, not all fields are present for all types.
+ */
+export interface SlackMessageEvent {
+    type: string;
+    subtype?: string;
+    channel?: string;
+    user?: string;
+    text?: string;
+    ts?: string;
+    event_ts?: string;
+    thread_ts?: string;
+    bot_id?: string;
+    bot_profile?: {
+        id?: string;
+    };
+}
+/**
+ * SlackThreadMessage represents a message from a Slack thread (from conversations.replies)
+ */
+export interface SlackThreadMessage {
+    type: string;
+    subtype?: string;
+    user?: string;
+    text?: string;
+    ts?: string;
+    thread_ts?: string;
+    parent_user_id?: string;
+    bot_id?: string;
+    bot_profile?: {
+        id?: string;
+        name?: string;
+    };
+}
+export interface ProjectCreateRequest {
+    name: string;
+    type: ProjectType;
+}
+export interface ProjectUpdateRequest {
+    name: string;
+}
+export interface MoveAgentToProjectRequest {
+    agent_id: string;
+    project_id: string;
+}
+export interface ApiKey {
+    BaseModel: BaseModel;
+    PermissionModel: PermissionModel;
+    name: string;
+    key: string;
+    last_used_at: string;
+}
+export interface ApiKeyDTO {
+    id: string;
+    created_at: string;
+    updated_at: string;
+    user_id: string;
+    user: UserRelationDTO;
+    name: string;
+    key: string;
+    last_used_at: string;
+}
+/**
+ * App-related types
+ */
+export type AppStatus = string;
+export declare const AppStatusActive: AppStatus;
+export declare const AppStatusInactive: AppStatus;
+export declare const AppStatusPending: AppStatus;
+export type AppCategory = string;
+export declare const AppCategoryImage: AppCategory;
+export declare const AppCategoryVideo: AppCategory;
+export declare const AppCategoryAudio: AppCategory;
+export declare const AppCategoryText: AppCategory;
+export declare const AppCategoryChat: AppCategory;
+export declare const AppCategory3D: AppCategory;
+export declare const AppCategoryOther: AppCategory;
+export declare const AppCategoryFlow: AppCategory;
+export type GPUType = string;
+export declare const GPUTypeAny: GPUType;
+export declare const GPUTypeNone: GPUType;
+export declare const GPUTypeIntel: GPUType;
+export declare const GPUTypeNvidia: GPUType;
+export declare const GPUTypeAMD: GPUType;
+export declare const GPUTypeApple: GPUType;
+export interface AppImages {
+    card: string;
+    thumbnail: string;
+    banner: string;
+}
+export interface App {
+    BaseModel: BaseModel;
+    PermissionModel: PermissionModel;
+    name: string;
+    description: string;
+    agent_description: string;
+    category: AppCategory;
+    blog_post_id?: string;
+    license: string;
+    license_mandatory: boolean;
+    needs_hf_token: boolean;
+    hf_model_url: string;
+    commercial: boolean;
+    status: AppStatus;
+    is_featured: boolean;
+    is_verified: boolean;
+    rank: number;
+    images: AppImages;
+    version_id: string;
+    version?: AppVersion;
+    allows_private_workers: boolean;
+    allows_cloud_workers: boolean;
+    fees: AppFees;
+}
+export type PartnerFeeType = string;
+export declare const PartnerFeeTypeFixed: PartnerFeeType;
+export declare const PartnerFeeTypePerSecond: PartnerFeeType;
+export interface AppFees {
+    royalty_fee: number;
+    partner_fee: number;
+    partner_fee_type: PartnerFeeType;
+}
+export interface AppGPUResource {
+    count: number;
+    vram: number;
+    type: GPUType;
+}
+export interface AppResources {
+    gpu: AppGPUResource;
+    ram: number;
+}
+export interface AppVariant {
+    name: string;
+    order: number;
+    resources: AppResources;
+    env: {
+        [key: string]: string;
+    };
+    python: string;
+}
+export interface AppVersion {
+    BaseModel: BaseModel;
+    app_id: string;
+    variants: {
+        [key: string]: AppVariant;
+    };
+    repository: string;
+    flow_id?: string;
+    flow?: Flow;
+    input_schema: any;
+    output_schema: any;
+    metadata: {
+        [key: string]: any;
+    };
+}
+export interface AppConfig {
+    name: string;
+    description: string;
+    category: AppCategory;
+    status: AppStatus;
+    images: AppImages;
+    input_schema: any;
+    output_schema: any;
+    metadata: {
+        [key: string]: any;
+    };
+    variants: {
+        [key: string]: AppVariant;
+    };
+}
+export interface LicenseRecord {
+    id: string;
+    created_at: string;
+    updated_at: string;
+    deleted_at?: string;
+    user_id: string;
+    app_id: string;
+    license: string;
+}
+export interface AppDTO {
+    id: string;
+    created_at: string;
+    updated_at: string;
+    deleted_at?: string;
+    user_id: string;
+    user?: UserRelationDTO;
+    name: string;
+    description: string;
+    agent_description: string;
+    category: AppCategory;
+    blog_post_id?: string;
+    license: string;
+    license_mandatory: boolean;
+    needs_hf_token: boolean;
+    hf_model_url: string;
+    commercial: boolean;
+    status: AppStatus;
+    acl?: ACL;
+    is_featured: boolean;
+    is_verified: boolean;
+    rank: number;
+    images: AppImages;
+    version_id: string;
+    version?: AppVersionDTO;
+    variants: {
+        [key: string]: AppVariant;
+    };
+    fees: AppFees;
+    allows_private_workers: boolean;
+    allows_cloud_workers: boolean;
+}
+export interface AppVersionDTO {
+    id: string;
+    created_at: string;
+    updated_at: string;
+    variants: {
+        [key: string]: AppVariant;
+    };
+    repository: string;
+    flow?: FlowDTO;
+    input_schema: any;
+    output_schema: any;
+    metadata: {
+        [key: string]: any;
+    };
+}
+export interface ChatModelCapabilities {
+    Image: boolean;
+    Images: boolean;
+    Files: boolean;
+    Reasoning: boolean;
+}
+export type Model = any;
+export interface BaseModel {
+    id: string;
+    created_at: string;
+    updated_at: string;
+    deleted_at?: string;
+}
+export type Permissioned = any;
+export interface PermissionModel {
+    user_id: string;
+    user?: User;
+    group_id?: string;
+    acl?: ACL;
+}
+export declare const PermRead = "read";
+export declare const PermWrite = "write";
+export declare const PermExec = "exec";
+export interface AuthContext {
+    IsAnonymous: boolean;
+    UserID: string;
+    GroupID?: string;
+}
+/**
+ * Versioned interface for optimistic locking
+ */
+export type Versioned = any;
+/**
+ * VersionedStruct provides optimistic locking functionality
+ */
+export interface VersionedStruct {
+    document_version: number;
+}
+export type Encrypted = any;
+export interface EncryptedModel {
+    user_public_key: string;
+    /**
+     * PRE key is extremely sensitive, it must be deleted as soon as the task is delivered to the engine
+     */
+    user_pre_key: string;
+    engine_public_key: string;
+}
+/**
+ * Billing holds billing information that can be owned by a user or team
+ * OwnerID is the user ID if no group, or the team/group ID if a group exists
+ */
+export interface Billing {
+    BaseModel: BaseModel;
+    PermissionModel: PermissionModel;
+    /**
+     * Balance in micro-cents (1 cent = 1,000,000)
+     */
+    balance: number;
+    /**
+     * Currency code (e.g., "USD")
+     */
+    currency: string;
+}
+/**
+ * BillingDTO is the data transfer object for Billing
+ */
+export interface BillingDTO {
+    id: string;
+    user_id: string;
+    group_id?: string;
+    created_at: string;
+    updated_at: string;
+    deleted_at?: string;
+    balance: number;
+    currency: string;
+}
+export type BlogPostStatus = number;
+export declare const BlogPostStatusUnknown: BlogPostStatus;
+export declare const BlogPostStatusDraft: BlogPostStatus;
+export declare const BlogPostStatusPublished: BlogPostStatus;
+export declare const BlogPostStatusArchived: BlogPostStatus;
+export interface BlogPostMetadata {
+    title: string;
+    description: string;
+    image: string;
+    tags: string[];
+}
+export interface BlogPost {
+    BaseModel: BaseModel;
+    PermissionModel: PermissionModel;
+    is_featured: boolean;
+    title: string;
+    content: string;
+    excerpt: string;
+    status: BlogPostStatus;
+    slug: string;
+    category_title?: string;
+    category_slug?: string;
+    sub_category_title?: string;
+    sub_category_slug?: string;
+    metadata: BlogPostMetadata;
+}
+export interface BlogPostDTO {
+    id: string;
+    created_at: string;
+    updated_at: string;
+    deleted_at?: string;
+    acl?: ACL;
+    is_featured: boolean;
+    user_id: string;
+    user?: UserRelationDTO;
+    title: string;
+    content: string;
+    excerpt: string;
+    status: BlogPostStatus;
+    metadata: BlogPostMetadata;
+    slug: string;
+    category_title?: string;
+    category_slug?: string;
+    sub_category_title?: string;
+    sub_category_slug?: string;
+}
+export type BlogPostCommentStatus = number;
+export declare const BlogPostCommentStatusUnknown: BlogPostCommentStatus;
+export declare const BlogPostCommentStatusDraft: BlogPostCommentStatus;
+export declare const BlogPostCommentStatusPublished: BlogPostCommentStatus;
+export declare const BlogPostCommentStatusArchived: BlogPostCommentStatus;
+export interface BlogPostComment {
+    BaseModel: BaseModel;
+    PermissionModel: PermissionModel;
+    blog_post_id: string;
+    content: string;
+    status: BlogPostCommentStatus;
+    /**
+     * Relationships
+     */
+    parent_comment_id?: string;
+    children: BlogPostComment[];
+}
+export interface BlogPostCommentDTO {
+    id: string;
+    created_at: string;
+    updated_at: string;
+    deleted_at?: string;
+    user_id: string;
+    user?: UserRelationDTO;
+    blog_post_id: string;
+    content: string;
+    parent_comment_id?: string;
+    children: BlogPostCommentDTO[];
+    status: BlogPostCommentStatus;
+}
+export type ChatType = string;
+export type ChatStatus = string;
+export declare const ChatStatusPending: ChatStatus;
+export declare const ChatStatusInProgress: ChatStatus;
+export declare const ChatStatusCompleted: ChatStatus;
+export declare const ChatStatusCancelled: ChatStatus;
+export interface Chat {
+    BaseModel: BaseModel;
+    PermissionModel: PermissionModel;
+    agent_id?: string;
+    agent_version_id?: string;
+    agent?: Agent;
+    tool_call_id?: string;
+    parent_id?: string;
+    parent?: Chat;
+    children: (Chat | undefined)[];
+    name: string;
+    description: string;
+    chat_messages: ChatMessage[];
+    agent_data: AgentData;
+    status: ChatStatus;
+    integration_context?: IntegrationContext;
+}
+export interface IntegrationContext {
+    integration_type?: IntegrationType;
+    integration_metadata?: any;
+}
+export interface AgentData {
+    plan_steps: AgentPlanStep[];
+    memory: StringEncodedMap;
+}
+export interface AgentPlanStep {
+    index: number;
+    title: string;
+    description: string;
+    notes?: string;
+    status: AgentPlanStepStatus;
+}
+export type AgentPlanStepStatus = string;
+export declare const AgentPlanStepStatusPending: AgentPlanStepStatus;
+export declare const AgentPlanStepStatusInProgress: AgentPlanStepStatus;
+export declare const AgentPlanStepStatusCompleted: AgentPlanStepStatus;
+export declare const AgentPlanStepStatusCancelled: AgentPlanStepStatus;
+export type ChatMessageRole = string;
+export declare const ChatMessageRoleSystem: ChatMessageRole;
+export declare const ChatMessageRoleUser: ChatMessageRole;
+export declare const ChatMessageRoleAssistant: ChatMessageRole;
+export declare const ChatMessageRoleTool: ChatMessageRole;
+export type ChatMessageContentType = string;
+export declare const ChatMessageContentTypeText: ChatMessageContentType;
+export declare const ChatMessageContentTypeReasoning: ChatMessageContentType;
+export declare const ChatMessageContentTypeImage: ChatMessageContentType;
+export declare const ChatMessageContentTypeFile: ChatMessageContentType;
+export declare const ChatMessageContentTypeTool: ChatMessageContentType;
+export type IntegrationType = string;
+export declare const IntegrationTypeSlack: IntegrationType;
+export declare const IntegrationTypeDiscord: IntegrationType;
+export declare const IntegrationTypeTeams: IntegrationType;
+export declare const IntegrationTypeTelegram: IntegrationType;
+export interface ChatMessageContent {
+    type: ChatMessageContentType;
+    error?: string;
+    text?: string;
+    image?: string;
+    file?: string;
+    tool_calls?: ToolInvocation[];
+}
+export type StringEncodedMap = {
+    [key: string]: any;
+};
+export interface ToolInvocationFunction {
+    name: string;
+    arguments: StringEncodedMap;
+}
+/**
+ * Define an auxiliary struct to avoid recursive UnmarshalJSON calls
+ */
+export interface Aux {
+    name: string;
+    arguments: any;
+}
+export type ToolInvocationType = string;
+export declare const ToolInvocationTypeInternal: ToolInvocationType;
+export declare const ToolInvocationTypeApp: ToolInvocationType;
+export declare const ToolInvocationTypeAgent: ToolInvocationType;
+export declare const ToolInvocationTypeWidget: ToolInvocationType;
+export declare const ToolInvocationTypeUnknown: ToolInvocationType;
+export type ToolInvocationStatus = string;
+export declare const ToolInvocationStatusPending: ToolInvocationStatus;
+export declare const ToolInvocationStatusInProgress: ToolInvocationStatus;
+export declare const ToolInvocationStatusAwaitingInput: ToolInvocationStatus;
+export declare const ToolInvocationStatusCompleted: ToolInvocationStatus;
+export declare const ToolInvocationStatusFailed: ToolInvocationStatus;
+export declare const ToolInvocationStatusCancelled: ToolInvocationStatus;
+export interface AgentToolInvocation {
+    BaseModel: BaseModel;
+    PermissionModel: PermissionModel;
+    chat_message_id: string;
+    tool_invocation_id: string;
+    type: ToolInvocationType;
+    function: ToolInvocationFunction;
+    status: ToolInvocationStatus;
+    result?: string;
+    widget: Widget;
+    task_id?: string;
+    chat_id?: string;
+}
+export interface AgentToolInvocationDTO {
+    id: string;
+    created_at: string;
+    updated_at: string;
+    deleted_at?: string;
+    user_id: string;
+    chat_message_id: string;
+    tool_invocation_id: string;
+    type: ToolInvocationType;
+    function: ToolInvocationFunction;
+    status: ToolInvocationStatus;
+    result?: string;
+    widget: Widget;
+    task_id?: string;
+    chat_id?: string;
+}
+/**
+ * This is a transport object, not a database model
+ */
+export interface ToolInvocation {
+    id: string;
+    type: string;
+    function: ToolInvocationFunction;
+}
+export interface ChatMessage {
+    BaseModel: BaseModel;
+    PermissionModel: PermissionModel;
+    chat_id: string;
+    chat?: Chat;
+    order: number;
+    task_id?: string;
+    task_status?: TaskStatus;
+    role: ChatMessageRole;
+    content: ChatMessageContent[];
+    tools?: Tool[];
+    tool_call_id?: string;
+    tool_invocations?: AgentToolInvocation[];
+    integration_context?: IntegrationContext;
+}
+export interface LLMUsage {
+    stop_reason: string;
+    time_to_first_token: number;
+    tokens_per_second: number;
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+    reasoning_tokens: number;
+    reasoning_time: number;
+}
+export interface ChatTaskOutput {
+    response: string;
+    reasoning?: string;
+    tool_calls?: ToolInvocation[];
+    usage?: LLMUsage;
+}
+export interface ChatTaskInput {
+    context_size: number;
+    temperature?: number;
+    top_p?: number;
+    reasoning_effort?: string;
+    reasoning_max_tokens?: number;
+    system_prompt: string;
+    context: ChatTaskContextMessage[];
+    role: ChatMessageRole;
+    text?: string;
+    reasoning?: string;
+    image?: string;
+    images?: string[];
+    files?: string[];
+    tools?: Tool[];
+    tool_call_id?: string;
+}
+export interface BaseLLMInput {
+    app_id: string;
+    app_version_id?: string;
+    app_variant?: string;
+    system_prompt: string;
+    tools?: Tool[];
+    context_size: number;
+    temperature?: number;
+    top_p?: number;
+    reasoning_effort?: string;
+    reasoning_max_tokens?: number;
+}
+export interface ChatTaskContextMessage {
+    role: ChatMessageRole;
+    text?: string;
+    reasoning?: string;
+    image?: string;
+    images?: string[];
+    file?: string;
+    files?: string[];
+    tools?: Tool[];
+    tool_calls?: ToolInvocation[];
+    tool_call_id?: string;
+}
+export interface ChatDTO {
+    id: string;
+    created_at: string;
+    updated_at: string;
+    deleted_at?: string;
+    user_id: string;
+    user: UserRelationDTO;
+    acl?: ACL;
+    parent_id?: string;
+    parent?: ChatDTO;
+    children: (ChatDTO | undefined)[];
+    agent_id?: string;
+    agent_version_id?: string;
+    agent?: AgentDTO;
+    name: string;
+    description: string;
+    chat_messages: ChatMessageDTO[];
+    agent_data: AgentData;
+}
+export interface ChatMessageDTO {
+    id: string;
+    created_at: string;
+    updated_at: string;
+    deleted_at?: string;
+    user_id: string;
+    user?: UserRelationDTO;
+    chat_id: string;
+    chat?: ChatDTO;
+    order: number;
+    task_id?: string;
+    task_status?: TaskStatus;
+    role: ChatMessageRole;
+    content: ChatMessageContent[];
+    tools?: Tool[];
+    tool_call_id?: string;
+    tool_invocations?: AgentToolInvocationDTO[];
+}
+/**
+ * SearchRequest represents a search request
+ */
+export interface SearchRequest {
+    fields: string[];
+    term: string;
+    exact: boolean;
+}
+/**
+ * FilterRequest represents a filter request
+ */
+export interface FilterRequest {
+    field: string;
+    operator: string;
+    value: any;
+}
+/**
+ * ListRequest represents a list request with all options
+ */
+export interface ListRequest {
+    page: number;
+    page_size: number;
+    search?: SearchRequest;
+    filters: Filter[];
+    sort: SortOrder[];
+    preloads: string[];
+    fields: string[];
+    permissions: string[];
+    include_others: boolean;
+}
+export interface ListResponse<T extends any> {
+    items: T[];
+    total: number;
+    page: number;
+    page_size: number;
+    total_pages: number;
+}
+/**
+ * Filter represents a single filter condition
+ */
+export interface Filter {
+    field: string;
+    operator: FilterOperator;
+    value: any;
+}
+/**
+ * FilterOperator represents the type of filter operation
+ */
+export type FilterOperator = string;
+export declare const OpEqual: FilterOperator;
+export declare const OpNotEqual: FilterOperator;
+export declare const OpIn: FilterOperator;
+export declare const OpNotIn: FilterOperator;
+export declare const OpGreater: FilterOperator;
+export declare const OpGreaterEqual: FilterOperator;
+export declare const OpLess: FilterOperator;
+export declare const OpLessEqual: FilterOperator;
+export declare const OpLike: FilterOperator;
+export declare const OpILike: FilterOperator;
+export declare const OpContains: FilterOperator;
+export declare const OpNotContains: FilterOperator;
+/**
+ * Null checks
+ */
+export declare const OpIsNull: FilterOperator;
+export declare const OpIsNotNull: FilterOperator;
+/**
+ * Empty checks (for strings)
+ */
+export declare const OpIsEmpty: FilterOperator;
+export declare const OpIsNotEmpty: FilterOperator;
+/**
+ * SortOrder represents sorting configuration
+ */
+export interface SortOrder {
+    field: string;
+    dir: string;
+}
+/**
+ * CursorListRequest represents a cursor-based list request with all options
+ */
+export interface CursorListRequest {
+    cursor: string;
+    limit: number;
+    direction: string;
+    search?: SearchRequest;
+    filters: Filter[];
+    preloads: string[];
+    sort: SortOrder[];
+    fields: string[];
+    permissions: string[];
+    include_others: boolean;
+}
+/**
+ * CursorListResponse represents a cursor-based paginated response
+ */
+export interface CursorListResponse<T extends any> {
+    items: T[];
+    next_cursor: string;
+    prev_cursor: string;
+    has_next: boolean;
+    has_previous: boolean;
+    items_per_page: number;
+    total_items: number;
+}
+/**
+ * CursorConfig represents the configuration for cursor-based pagination
+ */
+export interface CursorConfig {
+    field: string;
+    direction: string;
+    value: any;
+}
+/**
+ * Engine-related types
+ */
+export type EngineStatus = string;
+export declare const EngineStatusRunning: EngineStatus;
+export declare const EngineStatusPending: EngineStatus;
+export declare const EngineStatusStopping: EngineStatus;
+export declare const EngineStatusStopped: EngineStatus;
+export interface EngineState {
+    BaseModel: BaseModel;
+    PermissionModel: PermissionModel;
+    instance?: Instance;
+    transaction_id: string;
+    config: EngineConfig;
+    public_key: string;
+    name: string;
+    api_url: string;
+    status: EngineStatus;
+    system_info?: SystemInfo;
+    workers: (WorkerState | undefined)[];
+}
+export interface LocalEngineState {
+    id: string;
+    name: string;
+    config: EngineConfig;
+    public_key: string;
+}
+export interface EngineStateDTO {
+    id: string;
+    created_at: string;
+    updated_at: string;
+    user_id: string;
+    user?: UserRelationDTO;
+    group_id?: string;
+    acl?: ACL;
+    instance?: Instance;
+    config: EngineConfig;
+    name: string;
+    api_url: string;
+    status: EngineStatus;
+    system_info?: SystemInfo;
+    workers: (WorkerStateDTO | undefined)[];
+}
+export interface EngineStateSummary {
+    id: string;
+    created_at: string;
+    updated_at: string;
+    user_id: string;
+    user?: UserRelationDTO;
+    group_id?: string;
+    acl?: ACL;
+    instance?: Instance;
+    name: string;
+    status: EngineStatus;
+    workers: (WorkerStateSummary | undefined)[];
+}
+/**
+ * Worker-related types
+ */
+export type WorkerStatus = string;
+export interface WorkerState {
+    BaseModel: BaseModel;
+    PermissionModel: PermissionModel;
+    index: number;
+    status: WorkerStatus;
+    status_updated_at?: string;
+    engine_id: string;
+    engine?: EngineState;
+    task_id?: string;
+    app_id: string;
+    app_version_id: string;
+    variant: string;
+    gpus: WorkerGPU[];
+    cpus: WorkerCPU[];
+    rams: WorkerRAM[];
+}
+export interface WorkerGPU {
+    id: string;
+    worker_id: string;
+    gpu_id: string;
+    type: GPUType;
+    name: string;
+    vram: number;
+}
+export interface WorkerCPU {
+    id: string;
+    worker_id: string;
+    name: string;
+    vendor_id: string;
+    family: string;
+    model: string;
+    cores: number;
+    frequency: string;
+}
+export interface WorkerRAM {
+    id: string;
+    worker_id: string;
+    total: number;
+}
+export interface WorkerStateDTO {
+    id: string;
+    user_id: string;
+    index: number;
+    status: WorkerStatus;
+    engine_id: string;
+    task_id?: string;
+    app_id: string;
+    app_version_id: string;
+    app_variant: string;
+    gpus: WorkerGPU[];
+    cpus: WorkerCPU[];
+    rams: WorkerRAM[];
+    system_info: SystemInfo;
+}
+export interface WorkerStateSummary {
+    id: string;
+    user_id: string;
+    index: number;
+    status: WorkerStatus;
+    engine_id: string;
+    engine_name: string;
+    task_id?: string;
+    app_id: string;
+    app_version_id: string;
+    app_variant: string;
+    gpus: WorkerGPU[];
+    cpus: WorkerCPU[];
+    rams: WorkerRAM[];
+}
+export interface File {
+    BaseModel: BaseModel;
+    PermissionModel: PermissionModel;
+    path: string;
+    remote_path: string;
+    upload_url: string;
+    uri: string;
+    content_type: string;
+    size: number;
+    filename: string;
+}
+export interface FileDTO {
+    id: string;
+    created_at: string;
+    updated_at: string;
+    user_id: string;
+    user: UserRelationDTO;
+    path: string;
+    remote_path: string;
+    upload_url: string;
+    uri: string;
+    content_type: string;
+    size: number;
+    filename: string;
+}
+export interface Flow {
+    BaseModel: BaseModel;
+    PermissionModel: PermissionModel;
+    name: string;
+    description: string;
+    card_image: string;
+    thumbnail: string;
+    banner_image: string;
+    input_schema: any;
+    input: FlowRunInputs;
+    output_schema: any;
+    output_mappings: OutputMappings;
+    node_data: FlowNodeDataMap;
+    nodes: FlowNode[];
+    edges: FlowEdge[];
+    viewport?: FlowViewport;
+}
+export interface FlowViewport {
+    x: number;
+    y: number;
+    zoom: number;
+}
+export interface FlowNode {
+    id: string;
+    type: string;
+    position: FlowNodePosition;
+}
+export interface FlowNodePosition {
+    x: number;
+    y: number;
+}
+export interface FlowNodeData {
+    app?: AppDTO;
+    app_id: string;
+    app_version_id: string;
+    app_variant: string;
+    infra: Infra;
+    workers: string[];
+    additional?: any;
+    task?: TaskDTO;
+    task_id?: string;
+}
+export type FlowNodeDataMap = {
+    [key: string]: FlowNodeData;
+};
+export interface FlowEdge {
+    id: string;
+    type: string;
+    source: string;
+    target: string;
+    source_handle?: string;
+    target_handle?: string;
+}
+/**
+ * OutputFieldMapping represents a mapping from a source node's field to an output field in the flow output schema.
+ */
+export interface OutputFieldMapping {
+    sourceNodeId: string;
+    sourceFieldPath: string;
+    outputFieldName: string;
+    type: string;
+    schema: any;
+}
+/**
+ * OutputMappings is a map of output field name to OutputFieldMapping.
+ */
+export type OutputMappings = {
+    [key: string]: OutputFieldMapping;
+};
+export interface FlowDTO {
+    id: string;
+    created_at: string;
+    updated_at: string;
+    deleted_at?: string;
+    user_id: string;
+    user?: UserRelationDTO;
+    name: string;
+    description: string;
+    card_image: string;
+    thumbnail: string;
+    banner_image: string;
+    input_schema: any;
+    input: FlowRunInputs;
+    output_schema: any;
+    output_mappings: OutputMappings;
+    node_data: FlowNodeDataMap;
+    nodes: FlowNode[];
+    edges: FlowEdge[];
+    viewport?: FlowViewport;
+}
+export interface NodeTaskDTO {
+    task_id: string;
+    task?: TaskDTO;
+}
+export type FlowRunStatus = number;
+export declare const FlowRunStatusUnknown: FlowRunStatus;
+export declare const FlowRunStatusPending: FlowRunStatus;
+export declare const FlowRunStatusRunning: FlowRunStatus;
+export declare const FlowRunStatusCompleted: FlowRunStatus;
+export declare const FlowRunStatusFailed: FlowRunStatus;
+export declare const FlowRunStatusCancelled: FlowRunStatus;
+export interface FlowRun {
+    BaseModel: BaseModel;
+    PermissionModel: PermissionModel;
+    task_id?: string;
+    flow_id: string;
+    flow: Flow;
+    status: FlowRunStatus;
+    error?: string;
+    flow_run_started?: string;
+    flow_run_finished?: string;
+    flow_run_cancelled?: string;
+    input: FlowRunInputs;
+    fail_on_error: boolean;
+    output: any;
+    infra?: Infra;
+    workers?: string[];
+    node_task_map: {
+        [key: string]: string;
+    };
+    node_tasks: {
+        [key: string]: NodeTask;
+    };
+}
+export interface FlowRunDTO {
+    id: string;
+    created_at: string;
+    updated_at: string;
+    acl?: ACL;
+    user_id: string;
+    user?: UserRelationDTO;
+    flow_id: string;
+    flow?: FlowDTO;
+    task_id?: string;
+    status: FlowRunStatus;
+    error?: string;
+    flow_run_started?: string;
+    flow_run_finished?: string;
+    flow_run_cancelled?: string;
+    input: FlowRunInputs;
+    fail_on_error: boolean;
+    output: any;
+    node_tasks: {
+        [key: string]: NodeTaskDTO | undefined;
+    };
+}
+/**
+ * Connection represents a connection between nodes in a flow
+ */
+export interface FlowNodeConnection {
+    nodeId: string;
+    key: string;
+    type: string;
+    previousValue: any;
+}
+export type FlowRunInputs = {
+    [key: string]: {
+        [key: string]: FlowRunInput;
+    };
+};
+export interface FlowRunInput {
+    Connection?: FlowNodeConnection;
+    Value: any;
+}
+export interface NodeTask {
+    task_id: string;
+    task?: Task;
+}
+/**
+ * NodePosition represents x,y coordinates
+ */
+export interface NodePosition {
+    x: number;
+    y: number;
+}
+/**
+ * CoordinateExtent represents a bounding box with [x1, y1, x2, y2]
+ */
+export type CoordinateExtent = number[];
+export interface NodeHandle {
+    x: number;
+    y: number;
+    position: string;
+    id: string;
+    width: number;
+    height: number;
+    type: string;
+    name: string;
+}
+export interface GraphModel {
+    graph_id?: string;
+}
+/**
+ * Graph represents a persistent directed acyclic graph for tracking execution dependencies
+ */
+export interface Graph {
+    BaseModel: BaseModel;
+    PermissionModel: PermissionModel;
+    /**
+     * Source reference - what created this graph
+     */
+    source_id: string;
+    source_type: string;
+    /**
+     * Status
+     */
+    status: GraphStatus;
+    /**
+     * Metadata
+     */
+    started_at?: string;
+    completed_at?: string;
+    error?: string;
+    /**
+     * Relationships - loaded via GORM joins
+     */
+    nodes?: (GraphNode | undefined)[];
+    edges?: (GraphEdge | undefined)[];
+    node_states?: (GraphNodeState | undefined)[];
+}
+/**
+ * GraphNode represents a node in the execution graph
+ */
+export interface GraphNode {
+    id: string;
+    graph_id: string;
+    type: string;
+    /**
+     * Optional metadata for the node
+     */
+    name?: string;
+    description?: string;
+    metadata?: {
+        [key: string]: any;
+    };
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * GraphEdge represents a dependency between nodes
+ */
+export interface GraphEdge {
+    id: string;
+    graph_id: string;
+    from: string;
+    to: string;
+    /**
+     * Edge properties
+     */
+    type: GraphEdgeType;
+    required: boolean;
+    completed: boolean;
+    metadata?: {
+        [key: string]: any;
+    };
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * GraphNodeState tracks the execution state of a node
+ */
+export interface GraphNodeState {
+    node_id: string;
+    graph_id: string;
+    status: GraphNodeStatus;
+    /**
+     * Dependency barrier counters
+     */
+    required_deps: number;
+    completed_deps: number;
+    /**
+     * Link to the actual execution entity (TaskID, ChatMessageID, etc.)
+     */
+    execution_id?: string;
+    execution_type?: string;
+    /**
+     * Timing
+     */
+    ready_at?: string;
+    started_at?: string;
+    completed_at?: string;
+    /**
+     * Error tracking
+     */
+    error?: string;
+    retry_count?: number;
+    /**
+     * Optional: Store outputs if needed for input resolution
+     */
+    outputs?: {
+        [key: string]: any;
+    };
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * GraphStatus represents the overall status of the graph
+ */
+export type GraphStatus = string;
+export declare const GraphStatusPending: GraphStatus;
+export declare const GraphStatusRunning: GraphStatus;
+export declare const GraphStatusCompleted: GraphStatus;
+export declare const GraphStatusFailed: GraphStatus;
+export declare const GraphStatusCancelled: GraphStatus;
+/**
+ * GraphNodeStatus represents the status of a node
+ */
+export type GraphNodeStatus = string;
+export declare const GraphNodeStatusPending: GraphNodeStatus;
+export declare const GraphNodeStatusReady: GraphNodeStatus;
+export declare const GraphNodeStatusRunning: GraphNodeStatus;
+export declare const GraphNodeStatusCompleted: GraphNodeStatus;
+export declare const GraphNodeStatusFailed: GraphNodeStatus;
+export declare const GraphNodeStatusCancelled: GraphNodeStatus;
+export declare const GraphNodeStatusSkipped: GraphNodeStatus;
+export declare const GraphNodeStatusBlocked: GraphNodeStatus;
+/**
+ * GraphEdgeType defines the type of edge relationship
+ */
+export type GraphEdgeType = string;
+export declare const GraphEdgeTypeDependency: GraphEdgeType;
+export declare const GraphEdgeTypeFlow: GraphEdgeType;
+export declare const GraphEdgeTypeConditional: GraphEdgeType;
+export declare const GraphEdgeTypeError: GraphEdgeType;
+/**
+ * GraphSpec is used to create a new execution graph
+ */
+export interface GraphSpec {
+    SourceID: string;
+    SourceType: string;
+    Nodes: GraphNodeSpec[];
+    Edges: GraphEdgeSpec[];
+}
+/**
+ * GraphNodeSpec specifies a node to be created
+ */
+export interface GraphNodeSpec {
+    ID: string;
+    Type: string;
+    Name: string;
+    Description: string;
+    Metadata: {
+        [key: string]: any;
+    };
+}
+/**
+ * GraphEdgeSpec specifies an edge to be created
+ */
+export interface GraphEdgeSpec {
+    ID: string;
+    From: string;
+    To: string;
+    Type: GraphEdgeType;
+    Required: boolean;
+    Metadata: {
+        [key: string]: any;
+    };
+}
+/**
+ * ServerCapabilities represents the server's supported features
+ */
+export interface ServerCapabilitiesLogging {
+    level: string;
+}
+export interface ServerCapabilitiesPrompts {
+    listChanged: boolean;
+}
+export interface ServerCapabilitiesResources {
+    subscribe: boolean;
+    listChanged: boolean;
+}
+export interface ServerCapabilitiesTools {
+    listChanged: boolean;
+}
+export interface ServerCapabilities {
+    logging: ServerCapabilitiesLogging;
+    prompts: ServerCapabilitiesPrompts;
+    resources: ServerCapabilitiesResources;
+    tools: ServerCapabilitiesTools;
+}
+/**
+ * ServerInfo represents information about the server
+ */
+export interface ServerInfo {
+    name: string;
+    title: string;
+    version: string;
+}
+/**
+ * InitializeResponse represents the server's response to an initialization request
+ */
+export interface InitializeResponse {
+    protocolVersion: string;
+    capabilities: ServerCapabilities;
+    serverInfo: ServerInfo;
+    instructions?: string;
+}
+/**
+ * CancellationParams represents the parameters for a cancellation notification
+ */
+export interface CancellationParams {
+    requestId: string;
+    reason?: string;
+}
+/**
+ * ProgressParams represents progress update parameters
+ */
+export interface ProgressParams {
+    requestId: string;
+    progress: number;
+    message?: string;
+}
+/**
+ * ResourceRequest represents a request for resource operations
+ */
+export interface ResourceRequest {
+    operation: string;
+    id?: string;
+    userId?: string;
+    resource?: any;
+    listOptions?: ListRequest;
+}
+/**
+ * ResourceResponse represents a response for resource operations
+ */
+export interface ResourceResponse {
+    resources: Resource[];
+    nextCursor?: string;
+}
+/**
+ * Resource represents a resource item
+ */
+export interface Resource {
+    uri: string;
+    name: string;
+    title?: string;
+    description?: string;
+    mimeType?: string;
+    size?: number;
+}
+/**
+ * ResourceContent represents resource content
+ */
+export interface ResourceContent {
+    uri: string;
+    name: string;
+    title?: string;
+    mimeType?: string;
+    text?: string;
+    blob?: string;
+}
+/**
+ * ResourceReadResponse represents a response for resource read operations
+ */
+export interface ResourceReadResponse {
+    contents: ResourceContent[];
+}
+/**
+ * PromptRequest represents a request for prompt operations
+ */
+export interface PromptRequest {
+    operation: string;
+    id?: string;
+    prompt?: string;
+    listOptions?: ListRequest;
+}
+/**
+ * PromptResponse represents a response for prompt operations
+ */
+export interface PromptResponse {
+    prompts: Prompt[];
+    nextCursor?: string;
+}
+/**
+ * Prompt represents a prompt item
+ */
+export interface Prompt {
+    name: string;
+    title?: string;
+    description?: string;
+    arguments?: PromptArg[];
+    messages?: PromptMessage[];
+}
+/**
+ * PromptArg represents a prompt argument
+ */
+export interface PromptArg {
+    name: string;
+    description: string;
+    required: boolean;
+}
+/**
+ * PromptMessage represents a message in a prompt
+ */
+export interface PromptMessage {
+    role: string;
+    content: PromptContent;
+}
+/**
+ * PromptContent represents content in a prompt message
+ */
+export interface PromptContent {
+    type: string;
+    text?: string;
+    data?: string;
+    mimeType?: string;
+}
+/**
+ * ToolRequest represents a request for tool operations
+ */
+export interface ToolListRequest {
+    cursor?: string;
+}
+/**
+ * ToolResponse represents a response for tool operations
+ */
+export interface ToolListResponse {
+    tools: MCPTool[];
+    nextCursor?: string;
+}
+/**
+ * Tool represents a tool item
+ */
+export interface MCPTool {
+    name: string;
+    title?: string;
+    description: string;
+    inputSchema: any;
+    outputSchema?: any;
+}
+/**
+ * ToolCallRequest represents a request to call a tool
+ */
+export interface ToolCallRequest {
+    name: string;
+    arguments: {
+        [key: string]: any;
+    };
+}
+/**
+ * ToolCallResponse represents a response from a tool call
+ */
+export interface ToolCallResponse {
+    content: ToolContent[];
+    structuredContent?: any;
+    isError: boolean;
+}
+/**
+ * ToolContent represents content in a tool response
+ */
+export interface ToolContent {
+    type: string;
+    text?: string;
+    data?: string;
+    mimeType?: string;
+    resource?: ResourceContent;
+}
+/**
+ * JSONRPCRequest represents a JSON-RPC request
+ */
+export interface JSONRPCRequest {
+    jsonrpc: string;
+    id: any;
+    method: string;
+    params?: any;
+}
+/**
+ * JSONRPCResponse represents a JSON-RPC response
+ */
+export interface JSONRPCResponse {
+    jsonrpc: string;
+    id: any;
+    result?: any;
+    error?: JSONRPCError;
+}
+/**
+ * JSONRPCError represents a JSON-RPC error
+ */
+export interface JSONRPCError {
+    code: number;
+    message: string;
+    data?: any;
+}
+/**
+ * NotificationMessage represents a notification message
+ */
+export interface NotificationMessage {
+    jsonrpc: string;
+    method: string;
+    params?: any;
+}
+/**
+ * ConnectedEvent represents a connected event
+ */
+export interface ConnectedEvent {
+    event: string;
+    timestamp: string;
+}
+/**
+ * ResourceTemplate represents a resource template
+ */
+export interface ResourceTemplate {
+    uriTemplate: string;
+    name: string;
+    title?: string;
+    description?: string;
+    mimeType?: string;
+}
+/**
+ * ResourceTemplateResponse represents a response for resource template operations
+ */
+export interface ResourceTemplateResponse {
+    resourceTemplates: ResourceTemplate[];
+}
+/**
+ * ProjectType represents different types of projects
+ */
+export type ProjectType = string;
+export declare const ProjectTypeAgent: ProjectType;
+export declare const ProjectTypeApp: ProjectType;
+export declare const ProjectTypeFlow: ProjectType;
+export declare const ProjectTypeOther: ProjectType;
+/**
+ * Project represents a container for organizing related resources
+ */
+export interface Project {
+    BaseModel: BaseModel;
+    PermissionModel: PermissionModel;
+    name: string;
+    description: string;
+    type: ProjectType;
+    color?: string;
+    icon?: string;
+    /**
+     * For future: nested folders/projects
+     */
+    parent_id?: string;
+    parent?: Project;
+    children: (Project | undefined)[];
+}
+/**
+ * ProjectDTO for API responses
+ */
+export interface ProjectDTO {
+    id: string;
+    created_at: string;
+    updated_at: string;
+    deleted_at?: string;
+    user_id: string;
+    user?: UserRelationDTO;
+    acl?: ACL;
+    name: string;
+    description: string;
+    type: ProjectType;
+    color?: string;
+    icon?: string;
+    parent_id?: string;
+    parent?: ProjectDTO;
+    children: (ProjectDTO | undefined)[];
+}
+export interface ResourcePrice {
+    CentsPerHour: number;
+    NanosPerSecond: number;
+}
+/**
+ * SchemaConverter handles conversion from JSON Schema to tool format
+ */
+export interface SchemaConverter {
+}
+/**
+ * RequiredField represents a required field with its name and description
+ */
+export interface SchemaField {
+    Name: string;
+    Description: string;
+}
+export interface Session {
+    id: string;
+    hash: string;
+    token: string;
+    user_id: string;
+    user?: User;
+    created_at: string;
+    expires_at: string;
+    ip: string;
+    user_agent: string;
+    city: string;
+    country: string;
+    os: string;
+    browser: string;
+    browser_version: string;
+    is_anonymous: boolean;
+}
+export type InstanceCloudProvider = string;
+export declare const CloudAWS: InstanceCloudProvider;
+export declare const CloudAzure: InstanceCloudProvider;
+export declare const CloudLambdaLabs: InstanceCloudProvider;
+export declare const CloudTensorDock: InstanceCloudProvider;
+export declare const CloudRunPod: InstanceCloudProvider;
+export declare const CloudLatitude: InstanceCloudProvider;
+export declare const CloudJarvisLabs: InstanceCloudProvider;
+export declare const CloudOblivus: InstanceCloudProvider;
+export declare const CloudPaperspace: InstanceCloudProvider;
+export declare const CloudDatacrunch: InstanceCloudProvider;
+export declare const CloudMassedCompute: InstanceCloudProvider;
+export declare const CloudVultr: InstanceCloudProvider;
+export declare const CloudShade: InstanceCloudProvider;
+export type InstanceStatus = string;
+export declare const InstanceStatusPending: InstanceStatus;
+export declare const InstanceStatusActive: InstanceStatus;
+export declare const InstanceStatusDeleted: InstanceStatus;
+export interface Instance {
+    id: string;
+    PermissionModel: PermissionModel;
+    cloud: InstanceCloudProvider;
+    name: string;
+    region: string;
+    shade_cloud: boolean;
+    shade_instance_type: string;
+    cloud_instance_type: string;
+    cloud_assigned_id: string;
+    os?: string;
+    ssh_key_id?: string;
+    ssh_user: string;
+    ssh_port: number;
+    ip: string;
+    status: InstanceStatus;
+    cost_estimate: string;
+    hourly_price: number;
+    template_id?: string;
+    volume_ids?: string[];
+    tags?: string[];
+    configuration?: InstanceConfiguration;
+    launch_configuration?: InstanceLaunchConfiguration;
+    auto_delete?: InstanceThresholdConfig;
+    alert?: InstanceThresholdConfig;
+    volume_mount?: InstanceVolumeMountConfig;
+    envs?: InstanceEnvVar[];
+}
+export interface InstanceRequest {
+    cloud: InstanceCloudProvider;
+    name: string;
+    region: string;
+    shade_cloud: boolean;
+    shade_instance_type: string;
+    os?: string;
+    ssh_key_id?: string;
+    template_id?: string;
+    volume_ids?: string[];
+    tags?: string[];
+    launch_configuration?: InstanceLaunchConfiguration;
+    auto_delete?: InstanceThresholdConfig;
+    alert?: InstanceThresholdConfig;
+    volume_mount?: InstanceVolumeMountConfig;
+    envs?: InstanceEnvVar[];
+}
+export interface InstanceConfiguration {
+    gpu_type: string;
+    interconnect: string;
+    memory_in_gb: number;
+    num_gpus: number;
+    os: string;
+    storage_in_gb: number;
+    vcpus: number;
+    vram_per_gpu_in_gb: number;
+}
+export interface InstanceLaunchConfiguration {
+    type: string;
+    docker_configuration?: InstanceDockerConfig;
+    script_configuration?: InstanceScriptConfig;
+}
+export interface InstanceDockerConfig {
+    image: string;
+    args?: string;
+    shared_memory_in_gb?: number;
+    envs?: InstanceEnvVar[];
+    port_mappings?: InstancePortMapping[];
+    volume_mounts?: InstanceVolumeMount[];
+}
+export interface InstanceScriptConfig {
+    base64_script: string;
+}
+export interface InstancePortMapping {
+    host_port: number;
+    container_port: number;
+}
+export interface InstanceVolumeMount {
+    host_path: string;
+    container_path: string;
+}
+export interface InstanceThresholdConfig {
+    date_threshold?: string;
+    spend_threshold?: string;
+}
+export interface InstanceVolumeMountConfig {
+    auto: boolean;
+}
+export interface InstanceEnvVar {
+    name: string;
+    value: string;
+}
+export type InstanceTypeDeploymentType = string;
+export declare const InstanceTypeDeploymentTypeVM: InstanceTypeDeploymentType;
+export declare const InstanceTypeDeploymentTypeContainer: InstanceTypeDeploymentType;
+export declare const InstanceTypeDeploymentTypeBaremetal: InstanceTypeDeploymentType;
+export interface InstanceType {
+    id: string;
+    PermissionModel: PermissionModel;
+    cloud: InstanceCloudProvider;
+    region: string;
+    shade_instance_type: string;
+    cloud_instance_type: string;
+    deployment_type: InstanceTypeDeploymentType;
+    hourly_price: number;
+    configuration?: InstanceTypeConfiguration;
+    availability: InstanceTypeAvailability[];
+    boot_time?: InstanceTypeBootTime;
+}
+export interface InstanceTypeConfiguration {
+    gpu_type: string;
+    interconnect: string;
+    memory_in_gb: number;
+    num_gpus: number;
+    os_options: string[];
+    storage_in_gb: number;
+    vcpus: number;
+    vram_per_gpu_in_gb: number;
+}
+export interface InstanceTypeAvailability {
+    available: boolean;
+    region: string;
+}
+export interface InstanceTypeBootTime {
+    average_seconds: number;
+    updated_at: string;
+    sample_size: number;
+}
+export interface SlackResponse {
+    Body: string;
+    ContentType: string;
+}
+/**
+ * SlackIntegrationMetadata contains Slack-specific context for chat messages
+ * This is stored in ChatMessage.IntegrationMetadata as JSON
+ */
+export interface SlackIntegrationMetadata {
+    channel: string;
+    thread_ts: string;
+    team_id?: string;
+    user_id?: string;
+    bot_message_ts?: string;
+    stream_started?: boolean;
+    stream_ts?: string;
+}
+/**
+ * SlackBlock represents a Slack Block Kit block
+ */
+export interface SlackBlock {
+    type: string;
+    text?: any;
+}
+/**
+ * SlackTextObject represents a text object in Slack Block Kit
+ */
+export interface SlackTextObject {
+    type: string;
+    text: string;
+}
+/**
+ * SlackPostMessageRequest represents the payload for posting a message to Slack
+ */
+export interface SlackPostMessageRequest {
+    channel: string;
+    text?: string;
+    markdown_text?: string;
+    blocks?: SlackBlock[];
+    thread_ts?: string;
+    mrkdwn?: boolean;
+}
+/**
+ * SlackUpdateMessageRequest represents the payload for updating a Slack message
+ */
+export interface SlackUpdateMessageRequest {
+    channel: string;
+    ts: string;
+    text?: string;
+    blocks?: SlackBlock[];
+}
+/**
+ * SlackAssistantThreadsSetStatusRequest represents the payload for setting assistant thread status
+ * This shows a typing indicator in Slack (requires assistant:write scope)
+ */
+export interface SlackAssistantThreadsSetStatusRequest {
+    channel_id: string;
+    thread_ts: string;
+    status: string;
+    loading_messages?: string[];
+}
+/**
+ * SlackAssistantThreadsSetStopSuggestedRequest represents the payload to stop the typing indicator
+ */
+export interface SlackAssistantThreadsSetStopSuggestedRequest {
+    channel_id: string;
+    thread_ts: string;
+}
+/**
+ * SlackAPIResponse represents a standard Slack API response
+ */
+export interface SlackAPIResponse {
+    ok: boolean;
+    error?: string;
+    ts?: string;
+}
+/**
+ * SlackConversationsRepliesResponse represents the response from conversations.replies
+ */
+export interface SlackConversationsRepliesResponse {
+    ok: boolean;
+    error?: string;
+    messages: SlackThreadMessage[];
+}
+/**
+ * SlackStartStreamRequest represents the payload for starting a streaming message
+ */
+export interface SlackStartStreamRequest {
+    channel: string;
+    thread_ts: string;
+    markdown_text?: string;
+    recipient_user_id?: string;
+    recipient_team_id?: string;
+}
+/**
+ * SlackAppendStreamRequest represents the payload for appending to a streaming message
+ */
+export interface SlackAppendStreamRequest {
+    channel: string;
+    ts: string;
+    markdown_text?: string;
+}
+/**
+ * SlackStopStreamRequest represents the payload for stopping a streaming message
+ */
+export interface SlackStopStreamRequest {
+    channel: string;
+    ts: string;
+}
+/**
+ * Hardware/System related types
+ */
+export interface SystemInfo {
+    hostname: string;
+    ipv4: string;
+    ipv6: string;
+    mac_address: string;
+    os: string;
+    docker: Docker;
+    wsl2: WSL2;
+    cpus: CPU[];
+    ram: RAM;
+    volumes: Volume[];
+    hf_cache: HFCacheInfo;
+    gpus: GPU[];
+}
+export interface TelemetrySystemInfo {
+    cpus: CPU[];
+    ram: RAM;
+    gpus: GPU[];
+    volumes: Volume[];
+}
+export interface Docker {
+    binary_path: string;
+    installed: boolean;
+    socket_path: string;
+    socket_available: boolean;
+    running: boolean;
+    version: string;
+}
+export interface WSL2 {
+    installed: boolean;
+    enabled: boolean;
+    version: string;
+}
+export interface CPU {
+    name: string;
+    vendor_id: string;
+    family: string;
+    model: string;
+    cores: number;
+    frequency: string;
+    usage: number;
+    normalized_usage: number;
+}
+export interface Volume {
+    name: string;
+    size: number;
+    used: number;
+    free: number;
+    usage: number;
+}
+export interface RAM {
+    total: number;
+    available: number;
+    used: number;
+    free: number;
+    usage: number;
+    total_physical: number;
+    total_usable: number;
+    bootloader_usage: number;
+    swap_total: number;
+    swap_used: number;
+    swap_free: number;
+    swap_usage: number;
+}
+export interface GPU {
+    id: string;
+    name: string;
+    index: number;
+    cuda_version: string;
+    driver_version: string;
+    memory_used: number;
+    memory_total: number;
+    temperature: number;
+}
+/**
+ * CachedRevisionInfo represents information about a cached revision
+ */
+export interface CachedRevisionInfo {
+    commit_hash: string;
+    snapshot_path: string;
+    last_modified: string;
+    size_on_disk: number;
+    size_on_disk_str: string;
+    nb_files: number;
+    refs: string[];
+}
+/**
+ * CachedRepoInfo represents information about a cached repository
+ */
+export interface CachedRepoInfo {
+    repo_id: string;
+    repo_type: string;
+    repo_path: string;
+    last_accessed: string;
+    last_modified: string;
+    size_on_disk: number;
+    size_on_disk_str: string;
+    nb_files: number;
+    refs: string[];
+    Revisions: CachedRevisionInfo[];
+}
+/**
+ * HFCacheInfo represents information about the Huggingface cache
+ */
+export interface HFCacheInfo {
+    cache_dir: string;
+    repos: CachedRepoInfo[];
+    size_on_disk: number;
+    warnings: string[];
+}
+/**
+ * DeletionStrategy represents a strategy for deleting revisions
+ */
+export interface DeletionStrategy {
+    repos: CachedRepoInfo[];
+    snapshots: string[];
+    expected_freed_size: number;
+    expected_freed_size_str: string;
+}
+export interface CacheNotFoundError {
+    cache_dir: string;
+}
+export type TaskStatus = number;
+export declare const TaskStatusUnknown: TaskStatus;
+export declare const TaskStatusReceived: TaskStatus;
+export declare const TaskStatusQueued: TaskStatus;
+export declare const TaskStatusScheduled: TaskStatus;
+export declare const TaskStatusPreparing: TaskStatus;
+export declare const TaskStatusServing: TaskStatus;
+export declare const TaskStatusSettingUp: TaskStatus;
+export declare const TaskStatusRunning: TaskStatus;
+export declare const TaskStatusUploading: TaskStatus;
+export declare const TaskStatusCompleted: TaskStatus;
+export declare const TaskStatusFailed: TaskStatus;
+export declare const TaskStatusCancelled: TaskStatus;
+export type Infra = string;
+export declare const InfraPrivate: Infra;
+export declare const InfraCloud: Infra;
+export declare const InfraPrivateFirst: Infra;
+export interface Task {
+    BaseModel: BaseModel;
+    PermissionModel: PermissionModel;
+    VersionedStruct: VersionedStruct;
+    EncryptedModel: EncryptedModel;
+    GraphModel: GraphModel;
+    is_featured: boolean;
+    status: TaskStatus;
+    /**
+     * Foreign keys
+     */
+    app_id: string;
+    app?: App;
+    version_id: string;
+    app_version?: AppVersion;
+    variant: string;
+    infra: Infra;
+    workers: string[];
+    engine_id?: string;
+    engine?: EngineState;
+    worker_id?: string;
+    worker?: WorkerState;
+    flow_id?: string;
+    flow_run_id?: string;
+    sub_flow_run_id?: string;
+    /**
+     * This part should be all replaced by the new graph model
+     */
+    chat_id?: string;
+    agent_id?: string;
+    agent_version_id?: string;
+    agent?: Agent;
+    tool_call_id?: string;
+    webhook?: string;
+    input: any;
+    output: any;
+    error: string;
+    nsfw: boolean;
+    /**
+     * Relationships
+     */
+    events: TaskEvent[];
+    logs: TaskLog[];
+    telemetry: TimescaleTask[];
+    usage_events: (UsageEvent | undefined)[];
+    transaction_id?: string;
+    transaction?: Transaction;
+}
+export interface TaskEvent {
+    id: string;
+    created_at: string;
+    event_time: string;
+    task_id: string;
+    status: TaskStatus;
+}
+export type TaskLogType = number;
+export declare const TaskLogTypeBuild: TaskLogType;
+export declare const TaskLogTypeRun: TaskLogType;
+export declare const TaskLogTypeServe: TaskLogType;
+export declare const TaskLogTypeSetup: TaskLogType;
+export declare const TaskLogTypeTask: TaskLogType;
+export interface TaskLog {
+    id: string;
+    created_at: string;
+    updated_at: string;
+    task_id: string;
+    log_type: TaskLogType;
+    content: string;
+}
+export interface TaskDTO {
+    id: string;
+    graph_id?: string;
+    created_at: string;
+    updated_at: string;
+    deleted_at?: string;
+    acl?: ACL;
+    user_id: string;
+    user?: UserRelationDTO;
+    user_public_key: string;
+    engine_public_key: string;
+    is_featured: boolean;
+    status: TaskStatus;
+    app_id: string;
+    app?: AppDTO;
+    app_version_id: string;
+    app_version?: AppVersionDTO;
+    app_variant: string;
+    infra: Infra;
+    workers: string[];
+    flow_id?: string;
+    flow_run_id?: string;
+    sub_flow_run_id?: string;
+    chat_id?: string;
+    agent_id?: string;
+    agent_version_id?: string;
+    agent?: AgentDTO;
+    engine_id?: string;
+    engine?: EngineStateSummary;
+    worker_id?: string;
+    worker?: WorkerStateSummary;
+    webhook?: string;
+    input: any;
+    output: any;
+    error: string;
+    nsfw: boolean;
+    events: TaskEvent[];
+    logs: TaskLog[];
+    telemetry: TimescaleTask[];
+    usage_events: (UsageEvent | undefined)[];
+    transaction_id?: string;
+    transaction?: Transaction;
+}
+export interface TimescaleTask {
+    id: string;
+    timestamp: string;
+    task_id?: string;
+    task_seq: number;
+    app_id: string;
+    app_version_id: string;
+    app_variant: string;
+    engine_id: string;
+    engine_resources: TelemetrySystemInfo;
+    worker_id: string;
+    system_info: TelemetrySystemInfo;
+}
+export interface Team {
+    BaseModel: BaseModel;
+}
+export interface TeamDTO {
+    id: string;
+    name: string;
+    logo: string;
+    balance: number;
+    env: string;
+}
+export type TeamRole = string;
+export declare const TeamRoleOwner: TeamRole;
+export declare const TeamRoleAdmin: TeamRole;
+export declare const TeamRoleMember: TeamRole;
+export interface TeamMember {
+    BaseModel: BaseModel;
+}
+export interface TeamMemberDTO {
+    id: string;
+    user_id: string;
+    team_id: string;
+    role: TeamRole;
+    user?: UserRelationDTO;
+    team?: TeamDTO;
+}
+/**
+ * Tool types and parameter types
+ */
+export declare const ToolTypeFunction = "function";
+/**
+ * Tool types and parameter types
+ */
+export declare const ToolParamTypeObject = "object";
+/**
+ * Tool types and parameter types
+ */
+export declare const ToolParamTypeString = "string";
+/**
+ * Tool types and parameter types
+ */
+export declare const ToolParamTypeInteger = "integer";
+/**
+ * Tool types and parameter types
+ */
+export declare const ToolParamTypeNumber = "number";
+/**
+ * Tool types and parameter types
+ */
+export declare const ToolParamTypeBoolean = "boolean";
+/**
+ * Tool types and parameter types
+ */
+export declare const ToolParamTypeArray = "array";
+/**
+ * Tool types and parameter types
+ */
+export declare const ToolParamTypeNull = "null";
+export interface Tool {
+    type: string;
+    function: ToolFunction;
+}
+export interface ToolFunction {
+    name: string;
+    description: string;
+    parameters: ToolParameters;
+    required?: string[];
+}
+export interface ToolParameters {
+    type: string;
+    title: string;
+    properties: ToolParameterProperties;
+    required?: string[];
+}
+export type ToolParameterProperties = {
+    [key: string]: ToolParameterProperty;
+};
+export interface ToolParameterProperty {
+    type: string;
+    title: string;
+    description: string;
+    properties?: ToolParameterProperties;
+    items?: ToolParameterProperty;
+    required?: string[];
+}
+/**
+ * TransactionType represents the type of credit transaction
+ */
+export type TransactionType = string;
+export declare const TransactionTypeCredit: TransactionType;
+export declare const TransactionTypeDebit: TransactionType;
+/**
+ * Transaction represents a single credit transaction
+ */
+export interface Transaction {
+    BaseModel: BaseModel;
+    PermissionModel: PermissionModel;
+    type: TransactionType;
+    amount: number;
+    reference: string;
+    notes: string;
+    /**
+     * Metadata for the transaction
+     */
+    metadata: {
+        [key: string]: any;
+    };
+}
+export interface TransactionDTO {
+    id: string;
+    created_at: string;
+    updated_at: string;
+    deleted_at?: string;
+    user_id: string;
+    user?: UserRelationDTO;
+    type: TransactionType;
+    amount: number;
+    reference: string;
+    notes: string;
+    usage_billing_record_id?: string;
+    usage_billing_record?: UsageBillingRecord;
+    usage_billing_refund_id?: string;
+    usage_billing_refund?: UsageBillingRefund;
+    metadata: {
+        [key: string]: any;
+    };
+}
+export type StripeTransactionStatus = number;
+export declare const StripeTransactionStatusOpen: StripeTransactionStatus;
+export declare const StripeTransactionStatusComplete: StripeTransactionStatus;
+export declare const StripeTransactionStatusExpired: StripeTransactionStatus;
+export interface StripeTransaction {
+    BaseModel: BaseModel;
+    PermissionModel: PermissionModel;
+    session_id: string;
+    session_url: string;
+    status: StripeTransactionStatus;
+}
+export type UsageEventResourceTier = string;
+export declare const UsageEventResourceTierPrivate: UsageEventResourceTier;
+export declare const UsageEventResourceTierCloud: UsageEventResourceTier;
+export interface UsageEvent {
+    BaseModel: BaseModel;
+    usage_billing_record_id: string;
+    /**
+     * Event owner
+     */
+    user_id: string;
+    group_id?: string;
+    reference_id: string;
+    resource_id: string;
+    /**
+     * Resource tier
+     */
+    tier: UsageEventResourceTier;
+    type: string;
+    model: string;
+    quantity: number;
+    unit: string;
+}
+export interface UsageEventSummary {
+    tier_usage: {
+        [key: UsageEventResourceTier]: number;
+    };
+    type_usage: {
+        [key: string]: number;
+    };
+    model_usage: {
+        [key: string]: number;
+    };
+    total_usage: number;
+}
+export interface UsageBillingRecord {
+    BaseModel: BaseModel;
+    user_id: string;
+    group_id?: string;
+    usage_events: (UsageEvent | undefined)[];
+    total: number;
+    user_debit_transaction_id: string;
+    user_debit_transaction?: Transaction;
+    owner_credit_transaction_id: string;
+    owner_credit_transaction?: Transaction;
+}
+export interface UsageBillingRefund {
+    BaseModel: BaseModel;
+    user_id: string;
+    group_id?: string;
+    usage_billing_record_id: string;
+    usage_billing_record?: UsageBillingRecord;
+    user_debit_refund_transaction_id: string;
+    user_debit_refund_transaction?: Transaction;
+    owner_credit_refund_transaction_id: string;
+    owner_credit_refund_transaction?: Transaction;
+}
+/**
+ * User-related types
+ */
+export interface User {
+    BaseModel: BaseModel;
+    role: Role;
+    username: string;
+    email: string;
+    name: string;
+    full_name: string;
+    avatar_url: string;
+    email_verified: boolean;
+    phone_verified: boolean;
+    is_anonymous: boolean;
+    env: string;
+    balance: number;
+    metadata: UserMetadata;
+}
+export type Role = string;
+export declare const RoleUser: Role;
+export declare const RoleAdmin: Role;
+export declare const RoleSystem: Role;
+export interface UserDTO {
+    id: string;
+    created_at: string;
+    updated_at: string;
+    deleted_at?: string;
+    role: Role;
+    username: string;
+    email: string;
+    email_verified: boolean;
+    is_anonymous: boolean;
+    name: string;
+    full_name: string;
+    avatar_url: string;
+    env: string;
+    balance: number;
+    metadata: UserMetadata;
+}
+/**
+ * User-related types
+ */
+export interface UserRelationDTO {
+    id: string;
+    created_at: string;
+    updated_at: string;
+    role: Role;
+    username: string;
+    avatar_url: string;
+}
+export interface UserMetadata {
+    user_id: string;
+    completed_onboarding: boolean;
+    use_case: string;
+    use_case_reason: string;
+    use_case_privacy: string;
+}
+/**
+ * Environment represents a map of environment variables
+ */
+export type Environment = {
+    [key: string]: string;
+};
+/**
+ * WidgetAction represents an action triggered by a widget button
+ */
+export interface WidgetAction {
+    type: string;
+    payload?: {
+        [key: string]: any;
+    };
+}
+/**
+ * WidgetActionButton represents a button in a widget's action bar
+ */
+export interface WidgetActionButton {
+    label: string;
+    action: WidgetAction;
+    variant?: string;
+}
+export type WidgetNodeType = string;
+export declare const WidgetNodeTypeText: WidgetNodeType;
+export declare const WidgetNodeTypeMarkdown: WidgetNodeType;
+export declare const WidgetNodeTypeImage: WidgetNodeType;
+export declare const WidgetNodeTypeBadge: WidgetNodeType;
+export declare const WidgetNodeTypeButton: WidgetNodeType;
+export declare const WidgetNodeTypeInput: WidgetNodeType;
+export declare const WidgetNodeTypeSelect: WidgetNodeType;
+export declare const WidgetNodeTypeCheckbox: WidgetNodeType;
+export declare const WidgetNodeTypeRow: WidgetNodeType;
+export declare const WidgetNodeTypeCol: WidgetNodeType;
+/**
+ * WidgetNode represents a UI element in a widget (text, input, select, etc.)
+ */
+export interface WidgetNode {
+    type: WidgetNodeType;
+    value?: string;
+    src?: string;
+    alt?: string;
+    label?: string;
+    name?: string;
+    placeholder?: string;
+    defaultValue?: string;
+    variant?: string;
+    action?: WidgetAction;
+    options?: WidgetSelectOption[];
+    defaultChecked?: boolean;
+    children?: WidgetNode[];
+    gap?: number;
+}
+/**
+ * WidgetSelectOption represents an option in a select widget
+ */
+export interface WidgetSelectOption {
+    label: string;
+    value: string;
+}
+/**
+ * Widget represents an interactive card widget
+ */
+export interface Widget {
+    type: string;
+    title?: string;
+    html?: string;
+    json?: string;
+    children?: WidgetNode[];
+    actions?: WidgetActionButton[];
+}
+/**
+ * WidgetFormData represents the form data collected from widget inputs
+ */
+export type WidgetFormData = {
+    [key: string]: any;
+};
+/**
+ * WidgetActionResult represents the result of a widget action submission
+ */
+export interface WidgetActionResult {
+    action: WidgetAction;
+    form_data?: WidgetFormData;
+}
+/**
+ * WebSocket message types
+ */
+export declare const WSEventTaskStatus = "task_status";
+/**
+ * Task WebSocket
+ */
+export declare const WSEventTaskLog = "task_log";
+/**
+ * Task WebSocket
+ */
+export declare const WSEventTaskProgress = "task_progress";
+/**
+ * Task WebSocket
+ */
+export declare const WSEventTaskOutput = "task_output";
+/**
+ * Task WebSocket
+ */
+export declare const WSEventTaskFailed = "task_failed";
+export interface WsTaskStatusPayload {
+    task_id: string;
+    time: string;
+    status: TaskStatus;
+}
+export interface WsTaskLogPayload {
+    task_id: string;
+    log_type: TaskLogType;
+    logs: string;
+}
+export interface WsTaskOutputPayload {
+    task_id: string;
+    output: string;
+}
+export interface WsTaskFailedPayload {
+    task_id: string;
+    error: string;
+}
+export declare const WSEventTaskRun = "task_run";
+export declare const WSEventTaskCancel = "task_cancel";
+export declare const WSEventTaskForceCancel = "task_force_cancel";
+export declare const WSEventEngineStop = "engine_stop";
+export declare const WSEventEngineDeleteHFCacheRepo = "engine_delete_hfcache_repo";
+export interface WsTaskRunPayload {
+    task: TaskDTO;
+    user_env: string;
+}
+export interface WsTaskCancelPayload {
+    task: TaskDTO;
+}
+export interface WsTaskForceCancelPayload {
+    task: TaskDTO;
+}
+/**
+ * Engine WebSocket
+ */
+export declare const WSEventEngineHeartbeat = "engine_heartbeat";
+/**
+ * Engine WebSocket
+ */
+export declare const WSEventEngineTelemetry = "engine_telemetry";
+export type WorkerStatusMap = {
+    [key: string]: WorkerStatus;
+};
+export interface WsEngineHeartbeatPayload {
+    engine_id: string;
+    engine_status: EngineStatus;
+    worker_statuses: WorkerStatusMap;
+}
+export interface WsEngineTelemetryPayload {
+    engine_id: string;
+    engine_state: EngineState;
+}
+export interface WsEngineDeleteHFCacheRepoPayload {
+    repo_id: string;
+}
+/**
+ * Worker WebSocket
+ */
+export declare const WSEventWorkerUpdate = "worker_update";
+export interface WsWorkerUpdatePayload {
+    engine_id: string;
+    worker_id: string;
+    worker_state: WorkerState;
+}