modulex-python 0.1.0__py3-none-any.whl

modulex/types/composer.py

@@ -0,0 +1,27 @@
+"""Composer-related type definitions."""
+
+from __future__ import annotations
+
+from typing_extensions import TypedDict
+
+
+class ComposerChatResponse(TypedDict, total=False):
+    """Response from initiating or continuing a composer chat."""
+
+    status: str
+    composer_chat_id: str
+    workflow_id: str | None
+    run_id: str | None
+    thread_id: str | None
+    stream_url: str | None
+
+
+class ComposerStatusResponse(TypedDict, total=False):
+    """Status snapshot for an active composer session."""
+
+    composer_chat_id: str
+    workflow_id: str | None
+    is_running: bool
+    running_id: str | None
+    has_pending_changes: bool
+    run_status: str | None

modulex/types/credentials.py

@@ -0,0 +1,79 @@
+"""Credential-related type definitions."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from typing_extensions import TypedDict
+
+
+class CredentialResponse(TypedDict, total=False):
+    """Response representing a stored credential."""
+
+    credential_id: str
+    integration_name: str
+    integration_type: str
+    display_name: str
+    auth_type: str
+    is_default: bool
+    created_at: str
+    updated_at: str
+    last_used_at: str | None
+    expires_at: str | None
+
+
+class CredentialTestResult(TypedDict, total=False):
+    """Result from testing a credential."""
+
+    credential_id: str
+    is_valid: bool
+    message: str
+    tested_at: str
+    test_method: str
+    integration_name: str
+    auth_type: str
+    test_endpoint: str | None
+    status_code: int | None
+    cost_level: str | None
+
+
+class CredentialUsageStats(TypedDict, total=False):
+    """Aggregated usage statistics for a credential."""
+
+    credential_id: str
+    total_calls: int
+    successful_calls: int
+    failed_calls: int
+    success_rate: float
+    action_breakdown: dict[str, Any]
+    start_date: str
+    end_date: str
+
+
+class AuditEntry(TypedDict, total=False):
+    """Single audit log entry for a credential action."""
+
+    id: str
+    credential_id: str
+    action: str
+    performed_by: str
+    timestamp: str
+    details: dict[str, Any]
+
+
+class MCPToolsResponse(TypedDict, total=False):
+    """Response listing MCP tools available for a credential."""
+
+    credential_id: str
+    tools: list[Any]
+    total_count: int
+
+
+class MCPRefreshResponse(TypedDict, total=False):
+    """Response from refreshing MCP tools for a credential."""
+
+    credential_id: str
+    refreshed_at: str
+    changes: dict[str, Any]
+    total_tools: int
+    success: bool

modulex/types/dashboard.py

@@ -0,0 +1,54 @@
+"""Dashboard-related type definitions."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from typing_extensions import TypedDict
+
+
+class LogEntry(TypedDict, total=False):
+    """A single audit/activity log entry."""
+
+    id: str
+    organization_id: str
+    category: str
+    operation: str
+    performed_by: str
+    details: dict[str, Any]
+    timestamp: str
+
+
+class LogsResponse(TypedDict, total=False):
+    """Paginated log listing response."""
+
+    success: bool
+    organization_id: str
+    data: dict[str, Any]
+    filters: dict[str, Any]
+    meta: dict[str, Any]
+
+
+class AnalyticsOverviewResponse(TypedDict, total=False):
+    """High-level analytics overview for an organization."""
+
+    success: bool
+    organization_id: str
+    data: dict[str, Any]
+    meta: dict[str, Any]
+
+
+class UserListResponse(TypedDict, total=False):
+    """Paginated list of organization members."""
+
+    success: bool
+    organization_id: str
+    users: list[Any]
+    invitation_count: int
+    max_seats: int | None
+    total: int
+    total_pages: int
+    current_page: int
+    limit: int
+    has_next: bool
+    has_previous: bool

modulex/types/executions.py

