@ductape/sdk 0.0.4-v6 → 0.0.4-v61

package/dist/types/productsBuilder.types.d.ts

@@ -47,6 +47,11 @@ export interface IProduct {
     quota: Array<IProductQuota>;
     fallback: Array<IProductFallback>;
     messageBrokers: Array<IProductMessageBroker>;
+    healthchecks: Array<IProductAppHealth>;
+    workflows: Array<IProductWorkflow>;
+    vectors: Array<IProductVector>;
+    models: Array<IProductLLMModel>;
+    agents: Array<IProductAgent>;
     private_key: string;
 }
 export interface IProductEnv {
@@ -64,6 +69,102 @@ export interface IProductAppEnvs {
     variables?: Array<KeyValuePair>;
     auth: IProductAppAuth;
 }
+/**
+ * Healthcheck probe type
+ */
+export declare enum HealthcheckProbeType {
+    APP = "app",
+    DATABASE = "database",
+    WORKFLOW = "workflow",
+    FEATURE = "feature"
+}
+/**
+ * Healthcheck probe configuration
+ */
+export interface IHealthcheckProbe {
+    type: HealthcheckProbeType;
+    app?: string;
+    database?: string;
+    workflow?: string;
+    feature?: string;
+    event?: string;
+    input?: Record<string, unknown>;
+}
+/**
+ * Notification channel configuration for healthcheck failures
+ */
+export interface IHealthcheckNotificationChannel {
+    push?: {
+        recipients?: string[];
+    };
+    email?: {
+        recipients: string[];
+    };
+    sms?: {
+        recipients: string[];
+    };
+    callback?: {
+        data?: Record<string, unknown>;
+    };
+}
+/**
+ * Notification configuration for healthcheck failures
+ */
+export interface IHealthcheckNotification {
+    notification: string;
+    message: string;
+    channels: IHealthcheckNotificationChannel;
+}
+/**
+ * Webhook configuration for healthcheck failures
+ */
+export interface IHealthcheckWebhook {
+    url: string;
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH';
+    headers?: Record<string, string>;
+    body?: Record<string, unknown>;
+}
+/**
+ * Event emission configuration for healthcheck failures
+ */
+export interface IHealthcheckEmit {
+    event: string;
+    data?: Record<string, unknown>;
+}
+/**
+ * On-failure configuration for healthchecks
+ */
+export interface IHealthcheckOnFailure {
+    notifications?: IHealthcheckNotification[];
+    webhooks?: IHealthcheckWebhook[];
+    emit?: IHealthcheckEmit[];
+}
+/**
+ * Product healthcheck configuration
+ * Supports both simple app/event format and advanced probe configuration
+ */
+export interface IProductAppHealth {
+    _id?: string;
+    name?: string;
+    description?: string;
+    tag: string;
+    app?: string;
+    event?: string;
+    probe?: IHealthcheckProbe;
+    interval: number;
+    retries: number;
+    onFailure?: IHealthcheckOnFailure;
+    envs: CheckEnvStatus[];
+}
+export interface CheckEnvStatus {
+    slug: string;
+    status?: string;
+    lastAvailable?: string;
+    lastChecked?: string;
+    lastLatency?: string;
+    averageLatency?: string;
+    input?: any;
+}
 export interface IProductAppAuth {
     auth_tag: string;
     data: IActionRequest | string;
@@ -75,7 +176,7 @@ export interface IProductSession {
     expiry: number;
     period: TokenPeriods;
     selector: string;
-    selectorValue: Array<IParsedSample>;
+    selectorValue?: Array<IParsedSample>;
     schema: Record<string, unknown>;
     schema_data?: Array<IParsedSample>;
     tag: string;
@@ -84,6 +185,8 @@ export interface IProductSession {
 }
 export interface IProductApp {
     _id?: string;
+    app_tag?: string;
+    pricing_tag?: string;
     access_tag: string;
     version?: string;
     envs: Array<IProductAppEnvs>;
@@ -152,16 +255,43 @@ export interface MigrationEnv {
         reason?: any;
     }>;
 }
+/**
+ * Migration operation type - supports both simple SQL strings and rich operations
+ * Simple format: Raw SQL/CQL strings for direct execution
+ * Rich format: Structured operations that get translated by database adapters
+ */
+export type MigrationOperationValue = string | IMigrationOperationObject;
+/**
+ * Structured migration operation (database-agnostic)
+ * Gets translated to database-specific commands by the adapter
+ */
+export interface IMigrationOperationObject {
+    /** Operation type */
+    type: 'createCollection' | 'dropCollection' | 'createIndex' | 'dropIndex' | 'addField' | 'dropField' | 'renameField' | 'modifyField' | 'addConstraint' | 'dropConstraint' | 'raw';
+    /** Operation-specific properties */
+    [key: string]: any;
+}
 export interface IProductDatabaseMigration {
+    /** Human-readable name */
     name: string;
+    /** Description of what this migration does */
     description?: string;
+    /** Unique tag for this migration */
     tag: string;
+    /** Migration operations (up and down) */
     value: {
-        up: Array<string>;
-        down: Array<string>;
+        /** Operations to apply the migration */
+        up: Array<MigrationOperationValue>;
+        /** Operations to rollback the migration */
+        down: Array<MigrationOperationValue>;
     };
+    /** Dependencies - migrations that must run first */
+    dependencies?: string[];
+    /** Environment-specific execution status */
     envs?: MigrationEnv[];
+    /** Timestamp when migration was created */
     created_at?: string;
+    /** Timestamp when migration was last updated */
     updated_at?: string;
 }
 export interface IProductDatabase {
@@ -173,6 +303,73 @@ export interface IProductDatabase {
     type: DatabaseTypes;
     actions?: IProductDatabaseAction[];
     migrations?: IProductDatabaseMigration[];
+    triggers?: IProductDatabaseTrigger[];
+}
+/**
+ * Graph database environment configuration
+ */
+export interface IProductGraphEnvs {
+    slug: string;
+    connection_url: string;
+    description?: string;
+    /** Database name (ArangoDB) */
+    database?: string;
+    /** Graph name (ArangoDB) */
+    graphName?: string;
+    /** AWS region (Neptune) */
+    region?: string;
+    /** Username for authentication (Neo4j) */
+    username?: string;
+    /** Password for authentication (Neo4j) */
+    password?: string;
+}
+/**
+ * Supported graph database types
+ */
+export declare enum GraphTypes {
+    NEO4J = "neo4j",
+    NEPTUNE = "neptune",
+    ARANGODB = "arangodb",
+    MEMGRAPH = "memgraph"
+}
+/**
+ * Graph action parameter definition
+ */
+export interface IProductGraphActionParameter {
+    name: string;
+    path: string;
+    defaultValue: any;
+    type: 'string' | 'number' | 'boolean' | 'array' | 'object';
+    description?: string;
+    required?: boolean;
+}
+/**
+ * Graph action definition (saved parameterized query)
+ */
+export interface IProductGraphAction {
+    id: string;
+    tag: string;
+    name: string;
+    description?: string;
+    operation: string;
+    query: Record<string, any>;
+    parameters: IProductGraphActionParameter[];
+    createdAt: string;
+    updatedAt?: string;
+    graphTag?: string;
+}
+/**
+ * Product graph database configuration
+ */
+export interface IProductGraph {
+    _id?: string;
+    name: string;
+    description?: string;
+    tag: string;
+    envs: IProductGraphEnvs[];
+    type: GraphTypes;
+    /** Saved graph actions (parameterized queries) */
+    actions?: IProductGraphAction[];
 }
 export declare enum DatabaseActionTypes {
     READ = "read",
@@ -182,6 +379,393 @@ export declare enum DatabaseActionTypes {
     DELETE = "delete",
     AGGREGATE = "aggregate"
 }
+/**
+ * Supported vector database types
+ */
+export declare enum VectorDBTypes {
+    PINECONE = "pinecone",
+    QDRANT = "qdrant",
+    WEAVIATE = "weaviate",
+    CHROMA = "chroma",
+    MILVUS = "milvus",
+    PGVECTOR = "pgvector",
+    MEMORY = "memory"
+}
+/**
+ * Distance metrics for vector similarity
+ */
+export declare enum VectorDistanceMetrics {
+    COSINE = "cosine",
+    EUCLIDEAN = "euclidean",
+    DOT_PRODUCT = "dotproduct"
+}
+/**
+ * Vector database environment configuration
+ */
+export interface IProductVectorEnvs {
+    /** Environment slug (e.g., 'dev', 'stg', 'prd') */
+    slug: string;
+    /** API endpoint URL */
+    endpoint?: string;
+    /** API key (encrypted) */
+    apiKey?: string;
+    /** Cloud region */
+    region?: string;
+    /** Index/collection name */
+    index?: string;
+    /** Default namespace */
+    namespace?: string;
+    /** Whether this env is active */
+    active?: boolean;
+    /** Description */
+    description?: string;
+}
+/**
+ * Product vector database configuration
+ */
+export interface IProductVector {
+    _id?: string;
+    /** Display name */
+    name: string;
+    /** Unique tag identifier */
+    tag: string;
+    /** Description */
+    description?: string;
+    /** Vector database type */
+    type: VectorDBTypes;
+    /** Vector dimensions */
+    dimensions: number;
+    /** Distance metric for similarity */
+    metric?: VectorDistanceMetrics;
+    /** Environment configurations */
+    envs: IProductVectorEnvs[];
+    /** Created timestamp */
+    created_at?: Date;
+    /** Updated timestamp */
+    updated_at?: Date;
+}
+/**
+ * Supported LLM providers
+ */
+export type LLMProvider = 'anthropic' | 'openai' | 'google' | 'cohere' | 'custom';
+/**
+ * LLM model environment configuration
+ */
+export interface IProductLLMModelEnv {
+    /** Environment slug (e.g., 'dev', 'stg', 'prd') */
+    slug: string;
+    /** API key (encrypted with product private_key) */
+    apiKey?: string;
+    /** API base URL override for this environment */
+    baseUrl?: string;
+    /** Whether this env is active */
+    active?: boolean;
+    /** Description */
+    description?: string;
+}
+/**
+ * Product LLM model configuration
+ * Reusable model configurations that can be referenced by agents
+ */
+export interface IProductLLMModel {
+    _id?: string;
+    /** Unique tag identifier */
+    tag: string;
+    /** Display name */
+    name: string;
+    /** Description */
+    description?: string;
+    /** LLM provider */
+    provider: LLMProvider;
+    /** Model identifier (e.g., 'claude-sonnet-4-20250514', 'gpt-4-turbo') */
+    model: string;
+    /** Default sampling temperature (0-2) */
+    temperature?: number;
+    /** Default maximum tokens to generate */
+    maxTokens?: number;
+    /** Default top-p sampling */
+    topP?: number;
+    /** Default stop sequences */
+    stopSequences?: string[];
+    /** Default request timeout in ms */
+    timeout?: number;
+    /** Environment configurations with API keys */
+    envs: IProductLLMModelEnv[];
+    /** Created timestamp */
+    created_at?: Date;
+    /** Updated timestamp */
+    updated_at?: Date;
+}
+/**
+ * Supported LLM providers for agents
+ * @deprecated Use LLMProvider instead
+ */
+export type AgentLLMProvider = 'anthropic' | 'openai' | 'google' | 'cohere' | 'custom';
+/**
+ * Tool parameter types
+ */
+export type AgentToolParamType = 'string' | 'number' | 'boolean' | 'array' | 'object';
+/**
+ * Tool parameter definition (JSON-serializable)
+ */
+export interface IAgentToolParam {
+    /** Parameter type */
+    type: AgentToolParamType;
+    /** Description for LLM */
+    description: string;
+    /** Whether parameter is required */
+    required?: boolean;
+    /** Enum values for constrained inputs */
+    enum?: string[];
+    /** Default value */
+    default?: unknown;
+    /** For array types, the item type */
+    items?: IAgentToolParam;
+    /** For object types, nested properties */
+    properties?: Record<string, IAgentToolParam>;
+}
+/**
+ * Agent tool schema (without handler - JSON-serializable for storage)
+ */
+export interface IProductAgentToolSchema {
+    /** Unique tool identifier */
+    tag: string;
+    /** Human-readable name */
+    name?: string;
+    /** Description for LLM to understand when to use this tool */
+    description: string;
+    /** Input parameter schema */
+    parameters: Record<string, IAgentToolParam>;
+    /** Whether this tool requires human confirmation before execution */
+    requiresConfirmation?: boolean;
+    /** Estimated cost for quota tracking */
+    costEstimate?: number;
+    /** Timeout for this tool in ms */
+    timeout?: number;
+    /** Number of retries on failure */
+    retries?: number;
+    /**
+     * Handler reference - maps to a Ductape component for portable execution
+     * Format: "type:tag:event" (e.g., "action:payment-app:process-payment")
+     */
+    handlerRef?: string;
+    /** Tool-level resilience configuration */
+    resilience?: IProductAgentToolResilienceConfig;
+}
+/**
+ * LLM model configuration for agents
+ */
+export interface IProductAgentLLMConfig {
+    /** LLM provider */
+    provider: AgentLLMProvider;
+    /** Model identifier (e.g., 'claude-sonnet-4-20250514', 'gpt-4') */
+    model: string;
+    /** Sampling temperature (0-1) */
+    temperature?: number;
+    /** Maximum tokens to generate */
+    maxTokens?: number;
+    /** Top-p sampling */
+    topP?: number;
+    /** Stop sequences */
+    stopSequences?: string[];
+    /** API key reference (secret name, not actual key) */
+    apiKeyRef?: string;
+    /** API base URL for custom providers */
+    baseUrl?: string;
+    /** Request timeout in ms */
+    timeout?: number;
+}
+/**
+ * Model configuration overrides
+ * Applied at agent/env level to override settings from the model entity
+ */
+export interface IProductAgentModelConfigOverrides {
+    /** Override temperature */
+    temperature?: number;
+    /** Override max tokens */
+    maxTokens?: number;
+    /** Override top-p sampling */
+    topP?: number;
+    /** Override stop sequences */
+    stopSequences?: string[];
+    /** Override timeout in ms */
+    timeout?: number;
+}
+/**
+ * Short-term memory configuration
+ */
+export interface IProductAgentShortTermMemory {
+    /** Maximum messages to keep in context */
+    maxMessages?: number;
+    /** Summarize conversation after this many messages */
+    summarizeAfter?: number;
+    /** Include tool call results in context */
+    includeToolResults?: boolean;
+    /** Strategy for truncation */
+    truncationStrategy?: 'fifo' | 'sliding_window' | 'summarize';
+}
+/**
+ * Long-term memory configuration
+ */
+export interface IProductAgentLongTermMemory {
+    /** Enable long-term memory */
+    enabled: boolean;
+    /** Vector store tag for retrieval */
+    vectorStore?: string;
+    /** Number of results to retrieve */
+    retrieveTopK?: number;
+    /** Minimum similarity threshold */
+    minSimilarity?: number;
+    /** Automatically store new learnings */
+    autoStore?: boolean;
+    /** Namespace for memory isolation */
+    namespace?: string;
+}
+/**
+ * Agent memory configuration
+ */
+export interface IProductAgentMemoryConfig {
+    /** Short-term (conversation) memory */
+    shortTerm?: IProductAgentShortTermMemory;
+    /** Long-term (persistent) memory */
+    longTerm?: IProductAgentLongTermMemory;
+}
+/**
+ * Agent termination configuration
+ */
+export interface IProductAgentTerminationConfig {
+    /** Maximum number of agent loop iterations */
+    maxIterations?: number;
+    /** Maximum total tokens to use */
+    maxTokens?: number;
+    /** Timeout duration in ms */
+    timeout?: number;
+    /** Allow manual termination via signal */
+    allowManualStop?: boolean;
+}
+/**
+ * Human-in-the-loop configuration
+ */
+export interface IProductAgentHumanInLoopConfig {
+    /** Enable human-in-the-loop */
+    enabled: boolean;
+    /** Tools that always require approval */
+    alwaysRequireApproval?: string[];
+    /** Default timeout for approval requests in ms */
+    approvalTimeout?: number;
+    /** Webhook to call for approvals */
+    approvalWebhook?: string;
+    /** Broker topic to publish approval requests */
+    approvalBroker?: {
+        broker: string;
+        event: string;
+    };
+}
+/**
+ * Agent streaming configuration
+ */
+export interface IProductAgentStreamConfig {
+    /** Enable streaming */
+    enabled: boolean;
+    /** Events to stream */
+    events?: string[];
+    /** Webhook to send events to */
+    webhook?: string;
+    /** Broker to publish events to */
+    broker?: {
+        broker: string;
+        event: string;
+    };
+}
+/**
+ * Environment-specific agent configuration
+ */
+export interface IProductAgentEnvConfig {
+    /** Environment slug */
+    slug: string;
+    /** Whether active in this env */
+    active?: boolean;
+    /** Environment-specific model tag override */
+    model?: string;
+    /** Environment-specific model config overrides */
+    modelConfig?: IProductAgentModelConfigOverrides;
+    /** Environment-specific tool overrides */
+    toolOverrides?: Record<string, Partial<IProductAgentToolSchema>>;
+}
+/**
+ * Tool-level resilience configuration
+ * References existing product-level healthchecks, quotas, and fallbacks by tag
+ */
+export interface IProductAgentToolResilienceConfig {
+    /** Tag of an existing quota to use for this tool */
+    quota?: string;
+    /** Tag of an existing fallback to use for this tool */
+    fallback?: string;
+    /** Tag of an existing healthcheck to verify before execution */
+    healthcheck?: string;
+}
+/**
+ * Agent-level resilience configuration
+ * References existing product-level healthchecks, quotas, and fallbacks
+ *
+ * Note: Healthchecks, quotas, and fallbacks must be defined at the product level
+ * (in product.healthchecks, product.quota, product.fallback arrays).
+ * Agents can only reference existing configurations by tag.
+ */
+export interface IProductAgentResilienceConfig {
+    /** Default resilience settings applied to all tools */
+    defaults?: {
+        /** Tag of an existing quota to use by default */
+        quota?: string;
+        /** Tag of an existing fallback to use by default */
+        fallback?: string;
+        /** Tag of an existing healthcheck to verify before tool execution */
+        healthcheck?: string;
+    };
+    /** Tool-specific resilience overrides (keyed by tool tag) */
+    toolOverrides?: Record<string, IProductAgentToolResilienceConfig>;
+}
+/**
+ * Product agent configuration (stored in database)
+ */
+export interface IProductAgent {
+    _id?: string;
+    /** Unique agent tag */
+    tag: string;
+    /** Human-readable name */
+    name: string;
+    /** Agent description */
+    description?: string;
+    /**
+     * Model tag referencing a model configuration defined at the product level.
+     * Model configurations are managed via product.createModel() or the Ductape dashboard.
+     */
+    model: string;
+    /** Agent-level model config overrides */
+    modelConfig?: IProductAgentModelConfigOverrides;
+    /** System prompt defining agent behavior */
+    systemPrompt: string;
+    /** Tool schemas (without handlers for storage) */
+    tools: IProductAgentToolSchema[];
+    /** Termination configuration */
+    termination?: IProductAgentTerminationConfig;
+    /** Memory configuration */
+    memory?: IProductAgentMemoryConfig;
+    /** Human-in-the-loop configuration */
+    humanInLoop?: IProductAgentHumanInLoopConfig;
+    /** Streaming configuration */
+    streaming?: IProductAgentStreamConfig;
+    /** Input schema validation */
+    inputSchema?: Record<string, IAgentToolParam>;
+    /** Environment configurations */
+    envs?: IProductAgentEnvConfig[];
+    /** Resilience configuration (healthchecks, quotas, fallbacks) */
+    resilience?: IProductAgentResilienceConfig;
+    /** Created timestamp */
+    created_at?: Date;
+    /** Updated timestamp */
+    updated_at?: Date;
+}
 export interface IProductDatabaseAction {
     _id?: string;
     name: string;
@@ -225,9 +809,14 @@ export declare enum JobEventTypes {
     ACTION = "action",
     NOTIFICATION = "notification",
     DATABASE_ACTION = "database_action",
-    FUNCTION = "function",
+    DATABASE_OPERATION = "database_operation",
+    GRAPH_ACTION = "graph_action",
+    GRAPH_OPERATION = "graph_operation",
+    WORKFLOW = "workflow",
     STORAGE = "storage",
-    PUBLISH = "publish"
+    PUBLISH = "publish",
+    FALLBACK = "fallback",
+    QUOTA = "quota"
 }
 export interface IProductJobs {
     _id?: string;
@@ -325,6 +914,8 @@ export interface IFeatureEvent {
     env?: IProductEnv;
     return?: boolean;
     cache?: string;
+    start_at?: number;
+    hasProduct?: boolean;
 }
 export declare enum Conditions {
     LOOP = "loop",
@@ -355,7 +946,7 @@ export interface IParseInputStringInput {
     datapoint: IParsedSample;
     value: string;
     input: Record<string, unknown>;
-    stages: Array<string>;
+    stages: Array<string | number>;
 }
 export interface IParseInputStringMetaData {
     feature?: Partial<IProductFeature>;
@@ -393,9 +984,13 @@ export interface IQuotaOptions extends IFallbackOptions {
     quota: number;
     uses?: number;
 }
+/**
+ * Fallback options configuration
+ * Note: Features are deprecated - use workflows instead
+ */
 export interface IFallbackOptions {
     app?: string;
-    type: FeatureEventTypes.FEATURE | FeatureEventTypes.ACTION;
+    type: FeatureEventTypes.ACTION;
     event: string;
     input: IActionRequest | Record<string, unknown>;
     output: Record<string, unknown>;
@@ -418,6 +1013,113 @@ export interface IProductFallback {
     input: Record<string, IFeatureInput>;
     options: Array<IFallbackOptions>;
 }
+export declare enum WorkflowStepType {
+    ACTION = "action",
+    DATABASE_ACTION = "database_action",
+    NOTIFICATION = "notification",
+    STORAGE = "storage",
+    PUBLISH = "publish",
+    FEATURE = "feature",
+    QUOTA = "quota",
+    FALLBACK = "fallback",
+    GRAPH = "graph",
+    CHILD_WORKFLOW = "child_workflow",
+    SLEEP = "sleep",
+    WAIT_FOR_SIGNAL = "wait_for_signal",
+    CHECKPOINT = "checkpoint"
+}
+export declare enum WorkflowRollbackStrategy {
+    REVERSE_ALL = "reverse_all",
+    REVERSE_CRITICAL = "reverse_critical",
+    COMPENSATE = "compensate",
+    NONE = "none"
+}
+export declare enum WorkflowStatus {
+    PENDING = "pending",
+    RUNNING = "running",
+    COMPLETED = "completed",
+    FAILED = "failed",
+    ROLLED_BACK = "rolled_back",
+    ROLLING_BACK = "rolling_back",
+    PAUSED = "paused"
+}
+export interface IWorkflowStepRollback {
+    type: WorkflowStepType;
+    app?: string;
+    database?: string;
+    graph?: string;
+    storage?: string;
+    notification?: string;
+    broker?: string;
+    event?: string;
+    input?: Record<string, unknown>;
+    retries?: number;
+    continue_on_failure?: boolean;
+}
+export interface IWorkflowStepOptions {
+    timeout?: number;
+    retries?: number;
+    retry_interval?: number;
+    retry_backoff?: 'constant' | 'linear' | 'exponential';
+    optional?: boolean;
+    critical?: boolean;
+    allow_fail?: boolean;
+    rollback_timeout?: number;
+    rollback_retries?: number;
+    continue_on_rollback_failure?: boolean;
+    cache?: string;
+}
+export interface IProductWorkflowStep {
+    tag: string;
+    name?: string;
+    type: WorkflowStepType;
+    app?: string;
+    database?: string;
+    graph?: string;
+    storage?: string;
+    notification?: string;
+    broker?: string;
+    quota?: string;
+    fallback?: string;
+    workflow?: string;
+    event: string;
+    input: Record<string, unknown>;
+    depends_on?: string[];
+    condition?: string;
+    options?: IWorkflowStepOptions;
+    rollback?: IWorkflowStepRollback;
+}
+export interface IWorkflowSignal {
+    name: string;
+    input?: Record<string, string>;
+}
+export interface IWorkflowQuery {
+    name: string;
+    handler?: string;
+}
+export interface IWorkflowOptions {
+    timeout?: number;
+    retries?: number;
+    rollback_strategy?: WorkflowRollbackStrategy;
+    idempotency_key?: string;
+}
+export interface IWorkflowEnv {
+    slug: string;
+    active?: boolean;
+}
+export interface IProductWorkflow {
+    _id?: string;
+    name: string;
+    description?: string;
+    tag: string;
+    input?: Record<string, unknown>;
+    output?: Record<string, unknown>;
+    steps: IProductWorkflowStep[];
+    signals?: Record<string, IWorkflowSignal>;
+    queries?: Record<string, IWorkflowQuery>;
+    options?: IWorkflowOptions;
+    envs?: IWorkflowEnv[];
+}
 export declare enum FeatureEventTypes {
     ACTION = "action",
     FEATURE = "feature",
@@ -438,7 +1140,8 @@ export declare enum MessageBrokerTypes {
     KAFKA = "kafka",
     AWS_SQS = "aws_sqs",
     REDIS = "redis",
-    GOOGLE_PUBSUB = "google_pubsub"
+    GOOGLE_PUBSUB = "google_pubsub",
+    NATS = "nats"
 }
 export declare enum InputDataSources {
     INPUT = "input",
@@ -481,29 +1184,31 @@ export interface IStorageRequest extends IRequest {
 export interface RedisConfig {
     host: string;
     port: number;
-    channel: string;
     password?: string;
 }
 export interface GooglePubSubConfig {
     projectId: string;
-    topicName: string;
-    subscriptionName?: string;
-    keyFilename: string;
+    credentials: {
+        type?: string;
+        project_id?: string;
+        private_key_id?: string;
+        private_key: string;
+        client_email: string;
+        client_id?: string;
+        auth_uri?: string;
+        token_uri?: string;
+        auth_provider_x509_cert_url?: string;
+        client_x509_cert_url?: string;
+        universe_domain?: string;
+    };
 }
 export interface RabbitMQConfig {
-    host: string;
-    port: number;
-    username: string;
-    password: string;
-    exchange: string;
-    queue: string;
-    routingKey: string;
+    url: string;
 }
 export interface KafkaConfig {
     brokers: string[];
     clientId: string;
-    groupId: string;
-    topic: string;
+    groupId?: string;
     ssl?: boolean;
     sasl?: {
         mechanism: 'plain' | 'scram-sha-256' | 'scram-sha-512';
@@ -513,16 +1218,23 @@ export interface KafkaConfig {
 }
 export interface AWSSQSConfig {
     region: string;
-    queueUrl: string;
     accessKeyId: string;
     secretAccessKey: string;
 }
+export interface NatsConfig {
+    servers: string[];
+    token?: string;
+    user?: string;
+    pass?: string;
+    tls?: boolean;
+}
 export interface MessageBrokerConfig {
     redis?: RedisConfig;
     googlePubSub?: GooglePubSubConfig;
     rabbitMQ?: RabbitMQConfig;
     kafka?: KafkaConfig;
     awsSqs?: AWSSQSConfig;
+    nats?: NatsConfig;
 }
 export interface AWSConfig {
     bucketName: string;
@@ -572,13 +1284,183 @@ export interface IRemoteCache {
     component_tag: string;
     component_type: string;
 }
-export interface IFetchFilesFilter {
+export interface IPaginationOptions {
     page: number;
     limit: number;
+}
+export interface ISessionUser {
+    ductape_user_id: string;
+    product_tag: string;
+    session_tag: string;
+    identifier: string;
+    last_seen: Date;
+    env: string;
+    first_seen: Date;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface IFetchFilesPayload extends IPaginationOptions {
+    product: string;
     event: string;
 }
-export interface IFetchFilesPayload extends IFetchFilesFilter {
+export interface IFetchUsersPayload extends IPaginationOptions {
+    session: string;
     product: string;
 }
 export interface FetchRemoteCachePayload extends Partial<Pick<IRemoteCache, 'cache_tag' | 'component_tag' | 'component_type' | 'expiry' | 'product_tag'>> {
 }
+export declare enum PricingTag {
+    FREE = "free",
+    OVERAGE = "overage"
+}
+/**
+ * Events that can trigger actions
+ */
+export declare enum TriggerEventType {
+    BEFORE_INSERT = "beforeInsert",
+    AFTER_INSERT = "afterInsert",
+    BEFORE_UPDATE = "beforeUpdate",
+    AFTER_UPDATE = "afterUpdate",
+    BEFORE_DELETE = "beforeDelete",
+    AFTER_DELETE = "afterDelete",
+    BEFORE_WRITE = "beforeWrite",
+    AFTER_WRITE = "afterWrite"
+}
+/**
+ * Trigger execution timing
+ */
+export declare enum TriggerTimingType {
+    SYNC = "sync",
+    ASYNC = "async",
+    QUEUED = "queued"
+}
+/**
+ * Types of actions a trigger can perform
+ */
+export declare enum TriggerActionTypes {
+    DATABASE_INSERT = "database.insert",
+    DATABASE_UPDATE = "database.update",
+    DATABASE_DELETE = "database.delete",
+    DATABASE_QUERY = "database.query",
+    STORAGE_UPLOAD = "storage.upload",
+    STORAGE_DELETE = "storage.delete",
+    STORAGE_COPY = "storage.copy",
+    NOTIFICATION_EMAIL = "notification.email",
+    NOTIFICATION_SMS = "notification.sms",
+    NOTIFICATION_PUSH = "notification.push",
+    NOTIFICATION_CALLBACK = "notification.callback",
+    BROKER_PUBLISH = "broker.publish",
+    CACHE_SET = "cache.set",
+    CACHE_INVALIDATE = "cache.invalidate",
+    CACHE_DELETE = "cache.delete",
+    WORKFLOW_EXECUTE = "workflow.execute",
+    WORKFLOW_DISPATCH = "workflow.dispatch",
+    ACTION_EXECUTE = "action.execute",
+    AGENT_RUN = "agent.run",
+    QUOTA_RUN = "quota.run",
+    FALLBACK_RUN = "fallback.run",
+    HEALTHCHECK_RUN = "healthcheck.run",
+    LOG_CREATE = "log.create",
+    SESSION_REVOKE = "session.revoke",
+    VECTOR_UPSERT = "vector.upsert",
+    VECTOR_DELETE = "vector.delete",
+    CUSTOM_FUNCTION = "custom.function",
+    CUSTOM_HTTP = "custom.http"
+}
+/**
+ * Condition operators for trigger conditions
+ */
+export declare enum TriggerConditionOperator {
+    EQUALS = "eq",
+    NOT_EQUALS = "neq",
+    GREATER_THAN = "gt",
+    GREATER_THAN_OR_EQUALS = "gte",
+    LESS_THAN = "lt",
+    LESS_THAN_OR_EQUALS = "lte",
+    IN = "in",
+    NOT_IN = "notIn",
+    CONTAINS = "contains",
+    STARTS_WITH = "startsWith",
+    ENDS_WITH = "endsWith",
+    MATCHES = "matches",
+    IS_NULL = "isNull",
+    IS_NOT_NULL = "isNotNull",
+    IS_EMPTY = "isEmpty",
+    IS_NOT_EMPTY = "isNotEmpty",
+    CHANGED = "changed",
+    NOT_CHANGED = "notChanged",
+    CHANGED_TO = "changedTo",
+    CHANGED_FROM = "changedFrom"
+}
+/**
+ * Retry configuration for trigger actions
+ */
+export interface ITriggerRetryConfig {
+    maxAttempts: number;
+    initialDelay?: number;
+    maxDelay?: number;
+    backoffMultiplier?: number;
+    retryOn?: string[];
+}
+/**
+ * Condition clause for trigger evaluation
+ */
+export interface ITriggerConditionClause {
+    field: string;
+    operator: TriggerConditionOperator;
+    value?: any;
+}
+/**
+ * Trigger condition (can be simple or compound)
+ */
+export interface ITriggerConditionConfig {
+    $and?: (ITriggerConditionClause | ITriggerConditionConfig)[];
+    $or?: (ITriggerConditionClause | ITriggerConditionConfig)[];
+    $not?: ITriggerConditionClause | ITriggerConditionConfig;
+    field?: string;
+    operator?: TriggerConditionOperator;
+    value?: any;
+}
+/**
+ * Base configuration for trigger actions
+ */
+export interface ITriggerActionConfig {
+    type: TriggerActionTypes;
+    name?: string;
+    condition?: ITriggerConditionConfig;
+    timing?: TriggerTimingType;
+    retry?: ITriggerRetryConfig;
+    timeout?: number;
+    continueOnError?: boolean;
+    config: Record<string, any>;
+}
+/**
+ * Database trigger stored on backend
+ */
+export interface IProductDatabaseTrigger {
+    _id?: string;
+    /** Tag in format database_tag:trigger_tag */
+    tag: string;
+    /** Human-readable name */
+    name: string;
+    /** Description */
+    description?: string;
+    /** Events that activate this trigger */
+    events: TriggerEventType[];
+    /** Tables this trigger applies to (empty = all tables) */
+    tables?: string[];
+    /** Condition to evaluate before running actions */
+    condition?: ITriggerConditionConfig;
+    /** Actions to execute */
+    actions: ITriggerActionConfig[];
+    /** Whether trigger is enabled */
+    enabled?: boolean;
+    /** Priority (lower = higher priority) */
+    priority?: number;
+    /** Tags for organization */
+    tags?: string[];
+    /** Created timestamp */
+    created_at?: Date;
+    /** Updated timestamp */
+    updated_at?: Date;
+}