@@ -0,0 +1,104 @@
+"""Execution-related type definitions."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from typing_extensions import TypedDict
+
+
+class RunResponse(TypedDict, total=False):
+    """Response from /workflows/run."""
+
+    status: str
+    run_id: str
+    thread_id: str
+    chat_id: str | None
+    ephemeral: bool
+    stream: bool
+    workflow_name: str
+    workflow_version: str
+    workflow_source: str
+    elapsed_ms: float
+    human_message: dict[str, Any]
+    ai_message: dict[str, Any]
+    message: str
+
+
+class StateResponse(TypedDict, total=False):
+    """Response from /workflows/state/{thread_id}."""
+
+    thread_id: str
+    run_id: str
+    checkpoint_id: str
+    state: dict[str, Any]
+    next: list[str]
+    metadata: dict[str, Any]
+    pending_writes: int
+
+
+class ResumeResponse(TypedDict, total=False):
+    """Response from /workflows/resume/{thread_id}."""
+
+    status: str
+    run_id: str
+    thread_id: str
+    stream: bool
+    workflow_source: str
+    message: str
+
+
+class CancelResponse(TypedDict, total=False):
+    """Response from /workflows/cancel/{run_id}."""
+
+    status: str
+    run_id: str
+    reason: str
+    message: str
+
+
+class NodeUpdateEvent(TypedDict, total=False):
+    """SSE node_update event data."""
+
+    node_id: str
+    node_type: str
+    status: str
+    output: dict[str, Any]
+    error: str | None
+    execution_time_ms: float
+
+
+class MetadataEvent(TypedDict, total=False):
+    """SSE metadata event data."""
+
+    run_id: str
+    thread_id: str
+    workflow_name: str
+    workflow_version: str
+    nodes: list[dict[str, Any]]
+
+
+class InterruptEvent(TypedDict, total=False):
+    """SSE interrupt event data."""
+
+    message: str
+    state: dict[str, Any]
+    resume_instructions: str
+    node_id: str
+
+
+class DoneEvent(TypedDict, total=False):
+    """SSE done event data."""
+
+    final_state: dict[str, Any]
+    steps_executed: int
+    total_execution_time_ms: float
+
+
+class ErrorEvent(TypedDict, total=False):
+    """SSE error event data."""
+
+    error_message: str
+    error_type: str
+    node_id: str | None
+    stack_trace: str | None

modulex/types/integrations.py

@@ -0,0 +1,29 @@
+"""Integration-related type definitions."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from typing_extensions import TypedDict
+
+
+class IntegrationInfo(TypedDict, total=False):
+    """Metadata describing a single integration."""
+
+    name: str
+    display_name: str
+    type: str
+    category: str
+    description: str | None
+    auth_types: list[str]
+    icon_url: str | None
+
+
+class IntegrationBrowseResponse(TypedDict, total=False):
+    """Paginated browse response for available integrations."""
+
+    integrations: list[Any]
+    total: int
+    page: int
+    page_size: int
+    total_pages: int

modulex/types/knowledge.py

@@ -0,0 +1,75 @@
+"""Knowledge base-related type definitions."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from typing_extensions import TypedDict
+
+
+class KnowledgeBaseResponse(TypedDict, total=False):
+    """Response representing a knowledge base."""
+
+    id: str
+    organization_id: str
+    name: str
+    description: str | None
+    status: str
+    embedding_config: dict[str, Any]
+    chunking_config: dict[str, Any]
+    document_count: int
+    total_chunks: int
+    created_at: str
+    updated_at: str
+
+
+class DocumentResponse(TypedDict, total=False):
+    """Response representing a document inside a knowledge base."""
+
+    id: str
+    knowledge_base_id: str
+    filename: str
+    status: str
+    file_size: int
+    mime_type: str
+    metadata: dict[str, Any]
+    chunk_count: int
+    created_at: str
+    updated_at: str
+
+
+class SearchResult(TypedDict, total=False):
+    """Result from a knowledge base semantic search."""
+
+    query: str
+    results: list[dict[str, Any]]
+    total_results: int
+
+
+class ChunkInfo(TypedDict, total=False):
+    """Information about a single document chunk."""
+
+    id: str
+    document_id: str
+    content: str
+    metadata: dict[str, Any]
+    embedding_id: str | None
+
+
+class ContextResponse(TypedDict, total=False):
+    """Assembled context string returned for a query."""
+
+    context: str
+    query: str
+
+
+class SupportedFileTypesResponse(TypedDict, total=False):
+    """Supported file types and upload limits for a knowledge base."""
+
+    supported_types: list[str]
+    max_file_size_bytes: int
+    max_file_size_mb: float
+
+
+class KnowledgeStatsResponse(TypedDict, total=False):
+    """Aggregate statistics for a knowledge base (shape may vary by backend)."""

modulex/types/notifications.py

@@ -0,0 +1,16 @@
+"""Notification-related type definitions."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from typing_extensions import TypedDict
+
+
+class NotificationResponse(TypedDict, total=False):
+    """Paginated list of notifications for an organization."""
+
+    success: bool
+    notifications: list[Any]
+    total: int
+    organization_id: str

modulex/types/organizations.py

@@ -0,0 +1,43 @@
+"""Organization-related type definitions."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from typing_extensions import TypedDict
+
+
+class OrganizationResponse(TypedDict, total=False):
+    """Generic organization action response."""
+
+    success: bool
+    message: str
+    organization: dict[str, Any]
+
+
+class LLMListResponse(TypedDict, total=False):
+    """Response listing LLM configurations for an organization."""
+
+    success: bool
+    total: int
+    active_llm_total: int
+    inactive_llm_total: int
+    active_llms: list[Any]
+    inactive_llms: list[Any]
+
+
+class InviteResponse(TypedDict, total=False):
+    """Response from sending an organization invitation."""
+
+    success: bool
+    message: str
+
+
+class RoleUpdateResponse(TypedDict, total=False):
+    """Response from updating a member's role."""
+
+    success: bool
+    message: str
+    user_id: str
+    organization_id: str
+    new_role: str

modulex/types/schedules.py

@@ -0,0 +1,48 @@
+"""Schedule-related type definitions."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from typing_extensions import TypedDict
+
+
+class ScheduleResponse(TypedDict, total=False):
+    """Response representing a workflow schedule."""
+
+    id: str
+    workflow_id: str
+    name: str
+    description: str | None
+    schedule_type: str
+    interval_seconds: int | None
+    cron_expression: str | None
+    timezone: str
+    is_active: bool
+    input: dict[str, Any]
+    config: dict[str, Any]
+    next_run_at: str | None
+    last_run_at: str | None
+    created_at: str
+    updated_at: str
+
+
+class ScheduleRunResponse(TypedDict, total=False):
+    """Response representing a single execution triggered by a schedule."""
+
+    id: str
+    schedule_id: str
+    status: str
+    started_at: str
+    completed_at: str | None
+    duration_ms: float | None
+    error: str | None
+
+
+class RunStatsResponse(TypedDict, total=False):
+    """Aggregate run statistics for a schedule."""
+
+    total_runs: int
+    successful_runs: int
+    failed_runs: int
+    average_duration_ms: float | None

modulex/types/shared.py

@@ -0,0 +1,39 @@
+"""Shared/common type definitions."""
+
+from __future__ import annotations
+
+from typing_extensions import TypedDict
+
+
+class PaginatedResponse(TypedDict, total=False):
+    """Generic paginated response."""
+
+    total: int
+    limit: int
+    offset: int
+    has_next: bool
+    has_previous: bool
+
+
+class PagePaginatedResponse(TypedDict, total=False):
+    """Page-based paginated response."""
+
+    total: int
+    page: int
+    page_size: int
+    total_pages: int
+
+
+class SuccessResponse(TypedDict, total=False):
+    """Generic success response."""
+
+    success: bool
+    message: str
+
+
+class ErrorDetail(TypedDict, total=False):
+    """Validation error detail."""
+
+    loc: list[str]
+    msg: str
+    type: str

modulex/types/subscriptions.py

@@ -0,0 +1,59 @@
+"""Subscription and billing-related type definitions."""
+
+from __future__ import annotations
+
+from typing_extensions import TypedDict
+
+
+class PlanPrice(TypedDict, total=False):
+    """Pricing entry for a subscription plan."""
+
+    price: float
+    interval: str
+    currency: str
+
+
+class PlanInfo(TypedDict, total=False):
+    """Details about a subscription plan."""
+
+    id: str
+    name: str
+    sort_order: int
+    is_enterprise: bool
+    discount: float | None
+    prices: list[PlanPrice]
+    features: list[str]
+    is_selectable: bool
+
+
+class PlansResponse(TypedDict, total=False):
+    """Response listing available subscription plans."""
+
+    plans: list[PlanInfo]
+    total: int
+
+
+class BillingSubscription(TypedDict, total=False):
+    """Active billing subscription details."""
+
+    id: str
+    status: str
+    current_period_start: str
+    current_period_end: str
+    billing_interval: str
+    current_price: float | None
+    created_at: str
+
+
+class BillingResponse(TypedDict, total=False):
+    """Current billing state for an organization."""
+
+    has_subscription: bool
+    subscription: BillingSubscription
+    plan: PlanInfo
+
+
+class CheckoutResponse(TypedDict, total=False):
+    """Response containing a Stripe checkout or portal URL."""
+
+    url: str

modulex/types/templates.py

@@ -0,0 +1,50 @@
+"""Template-related type definitions."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from typing_extensions import TypedDict
+
+
+class CreatorProfile(TypedDict, total=False):
+    """Public creator profile attached to a template."""
+
+    id: str
+    user_id: str
+    name: str
+    about: str | None
+    display_photo: str | None
+    socials: dict[str, Any]
+    created_at: str
+
+
+class TemplateResponse(TypedDict, total=False):
+    """Response representing a workflow template."""
+
+    id: str
+    creator_id: str
+    creator: dict[str, Any]
+    name: str
+    description: str | None
+    tags: list[str]
+    workflow_schema: dict[str, Any]
+    input: dict[str, Any]
+    config: dict[str, Any]
+    schema_image_url: str | None
+    visibility: str
+    status: str
+    like_count: int
+    used_count: int
+    is_liked: bool
+    edit_version: int
+    created_at: str
+    updated_at: str
+
+
+class TemplateListResponse(TypedDict, total=False):
+    """Paginated list response for templates."""
+
+    templates: list[Any]
+    total: int
+    cached: bool