@ductape/sdk 0.0.4-v51 → 0.0.4-v53

package/dist/index.d.ts

@@ -1,9 +1,18 @@
-import { DatabaseService } from './database/database.service';
-import { GraphService } from './graph/graph.service';
-import { ImportDocsTypes, IApp, IAppConstants, IAppEnv, IAppVariables, IAppWebhook, IAppWebhookEvent, ICreateAppBuilder, IProduct, IProductApp, IProductCache, IProductDatabase, IProductDatabaseAction, IProductEnv, IProductFeature, IProductJobs, IProductStorage, IProcessorInput, IActionProcessorInput, IDBActionProcessorInput, IProductMessageBroker, IProductNotification, INotificationProcessorInput, IProductNotificationTemplate, IStorageProcessorInput, IParsedSample, IGenerateWebhookLink, IAppAuth, IMessageBrokerPublishInput, IMessageBrokerSubscribeInput, IProductMessageBrokerTopic, IAppAction, IProductDatabaseMigration, IProductGraph, LogQueryParams, IProductQuota, FetchRemoteCachePayload, IFileReadResult, IProductSession, ISessionInput, IActionUpdate, IProductFallback, IFetchFilesPayload, ISessionPayload, ISessionRefreshPayload, IFetchUsersPayload, IProductAppHealth } from './types';
+import { ImportDocsTypes, IApp, IAppConstants, IAppEnv, IAppVariables, IAppWebhook, IAppWebhookEvent, ICreateAppBuilder, IProduct, IProductApp, IProductCache, IProductDatabase, IProductEnv, IProductJobs, IProductStorage, IActionProcessorInput, IProductMessageBroker, IProductNotification, INotificationProcessorInput, IProductNotificationTemplate, IStorageProcessorInput, IParsedSample, IRegisterWebhook, IGenerateWebhookLink, IAppAuth, IProductMessageBrokerTopic, IAppAction, LogQueryParams, IProductQuota, FetchRemoteCachePayload, IFileReadResult, IProductSession, IActionUpdate, IProductFallback, IFetchUsersPayload, IProductAppHealth, IActionDispatchInput, INotificationDispatchInput, IStorageDispatchInput, IPublishDispatchInput, IDispatchResult } from './types';
 import { IDuctapeInit } from './types/index.types';
 import { PublicStates } from './types/enums';
-import { IWorkspaceSecret } from './api/services/workspaceSecretsApi.service';
+import { DatabaseService, IActionCreateOptions, IActionUpdateOptions, ISimpleSchemaDefinition, ISimpleCreateOptions, ISimpleDropOptions, ISimpleFieldDefinition, SimpleFieldType, ISimpleIndexOptions, ISchemaOperationResult, IIndexFieldDefinition, ITableSchema, IIndexInfo } from './database';
+import { IConstraintDefinition as IMigrationConstraintDefinition } from './database/types/migration.interface';
+import { IDBActionDispatchInput } from './types/processor.types';
+import { GraphService } from './graph';
+import { WorkflowService } from './workflows';
+import { AgentsService } from './agents';
+import { ModelService } from './models';
+import { VectorDatabaseService } from './vector';
+import { IShareCredentialsConfig } from './apps/utils/credential-manager';
+import { IOAuthConfig } from './apps/utils/oauth-manager';
+import { JobsService, JobStatus, IJobListOptions, ICancelOptions, IRetryOptions, IRescheduleOptions, IJobWebhookConfig } from './jobs';
+import { SecretsService, ICreateSecretInput, IUpdateSecretInput, ISecretMetadata, ISecret, IResolveSecretsOptions } from './secrets';
 /**
  * @typedef {Object} IProduct
  * @property {string} tag - Unique product tag.
@@ -210,31 +219,40 @@ import { IWorkspaceSecret } from './api/services/workspaceSecretsApi.service';
  * @property {any} input - Health check input data.
  * @see ts/src/types/productsBuilder.types.ts
  */
-export interface IDuctapeSecrets {
-    _privateKey: string | null;
-    fetchPrivateKey(): Promise<string>;
-    create(data: {
-        key: string;
-        value: string;
-        description?: string;
-        token_type?: string;
-        scope?: string[];
-        envs?: string[];
-        expires_at?: number | null;
-    }): Promise<IWorkspaceSecret>;
-    fetchAll(): Promise<IWorkspaceSecret[]>;
-    fetch(key: string): Promise<IWorkspaceSecret & {
-        value: string;
-    }>;
-    update(key: string, data: {
-        value?: string;
-        description?: string;
-        expires_at?: number | null;
-    }): Promise<IWorkspaceSecret>;
-    delete(key: string): Promise<boolean>;
-}
+export { GraphService } from './graph';
+export { GraphType, TraversalDirection, NodeIndexType, NodeConstraintType, GraphIsolationLevel, GraphTransactionStatus, GraphErrorType, GraphFeature, GraphSortOrder, } from './graph';
+export type { IGraphEnvConfig, IGraphConfig, IGraphConnectionConfig, IGraphConnectionOptions, IGraphConnectionResult, IGraphConnectionContext, IGraphServiceConfig, IGraphTestConnectionResult, IGraphFilterOperator, IGraphWhereClause, IRawQueryOptions, IRawQueryResult, ICountNodesOptions, ICountNodesResult, ICountRelationshipsOptions, ICountRelationshipsResult, IGraphStatistics, IFullTextSearchOptions, IFullTextSearchResult, IVectorSearchOptions, IVectorSearchResult, NodeProperties, INode, ICreateNodeOptions, ICreateNodeResult, IFindNodesOptions, IGraphOrderBy, IFindNodesResult, IUpdateNodeOptions, INodePropertyUpdate, IUpdateNodeResult, IDeleteNodeOptions, IDeleteNodeResult, IMergeNodeOptions, IMergeNodeResult, INodeFilter, RelationshipProperties, IRelationship, ICreateRelationshipOptions, ICreateRelationshipResult, IFindRelationshipsOptions, IFindRelationshipsResult, IUpdateRelationshipOptions, IRelationshipPropertyUpdate, IUpdateRelationshipResult, IDeleteRelationshipOptions, IDeleteRelationshipResult, IMergeRelationshipOptions, IMergeRelationshipResult, IRelationshipFilter, ICreateRelationshipIndexOptions, IPath, ITraverseOptions, ITraverseResult, IShortestPathOptions, IShortestPathResult, IAllPathsOptions, IAllPathsResult, INeighborhoodOptions, INeighborhoodResult, IConnectedComponentsOptions, IConnectedComponent, IConnectedComponentsResult, IGraphTransaction, IGraphTransactionOptions, TransactionCallback, IGraphTransactionResult, ICreateNodeIndexOptions, ICreateNodeConstraintOptions, IGraphIndex, IGraphConstraint, IListIndexesResult, IListConstraintsResult, ICreateIndexResult, ICreateConstraintResult, IDropIndexResult, IDropConstraintResult, GraphPropertyType, IGraphLabelProperty, IGraphLabel, IListLabelsResult, IGraphRelationshipType, IListRelationshipTypesResult, GraphActionParameterType, IGraphActionParameter, IGraphAction, ICreateGraphActionOptions, IUpdateGraphActionOptions, IExecuteGraphActionOptions, IExecuteGraphActionResult, IListGraphActionsResult, } from './graph';
+export { GraphError } from './graph';
+export { BaseGraphAdapter, Neo4jAdapter, NeptuneAdapter, ArangoDBAdapter, MemgraphAdapter, GraphAdapterFactory, } from './graph';
+export type { IAdapterConnectionOptions } from './graph';
+export { WorkflowService, WorkflowError, workflowService } from './workflows';
+export { WorkflowBuilder, createWorkflow } from './workflows';
+export type { IWorkflowServiceConfig, IWorkflowConfig, IWorkflowContext, IWorkflowContextMeta, IDefineWorkflowOptions, IExecuteWorkflowOptions, IWorkflowExecutionResult, IWorkflowDispatchInput, IWorkflowDispatchResult, IWorkflowSchedule, ISendSignalOptions, IQueryWorkflowOptions, IWorkflowActionContext, IWorkflowDatabaseContext, IWorkflowGraphContext, IWorkflowNotificationContext, IWorkflowStorageContext, IWorkflowPublishContext, IWorkflowFeatureContext, IWorkflowQuotaContext, IWorkflowFallbackContext, IWorkflowHealthcheckContext, WorkflowHandler, IStepBuilder, IRollbackBuilder, IWorkflowBuilder, } from './workflows';
+export { AgentsService, AgentError, agentsService } from './agents';
+export { AgentExecutor, AgentContext, ToolRegistry, MemoryManager, createLLMProvider, AnthropicProvider, OpenAIProvider, VectorServiceAdapter, createVectorStoreAdapter, createPineconeAdapter, createQdrantAdapter, createWeaviateAdapter, createMemoryAdapter, } from './agents';
+export type { IAgentServiceConfig, IDefineAgentOptions, IDefinedAgent, IRunAgentOptions, IAgentExecutionResult, IDispatchAgentOptions, IDispatchAgentResult, ISendAgentSignalOptions, IAgentStatusOptions, IAgentState, IListAgentExecutionsOptions, IAgentExecutionListResult, IAgentTool, IAgentToolSchema, IToolParam, IToolCallResult, ILLMConfig, LLMProvider, IAgentMemoryConfig, IAgentTerminationConfig, IAgentStreamEvent, IAgentToolContext, IConversationMessage, ITokenUsage, AgentStatus, IHumanInLoopConfig, IApprovalRequest, IApprovalResponse, IMultiAgentWorkflow, MultiAgentMode, } from './agents';
+export { StorageService, StorageError } from './storage';
+export { uploadBlobToCloud, downloadBlobFromCloud, deleteBlobFromCloud, listBlobsInCloud, generateSignedUrl, } from './storage';
+export type { IStorageServiceConfig, IUploadOptions, IDownloadOptions, IDeleteOptions, IListFilesOptions, ISignedUrlOptions, IStorageResult, IDownloadResult, IDeleteResult as IStorageDeleteResult, IListFilesResult, ISignedUrlResult, IStorageDispatchOptions, IStorageDispatchResult, IStorageProviderConfig, IStorageFileInfo, } from './storage';
+export { SessionsService, SessionError } from './sessions';
+export type { ISessionServiceConfig, ICreateSessionOptions, IRefreshSessionOptions, IVerifySessionOptions, IRevokeSessionOptions, IListSessionsOptions, IDefineSessionOptions, ISessionResult, IVerifyResult, IListSessionsResult, ISessionInfo, ISessionSchema, ISessionSchemaField, ISessionContext, IDefinedSession, } from './sessions';
+export { CacheService, CacheError } from './cache';
+export type { ICacheServiceConfig, ICacheValue, IFetchCacheValuesOptions, IFetchCacheValuesResult, IFetchCacheDashboardOptions, ICacheDashboardMetrics, IClearCacheValueOptions, IClearCacheValuesOptions, IClearCacheValuesResult, ISetCacheValueOptions, IGetCacheValueOptions, IDeleteCacheValueOptions, IDeleteCacheValuesOptions, IDeleteCacheValuesResult, } from './cache';
+export { BrokersService, BrokerError } from './brokers';
+export { RabbitMQService, KafkaService, SQSService, RedisService, GooglePubSubService, loadBrokerService, parseEventString, isValidSqsUrl, getSqsQueueUrl, } from './brokers';
+export type { IBrokerServiceConfig, IPublishOptions, ISubscribeOptions, IPublishResult, ISubscribeResult, IMessageBrokerService, BrokerConfig, IBrokerBootstrapData, IBrokerDispatchOptions, } from './brokers';
+export { NotificationsService, notificationsService } from './notifications';
+export { NotificationChannelType, PushNotificationProvider, SmsProvider } from './notifications';
+export type { IFirebaseCredential, IPushNotificationHandler, IPushNotificationInput, IPushOptions, IEmailHandler, IEmailInput, IEmailOptions, ISmsHandler, ISmsInput, ISmsOptions, ICallbackHandler, ICallbackInput, ICallbackOptions, INotificationTemplate, INotificationEnvConfig, INotificationDefinition, INotificationsServiceConfig, INotificationResult, IMultiChannelNotificationResult, INotificationOptions, } from './notifications';
+export { VectorDatabaseService, VectorService, createVectorService, createMemoryVectorService, VectorError, } from './vector';
+export type { IVectorDatabaseServiceConfig, ICreateVectorDbOptions, IVectorDbEnvConfig, IUpdateVectorDbOptions, IFetchVectorOptions, IDeleteVectorConfigOptions, IProductVectorQueryOptions, IProductVectorUpsertOptions, IProductVectorFetchOptions, IProductVectorDeleteOptions, } from './vector';
+export { BaseVectorAdapter, PineconeAdapter, QdrantAdapter, WeaviateAdapter, MemoryAdapter } from './vector';
+export { VectorDBType, DistanceMetric, VectorIndexType, VectorErrorType, VectorFeature } from './vector';
+export type { IVectorServiceOptions, IAdapterConnectionOptions as IVectorAdapterConnectionOptions, IVectorEnvConfig, IVectorConfig, IVectorConnectionConfig, IVectorConnectionOptions, IVectorConnectionResult, IVectorConnectionContext, IVectorServiceConfig, IVectorTestConnectionResult, VectorMetadata, IVector, ISparseVector, IUpsertVectorsOptions, IUpsertVectorsResult, IMetadataFilter, MetadataFilterOperator, IMetadataFilterGroup, IQueryVectorsOptions, IQueryMatch, IQueryVectorsResult, IFetchVectorsOptions, IFetchVectorsResult, IUpdateVectorOptions, IUpdateVectorResult, IDeleteVectorsOptions, IDeleteVectorsResult, IListVectorsOptions, IListVectorsResult, INamespaceInfo, IListNamespacesResult, IVectorIndexInfo, ICreateIndexOptions as IVectorCreateIndexOptions, ICreateIndexResult as IVectorCreateIndexResult, IDeleteIndexOptions as IVectorDeleteIndexOptions, IDeleteIndexResult as IVectorDeleteIndexResult, IVectorIndexStats, EmbeddingProvider, IEmbeddingModelConfig, IEmbedOptions, IEmbeddingResult, IBatchEmbeddingResult, IEmbeddingProvider, IOpenAIEmbeddingConfig, ICohereEmbeddingConfig, IVoyageEmbeddingConfig, IJinaEmbeddingConfig, IHuggingFaceEmbeddingConfig, ILocalEmbeddingConfig, } from './vector';
+export { SecretsService } from './secrets';
+export { SECRET_PATTERN, SECRET_PATTERN_GLOBAL, SecretNotFoundError, SecretScopeError, SecretEnvironmentError, SecretExpiredError, SecretRevokedError, SecretResolutionError, isSecretReference, containsSecretReferences, extractSecretKeys, findAllSecretReferences, mightContainSecrets, } from './secrets';
+export type { SecretTokenType, ICreateSecretInput, IUpdateSecretInput, ISecretMetadata, ISecret, ISecretCheck, IResolveSecretsOptions, ISecretResolutionResult, ISecretsServiceConfig, ISecretsService, } from './secrets';
 export interface IDuctape {
-    secrets: IDuctapeSecrets;
 }
 export default class Ductape implements IDuctape {
     private user_id;
@@ -249,15 +267,19 @@ export default class Ductape implements IDuctape {
     private appApi;
     private productsApi;
     private workspaceApi;
-    private secretsApi;
-    private productBuilder;
+    private productBuilders;
+    private appBuilders;
+    private _databaseService;
+    private _graphService;
+    private _workflowService;
+    private _agentsService;
+    private _modelService;
+    private _vectorService;
+    private _cacheService;
+    private _jobsService;
+    private _secretsService;
     private loggerService;
-    private appBuilder;
     private importService;
-    private databaseService;
-    private graphService;
-    private productInit;
-    private appInit;
     private environment;
     private redis_url;
     private redisClient?;
@@ -295,12 +317,12 @@ export default class Ductape implements IDuctape {
      * @param {string} public_key - The public key.
      */
     setPublicKey(public_key: string): void;
-    private initProduct;
-    private initApp;
-    private checkProductInit;
-    private checkAppInit;
+    private getProductBuilder;
+    private getAppBuilder;
+    private initProductBuilder;
+    private initAppBuilder;
     /**
-     * Product-related operations for managing products, sessions, apps, quotas, and fallbacks.
+     * Product-related operations for managing products.
      */
     product: {
         /**
@@ -323,81 +345,99 @@ export default class Ductape implements IDuctape {
          */
         update: (tag: string, data: Partial<IProduct>) => Promise<void>;
         /**
-         * Initializes a product by tag.
-         * @param {string} productTag - The product tag.
+         * Initializes a product by tag (pre-loads builder into cache).
+         * @param {string} product - The product tag.
          * @returns {Promise<void>} Resolves when initialization is complete. Throws on error.
          */
-        init: (productTag: string) => Promise<void>;
-        sessions: {
-            /**
-             * Creates a new product session.
-             * @param {IProductSession} payload - The session payload.
-             * @returns {Promise<void>} Resolves when the session is created. Throws on error.
-             */
-            create: (payload: IProductSession) => Promise<void>;
+        init: (product: string) => Promise<void>;
+        /**
+         * Updates data validation for a product.
+         * @param {string} product - The product tag.
+         * @param {string} tag - The validation tag.
+         * @param {Partial<IParsedSample>} update - The update data.
+         * @returns {Promise<void>} Resolves when the validation is updated. Throws on error.
+         */
+        updateValidation: (product: string, tag: string, update: Partial<IParsedSample>) => Promise<boolean>;
+        environments: {
             /**
-             * Updates a product session by tag.
-             * @param {string} tag - The session tag.
-             * @param {Partial<IProductSession>} payload - The session data to update.
-             * @returns {Promise<void>} Resolves when the session is updated. Throws on error.
+             * Creates an environment for a product.
+             * @param {string} product - The product tag.
+             * @param {IProductEnv} data - The environment data.
+             * @returns {Promise<void>} Resolves when the environment is created. Throws on error.
              */
-            update: (tag: string, payload: Partial<IProductSession>) => Promise<void>;
+            create: (product: string, data: IProductEnv) => Promise<void>;
             /**
-             * Fetches all product sessions.
-             * @returns {IProductSession[]} The list of sessions.
+             * Fetches all environments for a product.
+             * @param {string} product - The product tag.
+             * @returns {IAppEnv[]} The list of environments.
              */
-            fetchAll: () => Promise<IProductSession[]>;
+            list: (product: string) => Promise<IProductEnv[]>;
             /**
-             * Fetches a product session by tag.
-             * @param {string} tag - The session tag.
-             * @returns {IProductSession|null} The fetched session, or null if not found.
+             * Fetches an environment by slug.
+             * @param {string} product - The product tag.
+             * @param {string} slug - The environment slug.
+             * @returns {IAppEnv|null} The fetched environment, or null if not found.
              */
-            fetch: (tag: string) => Promise<IProductSession>;
+            fetch: (product: string, slug: string) => Promise<IProductEnv>;
             /**
-             * Fetches users for a session.
-             * @param {IFetchUsersPayload} data - The user fetch payload.
-             * @returns {Promise<any[]>} The users for the session.
+             * Updates an environment by slug.
+             * @param {string} product - The product tag.
+             * @param {string} slug - The environment slug.
+             * @param {Partial<IProductEnv>} data - The environment data to update.
+             * @returns {Promise<void>} Resolves when the environment is updated. Throws on error.
              */
-            users: (data: IFetchUsersPayload) => Promise<import("./types").IFileURLPayload[]>;
+            update: (product: string, slug: string, data: Partial<IProductEnv>) => Promise<void>;
         };
         apps: {
             /**
              * Connects an app to a product by app tag.
+             * @param {string} product - The product tag.
              * @param {string} appTag - The app tag.
              * @returns {Promise<IAppAccess>} The result of the connection.
              */
-            connect: (appTag: string) => Promise<import("./types").IAppAccess>;
+            connect: (product: string, appTag: string) => Promise<import("./types").IAppAccess>;
             /**
              * Adds an app to a product.
+             * @param {string} product - The product tag.
              * @param {IProductApp} app - The app data.
              * @returns {Promise<void>} Resolves when the app is added. Throws on error.
              */
-            add: (app: IProductApp) => Promise<void>;
+            add: (product: string, app: IProductApp) => Promise<void>;
             /**
              * Fetches all apps for a product.
+             * @param {string} product - The product tag.
              * @returns {IProductApp[]} The list of apps.
              */
-            fetchAll: () => Promise<IProductApp[]>;
+            list: (product: string) => Promise<IProductApp[]>;
             /**
              * Fetches an app by tag.
+             * @param {string} product - The product tag.
              * @param {string} tag - The app tag.
              * @returns {IProductApp|null} The fetched app, or null if not found.
              */
-            fetch: (tag: string) => Promise<IProductApp>;
+            fetch: (product: string, tag: string) => Promise<IProductApp>;
             /**
              * Updates an app by access tag.
+             * @param {string} product - The product tag.
              * @param {string} accessTag - The app access tag.
              * @param {Partial<IProductApp>} data - The app data to update.
              * @returns {Promise<void>} Resolves when the app is updated. Throws on error.
              */
-            update: (accessTag: string, data: Partial<IProductApp>) => Promise<void>;
+            update: (product: string, accessTag: string, data: Partial<IProductApp>) => Promise<void>;
             webhooks: {
                 /**
                  * Fetches all webhooks for an app by access tag.
+                 * @param {string} product - The product tag.
                  * @param {string} accessTag - The app access tag.
                  * @returns {Promise<IAppWebhook[]>} The list of webhooks.
                  */
-                fetchAll: (accessTag: string) => Promise<IAppWebhook[]>;
+                list: (product: string, accessTag: string) => Promise<IAppWebhook[]>;
+                /**
+                 * Enables a webhook for an app.
+                 * @param {IRegisterWebhook} data - The webhook registration data.
+                 * @returns {Promise<void>} Resolves when the webhook is enabled. Throws on error.
+                 */
+                enable: (data: IRegisterWebhook) => Promise<void>;
                 /**
                  * Generates a webhook link for an app.
                  * @param {IGenerateWebhookLink} data - The webhook link data.
@@ -408,443 +448,1522 @@ export default class Ductape implements IDuctape {
             health: {
                 /**
                  * Creates a health check for an app.
+                 * @param {string} product - The product tag.
                  * @param {Partial<IProductAppHealth>} data - The health check data.
                  * @returns {Promise<void>} Resolves when the health check is created. Throws on error.
                  */
-                create: (data: Partial<IProductAppHealth>) => Promise<void>;
+                create: (product: string, data: Partial<IProductAppHealth>) => Promise<void>;
                 /**
                  * Updates a health check by tag.
+                 * @param {string} product - The product tag.
                  * @param {string} tag - The health check tag.
                  * @param {Partial<IProductAppHealth>} data - The health check data to update.
                  * @returns {Promise<void>} Resolves when the health check is updated. Throws on error.
                  */
-                update: (tag: string, data: Partial<IProductAppHealth>) => Promise<void>;
+                update: (product: string, tag: string, data: Partial<IProductAppHealth>) => Promise<void>;
                 /**
                  * Fetches a health check by access tag and tag.
+                 * @param {string} product - The product tag.
                  * @param {string} access_tag - The app access tag.
                  * @param {string} tag - The health check tag.
                  * @returns {Promise<IProductAppHealth|null>} The fetched health check, or null if not found.
                  */
-                fetch: (access_tag: string, tag: string) => Promise<IProductAppHealth>;
+                fetch: (product: string, access_tag: string, tag: string) => Promise<IProductAppHealth>;
                 /**
                  * Fetches all health checks for an app by access tag.
+                 * @param {string} product - The product tag.
                  * @param {string} access_tag - The app access tag.
                  * @returns {Promise<IProductAppHealth[]>} The list of health checks.
                  */
-                fetchAll: (access_tag: string) => Promise<IProductAppHealth[]>;
+                list: (product: string, access_tag: string) => Promise<IProductAppHealth[]>;
             };
         };
+    };
+    /**
+     * Session-related operations for managing product sessions.
+     */
+    sessions: {
+        /**
+         * Creates a new product session.
+         * @param {string} product - The product tag.
+         * @param {IProductSession} payload - The session payload.
+         * @returns {Promise<void>} Resolves when the session is created. Throws on error.
+         */
+        create: (product: string, payload: IProductSession) => Promise<void>;
+        /**
+         * Updates a product session by tag.
+         * @param {string} product - The product tag.
+         * @param {string} tag - The session tag.
+         * @param {Partial<IProductSession>} payload - The session data to update.
+         * @returns {Promise<void>} Resolves when the session is updated. Throws on error.
+         */
+        update: (product: string, tag: string, payload: Partial<IProductSession>) => Promise<void>;
+        /**
+         * Fetches all product sessions.
+         * @param {string} product - The product tag.
+         * @returns {IProductSession[]} The list of sessions.
+         */
+        list: (product: string) => Promise<IProductSession[]>;
+        /**
+         * Fetches a product session by tag.
+         * @param {string} product - The product tag.
+         * @param {string} tag - The session tag.
+         * @returns {IProductSession|null} The fetched session, or null if not found.
+         */
+        fetch: (product: string, tag: string) => Promise<IProductSession>;
+        /**
+         * Fetches users for a session.
+         * @param {string} product - The product tag.
+         * @param {IFetchUsersPayload} data - The user fetch payload.
+         * @returns {Promise<any[]>} The users for the session.
+         */
+        users: (product: string, data: IFetchUsersPayload) => Promise<import("./types").IFileURLPayload[]>;
+        /**
+         * Deletes a product session by tag.
+         * @param {string} product - The product tag.
+         * @param {string} tag - The session tag.
+         * @returns {Promise<void>} Resolves when the session is deleted. Throws on error.
+         */
+        delete: (product: string, tag: string) => Promise<void>;
+        /**
+         * Starts a new session and generates session tokens.
+         * @param data - The session input data.
+         * @returns The generated session tokens.
+         */
+        start: (data: {
+            product: string;
+            env: string;
+            tag: string;
+            data: Record<string, unknown>;
+        }) => Promise<import("./sessions").ISessionResult>;
+        /**
+         * Verifies a session token.
+         * @param data - The session verification payload.
+         * @returns The verification result with session data.
+         */
+        verify: (data: {
+            product: string;
+            env: string;
+            tag: string;
+            token: string;
+        }) => Promise<import("./sessions").IVerifyResult>;
+        /**
+         * Refreshes a session using the refresh token.
+         * @param data - The session refresh payload.
+         * @returns The new session tokens.
+         */
+        refresh: (data: {
+            product: string;
+            env: string;
+            tag: string;
+            refreshToken: string;
+        }) => Promise<import("./sessions").ISessionResult>;
+        /**
+         * Revokes a session.
+         * @param data - The session revocation payload.
+         * @returns The revocation result.
+         */
+        revoke: (data: {
+            product: string;
+            env: string;
+            tag: string;
+            sessionId?: string;
+            identifier?: string;
+        }) => Promise<void>;
+        /**
+         * Lists active sessions with pagination.
+         * @param data - The list sessions payload.
+         * @returns The list of sessions with pagination info.
+         */
+        listActive: (data: {
+            product: string;
+            env: string;
+            tag: string;
+            identifier?: string;
+            page?: number;
+            limit?: number;
+        }) => Promise<import("./sessions").IListSessionsResult>;
+    };
+    /**
+     * Quota-related operations for managing product quotas.
+     */
+    quota: {
         /**
          * Creates a quota for a product.
+         * @param {string} product - The product tag.
          * @param {Partial<IProductQuota>} data - The quota data.
          * @returns {Promise<void>} Resolves when the quota is created. Throws on error.
          */
-        quota: {
-            create: (data: Partial<IProductQuota>) => Promise<void>;
-            /**
-             * Fetches a quota by tag.
-             * @param {string} tag - The quota tag.
-             * @returns {IProductQuota|null} The fetched quota, or null if not found.
-             */
-            fetch: (tag: string) => Promise<IProductQuota>;
-            /**
-             * Fetches all quotas for a product.
-             * @returns {IProductQuota[]} The list of quotas.
-             */
-            fetchAll: () => Promise<IProductQuota[]>;
-            /**
-             * Updates a quota by tag.
-             * @param {string} tag - The quota tag.
-             * @param {Partial<IProductQuota>} data - The quota data to update.
-             * @returns {Promise<void>} Resolves when the quota is updated. Throws on error.
-             */
-            update: (tag: string, data: Partial<IProductQuota>) => Promise<void>;
-        };
+        create: (product: string, data: Partial<IProductQuota>) => Promise<void>;
+        /**
+         * Fetches a quota by tag.
+         * @param {string} product - The product tag.
+         * @param {string} tag - The quota tag.
+         * @returns {IProductQuota|null} The fetched quota, or null if not found.
+         */
+        fetch: (product: string, tag: string) => Promise<IProductQuota>;
+        /**
+         * Fetches all quotas for a product.
+         * @param {string} product - The product tag.
+         * @returns {IProductQuota[]} The list of quotas.
+         */
+        list: (product: string) => Promise<IProductQuota[]>;
+        /**
+         * Updates a quota by tag.
+         * @param {string} product - The product tag.
+         * @param {string} tag - The quota tag.
+         * @param {Partial<IProductQuota>} data - The quota data to update.
+         * @returns {Promise<void>} Resolves when the quota is updated. Throws on error.
+         */
+        update: (product: string, tag: string, data: Partial<IProductQuota>) => Promise<void>;
+        /**
+         * Deletes a quota by tag.
+         * @param {string} product - The product tag.
+         * @param {string} tag - The quota tag.
+         * @returns {Promise<void>} Resolves when the quota is deleted. Throws on error.
+         */
+        delete: (product: string, tag: string) => Promise<void>;
+        /**
+         * Runs a quota with weighted distribution.
+         * @param {Object} data - The quota run input.
+         * @param {string} data.product - The product tag.
+         * @param {string} data.env - The environment slug.
+         * @param {string} data.tag - The quota tag.
+         * @param {Record<string, unknown>} data.input - The input data for the quota.
+         * @returns {Promise<any>} The result of the quota execution.
+         */
+        run: (data: {
+            product: string;
+            env: string;
+            tag: string;
+            input: Record<string, unknown>;
+        }) => Promise<unknown>;
+    };
+    /**
+     * Fallback-related operations for managing product fallbacks.
+     */
+    fallback: {
         /**
          * Creates a fallback for a product.
+         * @param {string} product - The product tag.
          * @param {Partial<IProductFallback>} data - The fallback data.
          * @returns {Promise<void>} Resolves when the fallback is created. Throws on error.
          */
-        fallback: {
-            create: (data: Partial<IProductFallback>) => Promise<void>;
+        create: (product: string, data: Partial<IProductFallback>) => Promise<void>;
+        /**
+         * Fetches a fallback by tag.
+         * @param {string} product - The product tag.
+         * @param {string} tag - The fallback tag.
+         * @returns {IProductFallback|null} The fetched fallback, or null if not found.
+         */
+        fetch: (product: string, tag: string) => Promise<IProductFallback>;
+        /**
+         * Fetches all fallbacks for a product.
+         * @param {string} product - The product tag.
+         * @returns {IProductFallback[]} The list of fallbacks.
+         */
+        list: (product: string) => Promise<IProductFallback[]>;
+        /**
+         * Updates a fallback by tag.
+         * @param {string} product - The product tag.
+         * @param {string} tag - The fallback tag.
+         * @param {Partial<IProductFallback>} data - The fallback data to update.
+         * @returns {Promise<void>} Resolves when the fallback is updated. Throws on error.
+         */
+        update: (product: string, tag: string, data: Partial<IProductFallback>) => Promise<void>;
+        /**
+         * Deletes a fallback by tag.
+         * @param {string} product - The product tag.
+         * @param {string} tag - The fallback tag.
+         * @returns {Promise<void>} Resolves when the fallback is deleted. Throws on error.
+         */
+        delete: (product: string, tag: string) => Promise<void>;
+        /**
+         * Runs a fallback with sequential failover.
+         * @param {Object} data - The fallback run input.
+         * @param {string} data.product - The product tag.
+         * @param {string} data.env - The environment slug.
+         * @param {string} data.tag - The fallback tag.
+         * @param {Record<string, unknown>} data.input - The input data for the fallback.
+         * @returns {Promise<any>} The result of the fallback execution.
+         */
+        run: (data: {
+            product: string;
+            env: string;
+            tag: string;
+            input: Record<string, unknown>;
+        }) => Promise<unknown>;
+    };
+    /**
+     * Storage-related operations for managing product storages.
+     */
+    storage: {
+        /**
+         * Creates a storage for a product.
+         * @param {string} product - The product tag.
+         * @param {IProductStorage} data - The storage data.
+         * @returns {Promise<void>} Resolves when the storage is created. Throws on error.
+         */
+        create: (product: string, data: IProductStorage) => Promise<void>;
+        /**
+         * Fetches all storages for a product.
+         * @param {string} product - The product tag.
+         * @returns {IProductStorage[]} The list of storages.
+         */
+        list: (product: string) => Promise<IProductStorage[]>;
+        /**
+         * Fetches a storage by tag.
+         * @param {string} product - The product tag.
+         * @param {string} tag - The storage tag.
+         * @returns {IProductStorage|null} The fetched storage, or null if not found.
+         */
+        fetch: (product: string, tag: string) => Promise<IProductStorage>;
+        /**
+         * Updates a storage by tag.
+         * @param {string} product - The product tag.
+         * @param {string} tag - The storage tag.
+         * @param {Partial<IProductStorage>} data - The storage data to update.
+         * @returns {Promise<void>} Resolves when the storage is updated. Throws on error.
+         */
+        update: (product: string, tag: string, data: Partial<IProductStorage>) => Promise<void>;
+        /**
+         * Fetches storage files for a product.
+         * @param {string} product - The product tag.
+         * @param {IFetchFilesPayload} data - The fetch files payload.
+         * @returns {Promise<void>} Resolves when the storage files are fetched. Throws on error.
+         */
+        /**
+         * Deletes a storage by tag.
+         * @param {string} product - The product tag.
+         * @param {string} tag - The storage tag.
+         * @returns {Promise<void>} Resolves when the storage is deleted. Throws on error.
+         */
+        delete: (product: string, tag: string) => Promise<void>;
+        /**
+         * Reads a file from local storage.
+         * @param {string} path - The file path.
+         * @returns {Promise<IFileReadResult>} The file read result.
+         */
+        readFile: (path: string) => Promise<IFileReadResult>;
+        /**
+         * Saves data to storage using the storage processor.
+         * @param {IStorageProcessorInput} data - The storage processor input.
+         * @returns {Promise<any>} The result of the storage processing.
+         * @example
+         * await ductape.storage.save({
+         *   product: 'my-product',
+         *   env: 'production',
+         *   event: 'upload-file',
+         *   input: { buffer: fileData, fileName: 'report.pdf', mimeType: 'application/pdf' }
+         * });
+         * @deprecated Use upload() instead for direct cloud storage operations
+         */
+        save: (data: IStorageProcessorInput) => Promise<any>;
+        /**
+         * Uploads a file to cloud storage.
+         * @param {Object} data - The upload options.
+         * @returns {Promise<IStorageResult>} The upload result with file URL.
+         * @example
+         * await ductape.storage.upload({
+         *   product: 'my-product',
+         *   env: 'production',
+         *   storage: 's3-bucket',
+         *   fileName: 'documents/report.pdf',
+         *   buffer: fileBuffer,
+         *   mimeType: 'application/pdf'
+         * });
+         */
+        upload: (data: {
+            product: string;
+            env: string;
+            storage: string;
+            fileName: string;
+            buffer: string | Buffer;
+            mimeType?: string;
+        }) => Promise<import("./storage").IStorageResult>;
+        /**
+         * Downloads a file from cloud storage.
+         * @param data - The download options.
+         * @returns The download result with file data.
+         * @example
+         * const result = await ductape.storage.download({
+         *   product: 'my-product',
+         *   env: 'production',
+         *   storage: 's3-bucket',
+         *   fileName: 'documents/report.pdf'
+         * });
+         */
+        download: (data: {
+            product: string;
+            env: string;
+            storage: string;
+            fileName: string;
+        }) => Promise<import("./storage").IDownloadResult>;
+        /**
+         * Removes a file from cloud storage.
+         * @param data - The delete options.
+         * @returns The delete result.
+         * @example
+         * await ductape.storage.remove({
+         *   product: 'my-product',
+         *   env: 'production',
+         *   storage: 's3-bucket',
+         *   fileName: 'documents/report.pdf'
+         * });
+         */
+        remove: (data: {
+            product: string;
+            env: string;
+            storage: string;
+            fileName: string;
+        }) => Promise<import("./storage").IDeleteResult>;
+        /**
+         * Lists files in cloud storage with pagination.
+         * @param data - The list options.
+         * @returns The list result with files and pagination info.
+         * @example
+         * const result = await ductape.storage.list({
+         *   product: 'my-product',
+         *   env: 'production',
+         *   storage: 's3-bucket',
+         *   prefix: 'documents/',
+         *   limit: 100
+         * });
+         */
+        files: (data: {
+            product: string;
+            env: string;
+            storage: string;
+            prefix?: string;
+            limit?: number;
+            continuationToken?: string;
+        }) => Promise<import("./storage").IListFilesResult>;
+        /**
+         * Generates a signed URL for temporary file access.
+         * @param data - The signed URL options.
+         * @returns The signed URL result.
+         * @example
+         * const result = await ductape.storage.getSignedUrl({
+         *   product: 'my-product',
+         *   env: 'production',
+         *   storage: 's3-bucket',
+         *   fileName: 'documents/report.pdf',
+         *   expiresIn: 3600,
+         *   action: 'read'
+         * });
+         */
+        getSignedUrl: (data: {
+            product: string;
+            env: string;
+            storage: string;
+            fileName: string;
+            expiresIn?: number;
+            action?: "read" | "write";
+        }) => Promise<import("./storage").ISignedUrlResult>;
+        /**
+         * Dispatches a storage operation to run as a scheduled job.
+         * @param {IStorageDispatchInput} data - The storage dispatch input.
+         * @returns {Promise<IDispatchResult>} The dispatch result with job ID and status.
+         * @example
+         * // Schedule a file backup in 6 hours
+         * await ductape.storage.dispatch({
+         *   product: 'my-product',
+         *   env: 'production',
+         *   storage: 's3-storage',
+         *   event: 'backup-files',
+         *   input: { buffer: fileData, fileName: 'backup.zip', mimeType: 'application/zip' },
+         *   schedule: { start_at: Date.now() + 21600000 }
+         * });
+         *
+         * // Run daily backups
+         * await ductape.storage.dispatch({
+         *   product: 'my-product',
+         *   env: 'production',
+         *   storage: 's3-storage',
+         *   event: 'daily-backup',
+         *   input: { buffer: fileData, fileName: 'daily.zip', mimeType: 'application/zip' },
+         *   schedule: { cron: '0 2 * * *' } // Daily at 2 AM
+         * });
+         */
+        dispatch: (data: IStorageDispatchInput) => Promise<IDispatchResult>;
+    };
+    /**
+     * Events-related operations for managing product events (message brokers).
+     */
+    events: {
+        /**
+         * Creates a message broker for a product.
+         * @param {string} product - The product tag.
+         * @param {Partial<IProductMessageBroker>} data - The message broker data.
+         * @returns {Promise<void>} Resolves when the message broker is created. Throws on error.
+         */
+        create: (product: string, data: Partial<IProductMessageBroker>) => Promise<void>;
+        /**
+         * Fetches all message brokers for a product.
+         * @param {string} product - The product tag.
+         * @returns {IProductMessageBroker[]} The list of message brokers.
+         */
+        list: (product: string) => Promise<IProductMessageBroker[]>;
+        /**
+         * Fetches a message broker by tag.
+         * @param {string} product - The product tag.
+         * @param {string} tag - The message broker tag.
+         * @returns {IProductMessageBroker|null} The fetched message broker, or null if not found.
+         */
+        fetch: (product: string, tag: string) => Promise<IProductMessageBroker>;
+        /**
+         * Updates a message broker by tag.
+         * @param {string} product - The product tag.
+         * @param {string} tag - The message broker tag.
+         * @param {Partial<IProductMessageBroker>} data - The message broker data to update.
+         * @returns {Promise<void>} Resolves when the message broker is updated. Throws on error.
+         */
+        update: (product: string, tag: string, data: Partial<IProductMessageBroker>) => Promise<void>;
+        /**
+         * Deletes a message broker by tag.
+         * @param {string} product - The product tag.
+         * @param {string} tag - The message broker tag.
+         * @returns {Promise<void>} Resolves when the message broker is deleted. Throws on error.
+         */
+        delete: (product: string, tag: string) => Promise<void>;
+        topics: {
             /**
-             * Fetches a fallback by tag.
-             * @param {string} tag - The fallback tag.
-             * @returns {IProductFallback|null} The fetched fallback, or null if not found.
+             * Creates a message broker topic for a product.
+             * @param {string} product - The product tag.
+             * @param {IProductMessageBrokerTopic} data - The message broker topic data.
+             * @returns {Promise<void>} Resolves when the message broker topic is created. Throws on error.
              */
-            fetch: (tag: string) => Promise<IProductFallback>;
+            create: (product: string, data: IProductMessageBrokerTopic) => Promise<void>;
             /**
-             * Fetches all fallbacks for a product.
-             * @returns {IProductFallback[]} The list of fallbacks.
+             * Fetches all message broker topics for a message broker by tag.
+             * @param {string} product - The product tag.
+             * @param {string} messageBrokerTag - The message broker tag.
+             * @returns {IProductMessageBrokerTopic[]} The list of message broker topics.
              */
-            fetchAll: () => Promise<IProductFallback[]>;
+            list: (product: string, messageBrokerTag: string) => Promise<IProductMessageBrokerTopic[]>;
             /**
-             * Updates a fallback by tag.
-             * @param {string} tag - The fallback tag.
-             * @param {Partial<IProductFallback>} data - The fallback data to update.
-             * @returns {Promise<void>} Resolves when the fallback is updated. Throws on error.
+             * Fetches a message broker topic by tag.
+             * @param {string} product - The product tag.
+             * @param {string} tag - The message broker topic tag.
+             * @returns {IProductMessageBrokerTopic|null} The fetched message broker topic, or null if not found.
              */
-            update: (tag: string, data: Partial<IProductFallback>) => Promise<void>;
+            fetch: (product: string, tag: string) => Promise<IProductMessageBrokerTopic>;
+            /**
+             * Updates a message broker topic by tag.
+             * @param {string} product - The product tag.
+             * @param {string} tag - The message broker topic tag.
+             * @param {Partial<IProductMessageBrokerTopic>} data - The message broker topic data to update.
+             * @returns {Promise<void>} Resolves when the message broker topic is updated. Throws on error.
+             */
+            update: (product: string, tag: string, data: Partial<IProductMessageBrokerTopic>) => Promise<void>;
         };
         /**
-         * Updates data validation for a product.
-         * @param {string} tag - The product tag.
-         * @param {Partial<IParsedSample>} update - The update data.
-         * @returns {Promise<void>} Resolves when the validation is updated. Throws on error.
+         * Publishes a message using the BrokersService.
+         * @param data - The publish input.
+         * @returns The result of the publish operation.
+         * @example
+         * await ductape.events.publish({
+         *   product: 'my-product',
+         *   env: 'production',
+         *   event: 'broker-tag:topic-tag',
+         *   message: { orderId: '123', status: 'pending' }
+         * });
          */
-        updateValidation: (tag: string, update: Partial<IParsedSample>) => Promise<boolean>;
-        environments: {
+        publish: (data: {
+            product: string;
+            env: string;
+            event: string;
+            message: Record<string, unknown>;
+        }) => Promise<import("./brokers").IPublishResult>;
+        /**
+         * Subscribes to a message broker topic.
+         * @param data - The subscribe input.
+         * @returns The result of the subscribe operation.
+         * @example
+         * await ductape.events.subscribe({
+         *   product: 'my-product',
+         *   env: 'production',
+         *   event: 'broker-tag:topic-tag',
+         *   callback: async (message) => console.log(message)
+         * });
+         */
+        subscribe: (data: {
+            product: string;
+            env: string;
+            event: string;
+            callback: (message: object) => Promise<void>;
+        }) => Promise<import("./brokers").ISubscribeResult>;
+        /**
+         * Dispatches a publish operation to run as a scheduled job.
+         * @param {IPublishDispatchInput} data - The publish dispatch input.
+         * @returns {Promise<IDispatchResult>} The dispatch result with job ID and status.
+         * @example
+         * // Schedule a message to be published in 15 minutes
+         * await ductape.events.dispatch({
+         *   product: 'my-product',
+         *   env: 'production',
+         *   broker: 'kafka-broker',
+         *   event: 'order-created',
+         *   input: { message: { orderId: '123', status: 'pending' } },
+         *   schedule: { start_at: Date.now() + 900000 }
+         * });
+         *
+         * // Publish messages at regular intervals
+         * await ductape.events.dispatch({
+         *   product: 'my-product',
+         *   env: 'production',
+         *   broker: 'redis-broker',
+         *   event: 'heartbeat',
+         *   input: { message: { ping: true } },
+         *   schedule: { every: 60000 } // Every minute
+         * });
+         */
+        dispatch: (data: IPublishDispatchInput) => Promise<IDispatchResult>;
+    };
+    /**
+     * Notification-related operations for managing product notifications.
+     */
+    notifications: {
+        /**
+         * Creates a notification for a product.
+         * @param {string} product - The product tag.
+         * @param {IProductNotification} data - The notification data.
+         * @returns {Promise<void>} Resolves when the notification is created. Throws on error.
+         */
+        create: (product: string, data: IProductNotification) => Promise<void>;
+        /**
+         * Fetches all notifications for a product.
+         * @param {string} product - The product tag.
+         * @returns {IProductNotification[]} The list of notifications.
+         */
+        list: (product: string) => Promise<IProductNotification[]>;
+        /**
+         * Fetches a notification by tag.
+         * @param {string} product - The product tag.
+         * @param {string} tag - The notification tag.
+         * @returns {IProductNotification|null} The fetched notification, or null if not found.
+         */
+        fetch: (product: string, tag: string) => Promise<IProductNotification>;
+        /**
+         * Updates a notification by tag.
+         * @param {string} product - The product tag.
+         * @param {string} tag - The notification tag.
+         * @param {Partial<IProductNotification>} data - The notification data to update.
+         * @returns {Promise<void>} Resolves when the notification is updated. Throws on error.
+         */
+        update: (product: string, tag: string, data: Partial<IProductNotification>) => Promise<void>;
+        /**
+         * Deletes a notification by tag.
+         * @param {string} product - The product tag.
+         * @param {string} tag - The notification tag.
+         * @returns {Promise<void>} Resolves when the notification is deleted. Throws on error.
+         */
+        delete: (product: string, tag: string) => Promise<void>;
+        messages: {
             /**
-             * Creates an environment for a product.
-             * @param {IProductEnv} data - The environment data.
-             * @returns {Promise<void>} Resolves when the environment is created. Throws on error.
+             * Creates a notification message for a product.
+             * @param {string} product - The product tag.
+             * @param {IProductNotificationTemplate} data - The notification message data.
+             * @returns {Promise<void>} Resolves when the notification message is created. Throws on error.
              */
-            create: (data: IProductEnv) => Promise<void>;
+            create: (product: string, data: IProductNotificationTemplate) => Promise<void>;
             /**
-             * Fetches all environments for a product.
-             * @returns {IAppEnv[]} The list of environments.
+             * Fetches all notification messages for a notification by tag.
+             * @param {string} product - The product tag.
+             * @param {string} notificationTag - The notification tag.
+             * @returns {IProductNotificationTemplate[]} The list of notification messages.
              */
-            fetchAll: () => Promise<IProductEnv[]>;
+            list: (product: string, notificationTag: string) => Promise<IProductNotificationTemplate[]>;
             /**
-             * Fetches an environment by slug.
-             * @param {string} slug - The environment slug.
-             * @returns {IAppEnv|null} The fetched environment, or null if not found.
+             * Fetches a notification message by tag.
+             * @param {string} product - The product tag.
+             * @param {string} tag - The notification message tag.
+             * @returns {IProductNotificationTemplate|null} The fetched notification message, or null if not found.
              */
-            fetch: (slug: string) => Promise<IProductEnv>;
+            fetch: (product: string, tag: string) => Promise<IProductNotificationTemplate>;
             /**
-             * Updates an environment by slug.
-             * @param {string} slug - The environment slug.
-             * @param {Partial<IProductEnv>} data - The environment data to update.
-             * @returns {Promise<void>} Resolves when the environment is updated. Throws on error.
+             * Updates a notification message by tag.
+             * @param {string} product - The product tag.
+             * @param {string} tag - The notification message tag.
+             * @param {Partial<IProductNotificationTemplate>} data - The notification message data to update.
+             * @returns {Promise<void>} Resolves when the notification message is updated. Throws on error.
              */
-            update: (slug: string, data: Partial<IProductEnv>) => Promise<void>;
+            update: (product: string, tag: string, data: Partial<IProductNotificationTemplate>) => Promise<void>;
         };
-        storage: {
+        /**
+         * Sends a notification immediately using the notification processor.
+         * @param {INotificationProcessorInput} data - The notification processor input.
+         * @returns {Promise<any>} The result of the notification processing.
+         * @example
+         * await ductape.notifications.send({
+         *   product: 'my-product',
+         *   env: 'production',
+         *   event: 'welcome-email',
+         *   input: { email: { recipients: ['user@example.com'], subject: { name: 'John' } } }
+         * });
+         */
+        send: (data: INotificationProcessorInput) => Promise<{
+            process_id: string;
+        }>;
+        /**
+         * Dispatches a notification to be sent as a scheduled job.
+         * @param {INotificationDispatchInput} data - The notification dispatch input.
+         * @returns {Promise<IDispatchResult>} The dispatch result with job ID and status.
+         * @example
+         * // Schedule a notification to be sent in 1 hour
+         * await ductape.notifications.dispatch({
+         *   product: 'my-product',
+         *   env: 'production',
+         *   notification: 'user-notifications',
+         *   event: 'welcome-email',
+         *   input: { email: { to: 'user@example.com' } },
+         *   schedule: { start_at: Date.now() + 3600000 }
+         * });
+         *
+         * // Send recurring notifications
+         * await ductape.notifications.dispatch({
+         *   product: 'my-product',
+         *   env: 'production',
+         *   notification: 'digest',
+         *   event: 'weekly-digest',
+         *   input: { email: { to: 'user@example.com' } },
+         *   schedule: { cron: '0 9 * * 1' } // Weekly on Monday at 9 AM
+         * });
+         */
+        dispatch: (data: INotificationDispatchInput) => Promise<IDispatchResult>;
+    };
+    /**
+     * Database operations service.
+     * Provides a unified API for database CRUD operations, schema management, queries, and migrations.
+     *
+     * @example
+     * // Register a new database
+     * await ductape.databases.create({
+     *   product: 'my-product',
+     *   name: 'User Database',
+     *   tag: 'users-db',
+     *   type: DatabaseType.POSTGRESQL,
+     *   envs: [{ slug: 'dev', connection_url: 'postgresql://localhost/mydb' }],
+     * });
+     *
+     * // Connect to database
+     * await ductape.databases.connect({ env: 'dev', product: 'my-product', database: 'users-db' });
+     */
+    databases: {
+        /**
+         * Create/register a new database configuration
+         */
+        create: (config: Parameters<DatabaseService["create"]>[0]) => Promise<void>;
+        /**
+         * Register a database for a product (alias for create with product)
+         */
+        register: (product: string, data: IProductDatabase) => Promise<void>;
+        /**
+         * Fetch all databases for a product
+         */
+        list: (product: string) => Promise<IProductDatabase[]>;
+        /**
+         * Fetch a specific database
+         */
+        fetch: (product: string, database: string) => Promise<IProductDatabase>;
+        /**
+         * Update a database configuration
+         */
+        update: (product: string, database: string, data: Partial<IProductDatabase>) => Promise<void>;
+        /**
+         * Update local database configuration
+         */
+        updateLocalConfig: (tag: string, updates: Parameters<DatabaseService["updateLocalConfig"]>[1]) => Promise<void>;
+        /**
+         * Connect to a database
+         */
+        connect: (config: Parameters<DatabaseService["connect"]>[0]) => Promise<import("./database").DatabaseConnection>;
+        /**
+         * Test database connection
+         */
+        testConnection: (config: Parameters<DatabaseService["testConnection"]>[0]) => Promise<import("./database").IConnectionResult>;
+        /**
+         * Disconnect from the current database
+         */
+        disconnect: () => Promise<void>;
+        /**
+         * Close all database connections
+         */
+        closeAll: () => Promise<void>;
+        /**
+         * Get current connection context
+         */
+        getCurrentContext: () => Promise<import("./database").IConnectionContext>;
+        /**
+         * Get a connection-scoped interface for a specific database/environment
+         */
+        connection: (database: string, env: string) => Promise<import("./database").DatabaseConnection>;
+        /**
+         * Query records from a table
+         */
+        query: <T = any>(options: Parameters<DatabaseService["query"]>[0]) => Promise<import("./database").IQueryResult<T>>;
+        /**
+         * Insert records into a table
+         */
+        insert: <T = any>(options: Parameters<DatabaseService["insert"]>[0]) => Promise<import("./database").IInsertResult<T>>;
+        /**
+         * Update records in a table
+         */
+        updateRecords: <T = any>(options: Parameters<DatabaseService["update"]>[0]) => Promise<import("./database").IUpdateResult<T>>;
+        /**
+         * Delete records from a table
+         */
+        delete: (options: Parameters<DatabaseService["delete"]>[0]) => Promise<import("./database").IDeleteResult>;
+        /**
+         * Insert or update a record based on conflict keys
+         */
+        upsert: <T = any>(options: Parameters<DatabaseService["upsert"]>[0]) => Promise<import("./database").IUpsertResult<T>>;
+        /**
+         * Count records
+         */
+        count: (options: Parameters<DatabaseService["count"]>[0]) => Promise<number>;
+        /**
+         * Sum values of a column
+         */
+        sum: (options: Parameters<DatabaseService["sum"]>[0]) => Promise<number>;
+        /**
+         * Calculate average of a column
+         */
+        avg: (options: Parameters<DatabaseService["avg"]>[0]) => Promise<number>;
+        /**
+         * Get minimum value of a column
+         */
+        min: (options: Parameters<DatabaseService["min"]>[0]) => Promise<any>;
+        /**
+         * Get maximum value of a column
+         */
+        max: (options: Parameters<DatabaseService["max"]>[0]) => Promise<any>;
+        /**
+         * Perform multiple aggregations in one query
+         */
+        aggregate: (options: Parameters<DatabaseService["aggregate"]>[0]) => Promise<import("./database").IAggregateResult>;
+        /**
+         * Begin a database transaction
+         */
+        beginTransaction: (options: Parameters<DatabaseService["beginTransaction"]>[0]) => Promise<import("./database").ITransaction>;
+        /**
+         * Schema operations sub-object - provides a simplified Mongoose-style API for schema management.
+         * These operations work on the currently connected database context.
+         */
+        schema: {
             /**
-             * Creates a storage for a product.
-             * @param {IProductStorage} data - The storage data.
-             * @returns {Promise<void>} Resolves when the storage is created. Throws on error.
+             * Create a collection/table with Mongoose-style schema definition
+             * @example
+             * await ductape.databases.schema.create('users', {
+             *   name: 'string',
+             *   email: { type: 'string', unique: true },
+             *   age: 'number',
+             *   createdAt: 'date',
+             * });
              */
-            create: (data: IProductStorage) => Promise<void>;
+            create: (name: string, definition: ISimpleSchemaDefinition, options?: ISimpleCreateOptions) => Promise<ISchemaOperationResult>;
             /**
-             * Fetches all storages for a product.
-             * @returns {IProductStorage[]} The list of storages.
+             * Drop a collection/table
              */
-            fetchAll: () => Promise<IProductStorage[]>;
+            drop: (name: string, options?: ISimpleDropOptions) => Promise<ISchemaOperationResult>;
             /**
-             * Fetches a storage by tag.
-             * @param {string} tag - The storage tag.
-             * @returns {IProductStorage|null} The fetched storage, or null if not found.
+             * Add a field to a collection
              */
-            fetch: (tag: string) => Promise<IProductStorage>;
+            addField: (collection: string, fieldName: string, definition: SimpleFieldType | ISimpleFieldDefinition) => Promise<ISchemaOperationResult>;
             /**
-             * Updates a storage by tag.
-             * @param {string} tag - The storage tag.
-             * @param {Partial<IProductStorage>} data - The storage data to update.
-             * @returns {Promise<void>} Resolves when the storage is updated. Throws on error.
+             * Drop a field from a collection
              */
-            update: (tag: string, data: Partial<IProductStorage>) => Promise<void>;
+            dropField: (collection: string, fieldName: string) => Promise<ISchemaOperationResult>;
             /**
-             * Fetches storage files for a product.
-             * @param {IFetchFilesPayload} data - The fetch files payload.
-             * @returns {Promise<void>} Resolves when the storage files are fetched. Throws on error.
+             * Rename a field in a collection
              */
-            files: (data: IFetchFilesPayload) => Promise<import("./types").IFileURLPayload[]>;
-        };
-        messageBrokers: {
+            renameField: (collection: string, oldName: string, newName: string) => Promise<ISchemaOperationResult>;
             /**
-             * Creates a message broker for a product.
-             * @param {Partial<IProductMessageBroker>} data - The message broker data.
-             * @returns {Promise<void>} Resolves when the message broker is created. Throws on error.
+             * Modify a field's definition
              */
-            create: (data: Partial<IProductMessageBroker>) => Promise<void>;
+            modifyField: (collection: string, fieldName: string, changes: Partial<ISimpleFieldDefinition>) => Promise<ISchemaOperationResult>;
             /**
-             * Fetches all message brokers for a product.
-             * @returns {IProductMessageBroker[]} The list of message brokers.
+             * Create an index on a collection
              */
-            fetchAll: () => Promise<IProductMessageBroker[]>;
+            createIndex: (collection: string, fields: string[] | IIndexFieldDefinition[], options?: ISimpleIndexOptions) => Promise<ISchemaOperationResult>;
             /**
-             * Fetches a message broker by tag.
-             * @param {string} tag - The message broker tag.
-             * @returns {IProductMessageBroker|null} The fetched message broker, or null if not found.
+             * Drop an index from a collection
              */
-            fetch: (tag: string) => Promise<IProductMessageBroker>;
+            dropIndex: (collection: string, indexName: string) => Promise<ISchemaOperationResult>;
             /**
-             * Updates a message broker by tag.
-             * @param {string} tag - The message broker tag.
-             * @param {Partial<IProductMessageBroker>} data - The message broker data to update.
-             * @returns {Promise<void>} Resolves when the message broker is updated. Throws on error.
+             * Add a constraint (SQL databases only)
              */
-            update: (tag: string, data: Partial<IProductMessageBroker>) => Promise<void>;
-            topics: {
-                /**
-                 * Creates a message broker topic for a product.
-                 * @param {IProductMessageBrokerTopic} data - The message broker topic data.
-                 * @returns {Promise<void>} Resolves when the message broker topic is created. Throws on error.
-                 */
-                create: (data: IProductMessageBrokerTopic) => Promise<void>;
-                /**
-                 * Fetches all message broker topics for a message broker by tag.
-                 * @param {string} messageBrokerTag - The message broker tag.
-                 * @returns {IProductMessageBrokerTopic[]} The list of message broker topics.
-                 */
-                fetchAll: (messageBrokerTag: string) => Promise<IProductMessageBrokerTopic[]>;
-                /**
-                 * Fetches a message broker topic by tag.
-                 * @param {string} tag - The message broker topic tag.
-                 * @returns {IProductMessageBrokerTopic|null} The fetched message broker topic, or null if not found.
-                 */
-                fetch: (tag: string) => Promise<IProductMessageBrokerTopic>;
-                /**
-                 * Updates a message broker topic by tag.
-                 * @param {string} tag - The message broker topic tag.
-                 * @param {Partial<IProductMessageBrokerTopic>} data - The message broker topic data to update.
-                 * @returns {Promise<void>} Resolves when the message broker topic is updated. Throws on error.
-                 */
-                update: (tag: string, data: Partial<IProductMessageBrokerTopic>) => Promise<void>;
-            };
-        };
-        notifications: {
+            addConstraint: (collection: string, constraint: IMigrationConstraintDefinition) => Promise<ISchemaOperationResult>;
             /**
-             * Creates a notification for a product.
-             * @param {IProductNotification} data - The notification data.
-             * @returns {Promise<void>} Resolves when the notification is created. Throws on error.
+             * Drop a constraint (SQL databases only)
              */
-            create: (data: IProductNotification) => Promise<void>;
+            dropConstraint: (collection: string, constraintName: string) => Promise<ISchemaOperationResult>;
             /**
-             * Fetches all notifications for a product.
-             * @returns {IProductNotification[]} The list of notifications.
+             * Rename a collection/table
              */
-            fetchAll: () => Promise<IProductNotification[]>;
+            rename: (oldName: string, newName: string) => Promise<ISchemaOperationResult>;
             /**
-             * Fetches a notification by tag.
-             * @param {string} tag - The notification tag.
-             * @returns {IProductNotification|null} The fetched notification, or null if not found.
+             * Check if a collection/table exists
              */
-            fetch: (tag: string) => Promise<IProductNotification>;
+            exists: (name: string) => Promise<boolean>;
             /**
-             * Updates a notification by tag.
-             * @param {string} tag - The notification tag.
-             * @param {Partial<IProductNotification>} data - The notification data to update.
-             * @returns {Promise<void>} Resolves when the notification is updated. Throws on error.
+             * List all collections/tables
              */
-            update: (tag: string, data: Partial<IProductNotification>) => Promise<void>;
-            messages: {
-                /**
-                 * Creates a notification message for a product.
-                 * @param {IProductNotificationTemplate} data - The notification message data.
-                 * @returns {Promise<void>} Resolves when the notification message is created. Throws on error.
-                 */
-                create: (data: IProductNotificationTemplate) => Promise<void>;
-                /**
-                 * Fetches all notification messages for a notification by tag.
-                 * @param {string} notificationTag - The notification tag.
-                 * @returns {IProductNotificationTemplate[]} The list of notification messages.
-                 */
-                fetchAll: (notificationTag: string) => Promise<IProductNotificationTemplate[]>;
-                /**
-                 * Fetches a notification message by tag.
-                 * @param {string} tag - The notification message tag.
-                 * @returns {IProductNotificationTemplate|null} The fetched notification message, or null if not found.
-                 */
-                fetch: (tag: string) => Promise<IProductNotificationTemplate>;
-                /**
-                 * Updates a notification message by tag.
-                 * @param {string} tag - The notification message tag.
-                 * @param {Partial<IProductNotificationTemplate>} data - The notification message data to update.
-                 * @returns {Promise<void>} Resolves when the notification message is updated. Throws on error.
-                 */
-                update: (tag: string, data: Partial<IProductNotificationTemplate>) => Promise<void>;
-            };
-        };
-        databases: {
+            list: (schemaName?: string) => Promise<string[]>;
             /**
-             * Creates a database for a product.
-             * @param {IProductDatabase} data - The database data.
-             * @returns {Promise<void>} Resolves when the database is created. Throws on error.
+             * Get detailed schema information for a collection
              */
-            create: (data: IProductDatabase) => Promise<void>;
+            describe: (name: string) => Promise<ITableSchema>;
             /**
-             * Fetches all databases for a product.
-             * @returns {IProductDatabase[]} The list of databases.
+             * List indexes on a collection
              */
-            fetchAll: () => Promise<IProductDatabase[]>;
-            /**
-             * Fetches a database by tag.
-             * @param {string} tag - The database tag.
-             * @returns {IProductDatabase|null} The fetched database, or null if not found.
-             */
-            fetch: (tag: string) => Promise<IProductDatabase>;
-            /**
-             * Updates a database by tag.
-             * @param {string} tag - The database tag.
-             * @param {Partial<IProductDatabase>} data - The database data to update.
-             * @returns {Promise<void>} Resolves when the database is updated. Throws on error.
-             */
-            update: (tag: string, data: Partial<IProductDatabase>) => Promise<void>;
-            actions: {
-                /**
-                 * Creates a database action for a product.
-                 * @param {IProductDatabaseAction} data - The database action data.
-                 * @returns {Promise<void>} Resolves when the database action is created. Throws on error.
-                 */
-                create: (data: IProductDatabaseAction) => Promise<void>;
-                /**
-                 * Fetches all database actions for a product.
-                 * @param {string} databaseTag - The database tag.
-                 * @returns {IProductDatabaseAction[]} The list of database actions.
-                 */
-                fetchAll: (databaseTag: string) => Promise<IProductDatabaseAction[]>;
-                /**
-                 * Fetches a database action by tag.
-                 * @param {string} tag - The database action tag.
-                 * @returns {IProductDatabaseAction|null} The fetched database action, or null if not found.
-                 */
-                fetch: (tag: string) => Promise<IProductDatabaseAction>;
-                /**
-                 * Updates a database action by tag.
-                 * @param {string} tag - The database action tag.
-                 * @param {Partial<IProductDatabaseAction>} data - The database action data to update.
-                 * @returns {Promise<void>} Resolves when the database action is updated. Throws on error.
-                 */
-                update: (tag: string, data: Partial<IProductDatabaseAction>) => Promise<void>;
-            };
-            migrations: {
-                /**
-                 * Creates a database migration for a product.
-                 * @param {IProductDatabaseMigration} data - The database migration data.
-                 * @returns {void} Resolves when the database migration is created. Throws on error.
-                 */
-                create: (data: IProductDatabaseMigration) => Promise<void>;
-                /**
-                 * Fetches all database migrations for a product.
-                 * @param {string} databaseTag - The database tag.
-                 * @returns {IProductDatabaseMigration[]} The list of database migrations.
-                 */
-                fetchAll: (databaseTag: string) => Promise<IProductDatabaseMigration[]>;
-                /**
-                 * Fetches a database migration by tag.
-                 * @param {string} tag - The database migration tag.
-                 * @returns {IProductDatabaseMigration|null} The fetched database migration, or null if not found.
-                 */
-                fetch: (tag: string) => Promise<IProductDatabaseMigration>;
-                /**
-                 * Updates a database migration by tag.
-                 * @param {string} tag - The database migration tag.
-                 * @param {Partial<IProductDatabaseMigration>} data - The database migration data to update.
-                 * @returns {void} Resolves when the database migration is updated. Throws on error.
-                 */
-                update: (tag: string, data: Partial<IProductDatabaseMigration>) => Promise<void>;
-            };
-        };
-        graphs: {
-            /**
-             * Creates a graph database for a product.
-             * @param {IProductGraph} data - The graph database data.
-             * @returns {Promise<void>} Resolves when the graph database is created. Throws on error.
-             */
-            create: (data: IProductGraph) => Promise<void>;
-            /**
-             * Fetches all graph databases for a product.
-             * @returns {IProductGraph[]} The list of graph databases.
-             */
-            fetchAll: () => Promise<IProductGraph[]>;
-            /**
-             * Fetches a graph database by tag.
-             * @param {string} tag - The graph database tag.
-             * @returns {IProductGraph|null} The fetched graph database, or null if not found.
-             */
-            fetch: (tag: string) => Promise<IProductGraph>;
-            /**
-             * Updates a graph database by tag.
-             * @param {string} tag - The graph database tag.
-             * @param {Partial<IProductGraph>} data - The graph database data to update.
-             * @returns {Promise<void>} Resolves when the graph database is updated. Throws on error.
-             */
-            update: (tag: string, data: Partial<IProductGraph>) => Promise<void>;
-        };
-        jobs: {
-            /**
-             * Creates a job for a product.
-             * @param {Partial<IProductJobs>} data - The job data.
-             * @returns {Promise<void>} Resolves when the job is created. Throws on error.
-             */
-            create: (data: Partial<IProductJobs>) => Promise<void>;
-            /**
-             * Fetches all jobs for a product.
-             * @returns {IProductJobs[]} The list of jobs.
-             */
-            fetchAll: () => Promise<IProductJobs[]>;
-            /**
-             * Fetches a job by tag.
-             * @param {string} tag - The job tag.
-             * @returns {IProductJobs|null} The fetched job, or null if not found.
-             */
-            fetch: (tag: string) => Promise<IProductJobs>;
-            /**
-             * Updates a job by tag.
-             * @param {string} tag - The job tag.
-             * @param {Partial<IProductJobs>} data - The job data to update.
-             * @returns {Promise<void>} Resolves when the job is updated. Throws on error.
-             */
-            update: (tag: string, data: Partial<IProductJobs>) => Promise<void>;
+            indexes: (collection: string) => Promise<IIndexInfo[]>;
         };
-        caches: {
+        /**
+         * Migration CRUD sub-object
+         */
+        migration: {
+            create: (options: {
+                product: string;
+                database: string;
+                data: {
+                    name: string;
+                    tag: string;
+                    description?: string;
+                    value: {
+                        up: string[];
+                        down: string[];
+                    };
+                };
+            }) => Promise<void>;
+            update: (options: {
+                product: string;
+                tag: string;
+                data: {
+                    name?: string;
+                    description?: string;
+                    value?: {
+                        up: string[];
+                        down: string[];
+                    };
+                };
+            }) => Promise<void>;
+            fetch: (options: {
+                product: string;
+                tag: string;
+            }) => Promise<any>;
+            list: (options: {
+                product: string;
+                database: string;
+            }) => Promise<any[]>;
+            delete: (options: {
+                product: string;
+                tag: string;
+            }) => Promise<void>;
             /**
-             * Creates a cache for a product.
-             * @param {IProductCache} data - The cache data.
-             * @returns {Promise<void>} Resolves when the cache is created. Throws on error.
+             * Run a migration
              */
-            create: (data: IProductCache) => Promise<void>;
+            run: (migrations: Parameters<DatabaseService["runMigration"]>[0], options?: Parameters<DatabaseService["runMigration"]>[1]) => Promise<Map<string, import("./database").IMigrationResult>>;
             /**
-             * Fetches all caches for a product.
-             * @returns {IProductCache[]} The list of caches.
+             * Rollback migrations
              */
-            fetchAll: () => Promise<IProductCache[]>;
+            rollback: (migrations: Parameters<DatabaseService["rollbackMigration"]>[0], count?: number) => Promise<Map<string, import("./database").IMigrationResult>>;
             /**
-             * Fetches a cache by tag.
-             * @param {string} tag - The cache tag.
-             * @returns {IProductCache|null} The fetched cache, or null if not found.
+             * Get migration history
              */
-            fetch: (tag: string) => Promise<IProductCache>;
+            history: () => Promise<import("./database").IMigrationHistory[]>;
             /**
-             * Updates a cache by tag.
-             * @param {string} tag - The cache tag.
-             * @param {Partial<IProductCache>} data - The cache data to update.
-             * @returns {Promise<void>} Resolves when the cache is updated. Throws on error.
+             * Get migration status
              */
-            update: (tag: string, data: Partial<IProductCache>) => Promise<void>;
-            values: (data: FetchRemoteCachePayload) => Promise<import("./types").IRemoteCache[]>;
+            status: (migrations: Parameters<DatabaseService["getMigrationStatus"]>[0]) => Promise<import("./database").IMigrationStatusResult>;
         };
-        features: {
-            /**
-             * Creates a feature for a product.
-             * @param {Partial<IProductFeature>} data - The feature data.
-             * @returns {Promise<void>} Resolves when the feature is created. Throws on error.
-             */
-            create: (data: Partial<IProductFeature>) => Promise<void>;
-            /**
-             * Fetches all features for a product.
-             * @returns {IProductFeature[]} The list of features.
-             */
-            fetchAll: () => Promise<IProductFeature[]>;
-            /**
-             * Fetches a feature by tag.
-             * @param {string} tag - The feature tag.
-             * @returns {IProductFeature|null} The fetched feature, or null if not found.
-             */
-            fetch: (tag: string) => Promise<IProductFeature>;
-            /**
-             * Updates a feature by tag.
-             * @param {string} tag - The feature tag.
-             * @param {Partial<IProductCache>} data - The feature data to update.
-             * @returns {Promise<void>} Resolves when the feature is updated. Throws on error.
-             */
-            update: (tag: string, data: Partial<IProductCache>) => Promise<void>;
+        /**
+         * Action CRUD sub-object
+         */
+        action: {
+            create: (options: IActionCreateOptions) => Promise<void>;
+            update: (options: IActionUpdateOptions) => Promise<void>;
+            fetch: (tag: string) => Promise<import("./database").IActionDefinition>;
+            list: (databaseTag: string) => Promise<import("./database").IActionDefinition[]>;
+            delete: (tag: string) => Promise<void>;
+            dispatch: (data: IDBActionDispatchInput) => Promise<IDispatchResult>;
         };
+        /**
+         * Dispatch a database operation as a scheduled job
+         */
+        dispatch: (data: Parameters<DatabaseService["dispatch"]>[0]) => Promise<IDispatchResult>;
+        /**
+         * Get the adapter for the current connection
+         */
+        getAdapter: (options?: Parameters<DatabaseService["getAdapter"]>[0]) => Promise<import("./database").BaseAdapter>;
+        /**
+         * Get the underlying DatabaseService instance (for advanced usage)
+         */
+        getService: () => Promise<DatabaseService>;
+    };
+    /**
+     * Graph database operations service.
+     * Provides a unified API for graph database operations including nodes, relationships,
+     * traversals, and transactions.
+     *
+     * @example
+     * // Register a new graph database
+     * await ductape.graph.create({
+     *   name: 'Social Graph',
+     *   tag: 'social-graph',
+     *   type: 'neo4j',
+     *   envs: [{ slug: 'dev', connection_url: 'bolt://localhost:7687' }],
+     * });
+     */
+    graph: {
+        /**
+         * Get the underlying GraphService instance
+         */
+        getService: () => Promise<GraphService>;
+    };
+    /**
+     * Workflow service for building and executing durable workflows.
+     *
+     * @example
+     * // Create a workflow from JSON schema
+     * await ductape.workflows.create('my-product', {
+     *   tag: 'order-fulfillment',
+     *   name: 'Order Fulfillment',
+     *   steps: [...],
+     * });
+     */
+    workflows: {
+        /**
+         * Get the underlying WorkflowService instance
+         */
+        getService: () => Promise<WorkflowService>;
+    };
+    /**
+     * Agents service for building and executing AI-driven agentic workflows.
+     *
+     * @example
+     * // Define an agent
+     * await ductape.agents.define({
+     *   tag: 'customer-support',
+     *   name: 'Customer Support Agent',
+     *   model: { provider: 'anthropic', model: 'claude-sonnet-4-20250514' },
+     * });
+     */
+    agents: {
+        /**
+         * Get the underlying AgentsService instance
+         */
+        getService: () => Promise<AgentsService>;
+    };
+    /**
+     * LLM Model operations for managing model configurations.
+     *
+     * @example
+     * // Create a model configuration
+     * await ductape.models.create({
+     *   product: 'my-product',
+     *   tag: 'claude-sonnet',
+     *   name: 'Claude Sonnet',
+     *   provider: 'anthropic',
+     * });
+     */
+    models: {
+        /**
+         * Get the underlying ModelService instance
+         */
+        getService: () => Promise<ModelService>;
+    };
+    /**
+     * Vector database operations service.
+     *
+     * @example
+     * // Create a vector database configuration
+     * await ductape.vector.create({
+     *   product: 'my-product',
+     *   tag: 'embeddings',
+     *   name: 'Document Embeddings',
+     * });
+     */
+    vector: {
+        /**
+         * Get the underlying VectorDatabaseService instance
+         */
+        getService: () => Promise<VectorDatabaseService>;
+    };
+    /**
+     * Job-related operations for managing product jobs.
+     */
+    jobs: {
+        /**
+         * Creates a job for a product.
+         * @param {string} product - The product tag.
+         * @param {Partial<IProductJobs>} data - The job data.
+         * @returns {Promise<void>} Resolves when the job is created. Throws on error.
+         */
+        create: (product: string, data: Partial<IProductJobs>) => Promise<void>;
+        /**
+         * Fetches all jobs for a product.
+         * @param {string} product - The product tag.
+         * @returns {IProductJobs[]} The list of jobs.
+         */
+        list: (product: string) => Promise<IProductJobs[]>;
+        /**
+         * Fetches a job by tag.
+         * @param {string} product - The product tag.
+         * @param {string} tag - The job tag.
+         * @returns {IProductJobs|null} The fetched job, or null if not found.
+         */
+        fetch: (product: string, tag: string) => Promise<IProductJobs>;
+        /**
+         * Updates a job by tag.
+         * @param {string} product - The product tag.
+         * @param {string} tag - The job tag.
+         * @param {Partial<IProductJobs>} data - The job data to update.
+         * @returns {Promise<void>} Resolves when the job is updated. Throws on error.
+         */
+        update: (product: string, tag: string, data: Partial<IProductJobs>) => Promise<void>;
+        /**
+         * Deletes a job by tag.
+         * @param {string} product - The product tag.
+         * @param {string} tag - The job tag.
+         * @returns {Promise<void>} Resolves when the job is deleted. Throws on error.
+         */
+        delete: (product: string, tag: string) => Promise<void>;
+        /**
+         * Get a scheduled/running job by ID
+         * @param jobId - The job ID
+         * @returns The job details or null if not found
+         * @example
+         * const job = await ductape.jobs.get('job_abc123');
+         * console.log(job.status); // 'scheduled', 'running', 'completed', etc.
+         */
+        get: (jobId: string) => Promise<import("./jobs").IJob>;
+        /**
+         * List jobs with filtering options
+         * @param options - Filter options
+         * @returns Paginated list of jobs
+         * @example
+         * const { jobs, total } = await ductape.jobs.listJobs({
+         *   product: 'my-product',
+         *   status: JobStatus.SCHEDULED,
+         *   limit: 20,
+         * });
+         */
+        listJobs: (options?: IJobListOptions) => Promise<import("./jobs").IJobListResult>;
+        /**
+         * Cancel a scheduled or running job
+         * @param jobId - The job ID
+         * @param options - Cancel options
+         * @returns The cancelled job or null
+         * @example
+         * await ductape.jobs.cancel('job_abc123', { reason: 'User requested' });
+         */
+        cancel: (jobId: string, options?: ICancelOptions) => Promise<import("./jobs").IJob>;
+        /**
+         * Cancel multiple jobs matching a filter
+         * @param filter - Filter to match jobs
+         * @returns Count of cancelled jobs
+         */
+        cancelMany: (filter: {
+            product?: string;
+            status?: JobStatus;
+        }) => Promise<{
+            count: number;
+        }>;
+        /**
+         * Pause a recurring job
+         * @param jobId - The job ID
+         * @returns The paused job or null
+         * @example
+         * await ductape.jobs.pause('job_abc123');
+         */
+        pause: (jobId: string) => Promise<import("./jobs").IJob>;
+        /**
+         * Pause multiple jobs matching a filter
+         * @param filter - Filter to match jobs
+         * @returns Count of paused jobs
+         */
+        pauseMany: (filter: {
+            product?: string;
+            recurring?: boolean;
+        }) => Promise<{
+            count: number;
+        }>;
+        /**
+         * Resume a paused job
+         * @param jobId - The job ID
+         * @returns The resumed job or null
+         * @example
+         * await ductape.jobs.resume('job_abc123');
+         */
+        resume: (jobId: string) => Promise<import("./jobs").IJob>;
+        /**
+         * Resume multiple jobs matching a filter
+         * @param filter - Filter to match jobs
+         * @returns Count of resumed jobs
+         */
+        resumeMany: (filter: {
+            product?: string;
+            status?: JobStatus;
+        }) => Promise<{
+            count: number;
+        }>;
+        /**
+         * Retry a failed job
+         * @param jobId - The job ID
+         * @param options - Retry options
+         * @returns The retried job or null
+         * @example
+         * await ductape.jobs.retry('job_abc123', { delay: 5000 });
+         */
+        retry: (jobId: string, options?: IRetryOptions) => Promise<import("./jobs").IJob>;
+        /**
+         * Retry multiple failed jobs matching a filter
+         * @param filter - Filter to match jobs
+         * @returns Count of retried jobs
+         */
+        retryMany: (filter: {
+            status?: JobStatus;
+            from?: number | string;
+        }) => Promise<{
+            count: number;
+        }>;
+        /**
+         * Reschedule a job for a different time
+         * @param jobId - The job ID
+         * @param options - Reschedule options
+         * @returns The rescheduled job or null
+         * @example
+         * await ductape.jobs.reschedule('job_abc123', {
+         *   start_at: Date.now() + 3600000, // 1 hour from now
+         * });
+         */
+        reschedule: (jobId: string, options: IRescheduleOptions) => Promise<import("./jobs").IJob>;
+        /**
+         * Get job execution history
+         * @param jobId - The job ID
+         * @param options - Options (limit)
+         * @returns Execution history
+         * @example
+         * const history = await ductape.jobs.getHistory('job_abc123');
+         * console.log(history.executions); // Array of past executions
+         */
+        getHistory: (jobId: string, options?: {
+            limit?: number;
+        }) => Promise<import("./jobs").IJobHistory>;
+        /**
+         * Get job statistics
+         * @param options - Filter options
+         * @returns Job statistics
+         * @example
+         * const stats = await ductape.jobs.getStats({ product: 'my-product' });
+         * console.log(stats.total, stats.completed, stats.failed);
+         */
+        getStats: (options?: {
+            product?: string;
+            env?: string;
+            from?: number;
+            to?: number;
+        }) => Promise<import("./jobs").IJobStats>;
+        /**
+         * Set a webhook for job events
+         * @param config - Webhook configuration
+         * @returns Promise<void>
+         * @example
+         * await ductape.jobs.setWebhook({
+         *   url: 'https://api.example.com/webhooks/jobs',
+         *   events: ['completed', 'failed'],
+         *   secret: 'webhook-secret',
+         * });
+         */
+        setWebhook: (config: IJobWebhookConfig) => Promise<void>;
+        /**
+         * Get the underlying JobsService instance (for advanced usage)
+         */
+        getService: () => Promise<JobsService>;
+    };
+    /**
+     * Secrets management for workspace secrets.
+     *
+     * Secrets allow you to store sensitive values (API keys, passwords, etc.) securely
+     * and reference them in configurations using the $Secret{key} syntax.
+     *
+     * @example
+     * // Create a secret
+     * await ductape.secrets.create({
+     *   key: 'STRIPE_API_KEY',
+     *   value: 'sk_live_51ABC123...',
+     *   description: 'Production Stripe API key',
+     *   scope: ['payment_app'],
+     *   envs: ['prd'],
+     * });
+     *
+     * // Use secret in database config
+     * await ductape.databases.create({
+     *   tag: 'main-db',
+     *   name: 'Main Database',
+     *   type: 'mongodb',
+     *   envs: [{
+     *     slug: 'prd',
+     *     connection_url: '$Secret{MONGODB_CONNECTION_URL}'
+     *   }]
+     * });
+     */
+    secrets: {
+        /**
+         * Create a new secret in the workspace
+         * @param input - Secret creation input
+         * @returns The created secret metadata (without value)
+         * @example
+         * const secret = await ductape.secrets.create({
+         *   key: 'STRIPE_API_KEY',
+         *   value: 'sk_live_51ABC123...',
+         *   description: 'Production Stripe API key',
+         *   token_type: 'api',
+         *   scope: ['payment_app'],
+         *   envs: ['prd'],
+         *   expires_at: Math.floor(Date.now() / 1000) + (365 * 24 * 60 * 60)
+         * });
+         */
+        create: (input: ICreateSecretInput) => Promise<ISecretMetadata>;
+        /**
+         * Fetch all secrets in the workspace (metadata only, no values)
+         * @returns Array of secret metadata
+         * @example
+         * const secrets = await ductape.secrets.fetchAll();
+         * secrets.forEach(s => console.log(s.key, s.description));
+         */
+        fetchAll: () => Promise<ISecretMetadata[]>;
+        /**
+         * Fetch a single secret with its decrypted value
+         * @param key - The secret key
+         * @returns The full secret including decrypted value
+         * @example
+         * const secret = await ductape.secrets.fetch('STRIPE_API_KEY');
+         * console.log(secret.value); // sk_live_51ABC123...
+         */
+        fetch: (key: string) => Promise<ISecret>;
+        /**
+         * Update an existing secret
+         * @param key - The secret key to update
+         * @param input - Update data
+         * @returns Updated secret metadata
+         * @example
+         * await ductape.secrets.update('STRIPE_API_KEY', {
+         *   value: 'sk_live_NEW_KEY...',
+         *   description: 'Rotated Stripe API key'
+         * });
+         */
+        update: (key: string, input: IUpdateSecretInput) => Promise<ISecretMetadata>;
+        /**
+         * Delete a secret permanently
+         * @param key - The secret key to delete
+         * @returns true if deleted successfully
+         * @example
+         * await ductape.secrets.delete('OLD_API_KEY');
+         */
+        delete: (key: string) => Promise<boolean>;
+        /**
+         * Revoke a secret (disable without deleting)
+         * @param key - The secret key to revoke
+         * @returns true if revoked successfully
+         * @example
+         * await ductape.secrets.revoke('COMPROMISED_KEY');
+         */
+        revoke: (key: string) => Promise<boolean>;
+        /**
+         * Check if a secret exists
+         * @param key - The secret key to check
+         * @returns true if the secret exists
+         * @example
+         * if (await ductape.secrets.exists('MY_SECRET')) {
+         *   console.log('Secret exists');
+         * }
+         */
+        exists: (key: string) => Promise<boolean>;
+        /**
+         * Resolve all $Secret{key} references in a value
+         * Works with strings, objects, and arrays
+         * @param value - The value containing secret references
+         * @param options - Resolution options (app, env for scope/env validation)
+         * @returns Resolved value with secrets replaced
+         * @example
+         * const config = {
+         *   apiKey: '$Secret{API_KEY}',
+         *   dbUrl: '$Secret{DB_URL}'
+         * };
+         * const resolved = await ductape.secrets.resolve(config, { env: 'prd' });
+         */
+        resolve: <T>(value: T, options?: IResolveSecretsOptions) => Promise<import("./secrets").ISecretResolutionResult<T>>;
+        /**
+         * Validate that all $Secret{key} references in a value exist
+         * @param value - The value containing secret references
+         * @returns Validation result with existing and missing keys
+         * @example
+         * const result = await ductape.secrets.validate({
+         *   url: '$Secret{API_URL}',
+         *   key: '$Secret{MISSING_KEY}'
+         * });
+         * if (!result.valid) {
+         *   console.error('Missing secrets:', result.missingKeys);
+         * }
+         */
+        validate: (value: unknown) => Promise<{
+            valid: boolean;
+            missingKeys: string[];
+            existingKeys: string[];
+        }>;
+        /**
+         * Get the underlying SecretsService instance (for advanced usage)
+         */
+        getService: () => Promise<SecretsService>;
     };
     /**
-     * App-related operations for managing apps, variables, constants, actions, auths, webhooks, environments, and validation.
+     * Cache-related operations for managing product caches.
+     */
+    caches: {
+        /**
+         * Creates a cache for a product.
+         * @param {string} product - The product tag.
+         * @param {IProductCache} data - The cache data.
+         * @returns {Promise<void>} Resolves when the cache is created. Throws on error.
+         */
+        create: (product: string, data: IProductCache) => Promise<void>;
+        /**
+         * Fetches all caches for a product.
+         * @param {string} product - The product tag.
+         * @returns {IProductCache[]} The list of caches.
+         */
+        list: (product: string) => Promise<IProductCache[]>;
+        /**
+         * Fetches a cache by tag.
+         * @param {string} product - The product tag.
+         * @param {string} tag - The cache tag.
+         * @returns {IProductCache|null} The fetched cache, or null if not found.
+         */
+        fetch: (product: string, tag: string) => Promise<IProductCache>;
+        /**
+         * Updates a cache by tag.
+         * @param {string} product - The product tag.
+         * @param {string} tag - The cache tag.
+         * @param {Partial<IProductCache>} data - The cache data to update.
+         * @returns {Promise<void>} Resolves when the cache is updated. Throws on error.
+         */
+        update: (product: string, tag: string, data: Partial<IProductCache>) => Promise<void>;
+        /**
+         * Deletes a cache by tag.
+         * @param {string} product - The product tag.
+         * @param {string} tag - The cache tag.
+         * @returns {Promise<void>} Resolves when the cache is deleted. Throws on error.
+         */
+        delete: (product: string, tag: string) => Promise<void>;
+        values: (data: FetchRemoteCachePayload) => Promise<import("./types").IRemoteCache[]>;
+        /**
+         * Fetch paginated cache values with filtering options.
+         * @param options - Options for fetching cache values
+         * @returns Paginated cache values result
+         * @example
+         * ```ts
+         * const result = await ductape.caches.fetchValues({
+         *   product: 'my-product',
+         *   cache: 'user-cache',
+         *   page: 1,
+         *   limit: 20,
+         * });
+         * ```
+         */
+        fetchValues: (options: {
+            product: string;
+            cache: string;
+            env?: string;
+            page?: number;
+            limit?: number;
+        }) => Promise<import("./cache").IFetchCacheValuesResult>;
+        /**
+         * Fetch cache dashboard metrics.
+         * @param options - Options for fetching dashboard
+         * @returns Cache dashboard metrics
+         * @example
+         * ```ts
+         * const dashboard = await ductape.caches.fetchDashboard({
+         *   product: 'my-product',
+         *   cache: 'user-cache',
+         * });
+         * ```
+         */
+        fetchDashboard: (options: {
+            product: string;
+            cache: string;
+            env?: string;
+        }) => Promise<import("./cache").ICacheDashboardMetrics>;
+        /**
+         * Get a cache value by key.
+         * @param options - Options containing the key
+         * @returns The cache value or null if not found
+         * @example
+         * ```ts
+         * const value = await ductape.caches.get({ key: 'user:123' });
+         * ```
+         */
+        get: (options: {
+            key: string;
+        }) => Promise<import("./cache").ICacheValue>;
+        /**
+         * Set a cache value.
+         * @param options - Options for setting the cache value
+         * @returns Boolean indicating success
+         * @example
+         * ```ts
+         * await ductape.caches.set({
+         *   product: 'my-product',
+         *   cache: 'user-cache',
+         *   key: 'user:123',
+         *   value: JSON.stringify({ name: 'John' }),
+         * });
+         * ```
+         */
+        set: (options: {
+            product: string;
+            cache: string;
+            key: string;
+            value: string;
+            componentTag?: string;
+            componentType?: string;
+            expiry?: Date;
+        }) => Promise<boolean>;
+        /**
+         * Clear a cache value by key.
+         * @param options - Options containing the key
+         * @returns Boolean indicating success
+         * @example
+         * ```ts
+         * await ductape.caches.clear({ key: 'user:123' });
+         * ```
+         */
+        clear: (options: {
+            key: string;
+        }) => Promise<boolean>;
+        /**
+         * Clear all cache values for a product/cache combination.
+         * @param options - Options for clearing cache values
+         * @returns Object with cleared count
+         * @example
+         * ```ts
+         * const result = await ductape.caches.clearAll({
+         *   product: 'my-product',
+         *   cache: 'user-cache',
+         * });
+         * console.log('Cleared:', result.cleared);
+         * ```
+         */
+        clearAll: (options: {
+            product: string;
+            cache: string;
+            env?: string;
+        }) => Promise<import("./cache").IClearCacheValuesResult>;
+    };
+    /**
+     * App-related operations for managing apps.
      */
     app: {
         /**
@@ -869,474 +1988,395 @@ export default class Ductape implements IDuctape {
          */
         update: (tag: string, data: Partial<IApp>) => Promise<void>;
         /**
-         * Initializes an app by tag.
+         * Initializes an app by tag (pre-loads builder into cache).
          * @param {string} appTag - The app tag.
          * @returns {Promise<void>} Resolves when initialization is complete. Throws on error.
          */
         init: (appTag: string) => Promise<void>;
-        variables: {
-            /**
-             * Creates a variable for an app.
-             * @param {IAppVariables} data - The variable data.
-             * @returns {Promise<void>} Resolves when the variable is created. Throws on error.
-             */
-            create: (data: IAppVariables) => Promise<void>;
-            /**
-             * Fetches all variables for an app.
-             * @returns {IAppVariables[]} The list of variables.
-             */
-            fetchAll: () => Promise<IAppVariables[]>;
-            /**
-             * Fetches a variable by tag.
-             * @param {string} tag - The variable tag.
-             * @returns {IAppVariables|null} The fetched variable, or null if not found.
-             */
-            fetch: (tag: string) => Promise<IAppVariables>;
-            /**
-             * Updates a variable by tag.
-             * @param {string} tag - The variable tag.
-             * @param {Partial<IAppVariables>} data - The variable data to update.
-             * @returns {Promise<void>} Resolves when the variable is updated. Throws on error.
-             */
-            update: (tag: string, data: Partial<IAppVariables>) => Promise<void>;
-        };
-        constants: {
-            /**
-             * Creates a constant for an app.
-             * @param {IAppConstants} data - The constant data.
-             * @returns {Promise<void>} Resolves when the constant is created. Throws on error.
-             */
-            create: (data: IAppConstants) => Promise<void>;
-            /**
-             * Fetches all constants for an app.
-             * @returns {IAppConstants[]} The list of constants.
-             */
-            fetchAll: () => Promise<IAppConstants[]>;
-            /**
-             * Fetches a constant by tag.
-             * @param {string} tag - The constant tag.
-             * @returns {IAppConstants|null} The fetched constant, or null if not found.
-             */
-            fetch: (tag: string) => Promise<IAppConstants>;
-            /**
-             * Updates a constant by tag.
-             * @param {string} tag - The constant tag.
-             * @param {Partial<IAppVariables>} data - The constant data to update.
-             * @returns {Promise<void>} Resolves when the constant is updated. Throws on error.
-             */
-            update: (tag: string, data: Partial<IAppVariables>) => Promise<void>;
-        };
-        actions: {
-            /**
-             * Imports actions for an app from a file.
-             * @param {Object} params - The import parameters.
-             * @param {Buffer} params.file - The file buffer.
-             * @param {ImportDocsTypes} params.type - The import type.
-             * @param {string} params.version - The version.
-             * @param {string} [params.appTag] - The app tag (optional).
-             * @param {boolean} [params.updateIfExists] - Whether to update if actions exist (optional).
-             * @returns {Promise<void>} Resolves when the import is complete. Throws on error.
-             */
-            import: ({ file, type, version, appTag, updateIfExists, isAdminImport, }: {
-                file: Buffer;
-                type: ImportDocsTypes;
-                version: string;
-                appTag?: string;
-                updateIfExists?: boolean;
-                isAdminImport?: boolean;
-            }) => Promise<void>;
-            /**
-             * Updates an action by tag.
-             * @param {string} tag - The action tag.
-             * @param {Partial<IActionUpdate>} data - The action data to update.
-             * @returns {Promise<void>} Resolves when the action is updated. Throws on error.
-             */
-            update: (tag: string, data: Partial<IActionUpdate>) => Promise<void>;
-            /**
-             * Updates multiple actions at once with shared variables (query params or headers).
-             * @param {string[]} tags - Array of action tags to update.
-             * @param {Object} data - The shared variable data.
-             * @param {'query' | 'headers'} data.category - The variable type (query params or headers).
-             * @param {string} data.key - The variable key.
-             * @param {string} data.value - The variable value.
-             * @returns {Promise<void>} Resolves when all actions are updated. Throws on error.
-             */
-            updateMany: (tags: string[], data: {
-                category: "query" | "headers";
-                key: string;
-                value: string;
-            }) => Promise<void>;
-            /**
-             * Creates an action.
-             * @param {Partial<IActionUpdate> & { tag: string; name: string; resource: string; method: string }} data - The action data to create.
-             * @returns {Promise<void>} Resolves when the action is created. Throws on error.
-             */
-            create: (data: Partial<IActionUpdate> & {
-                tag: string;
-                name: string;
-                resource: string;
-                method: string;
-            }) => Promise<void>;
-            /**
-             * Fetches all actions for an app.
-             * @returns {IAppAction[]} The list of actions.
-             */
-            fetchAll: () => Promise<IAppAction[]>;
-            /**
-             * Fetches an action by tag.
-             * @param {string} tag - The action tag.
-             * @returns {IAppAction|null} The fetched action, or null if not found.
-             */
-            fetch: (tag: string) => Promise<IAppAction>;
-        };
-        auths: {
-            /**
-             * Creates an auth for an app.
-             * @param {IAppAuth} data - The auth data.
-             * @returns {Promise<void>} Resolves when the auth is created. Throws on error.
-             */
-            create: (data: IAppAuth) => Promise<void>;
-            /**
-             * Fetches all auths for an app.
-             * @returns {IAppAuth[]} The list of auths.
-             */
-            fetchAll: () => Promise<IAppAuth[]>;
-            /**
-             * Fetches an auth by tag.
-             * @param {string} tag - The auth tag.
-             * @returns {IAppAuth|null} The fetched auth, or null if not found.
-             */
-            fetch: (tag: string) => Promise<IAppAuth>;
-            /**
-             * Updates an auth by tag.
-             * @param {string} tag - The auth tag.
-             * @param {Partial<IAppAuth>} data - The auth data to update.
-             * @returns {Promise<void>} Resolves when the auth is updated. Throws on error.
-             */
-            update: (tag: string, data: Partial<IAppAuth>) => Promise<void>;
-        };
-        webhooks: {
-            /**
-             * Creates a webhook for an app.
-             * @param {Partial<IAppWebhook>} data - The webhook data.
-             * @returns {Promise<void>} Resolves when the webhook is created. Throws on error.
-             */
-            create: (data: Partial<IAppWebhook>) => Promise<void>;
-            /**
-             * Fetches all webhooks for an app.
-             * @returns {IAppWebhook[]} The list of webhooks.
-             */
-            fetchAll: () => Promise<IAppWebhook[]>;
-            /**
-             * Fetches a webhook by tag.
-             * @param {string} tag - The webhook tag.
-             * @returns {IAppWebhook|null} The fetched webhook, or null if not found.
-             */
-            fetch: (tag: string) => Promise<IAppWebhook>;
-            /**
-             * Updates a webhook by tag.
-             * @param {string} tag - The webhook tag.
-             * @param {Partial<IAppWebhook>} data - The webhook data to update.
-             * @returns {Promise<void>} Resolves when the webhook is updated. Throws on error.
-             */
-            update: (tag: string, data: Partial<IAppWebhook>) => Promise<void>;
-            events: {
-                /**
-                 * Creates a webhook event for an app.
-                 * @param {IAppWebhookEvent} data - The webhook event data.
-                 * @returns {Promise<void>} Resolves when the webhook event is created. Throws on error.
-                 */
-                create: (data: IAppWebhookEvent) => Promise<void>;
-                /**
-                 * Fetches all webhook events for a webhook by tag.
-                 * @param {string} webhookTag - The webhook tag.
-                 * @returns {IAppWebhookEvent[]} The list of webhook events.
-                 */
-                fetchAll: (webhookTag: string) => Promise<IAppWebhookEvent[]>;
-                /**
-                 * Fetches a webhook event by tag.
-                 * @param {string} tag - The webhook event tag.
-                 * @returns {IAppWebhookEvent|null} The fetched webhook event, or null if not found.
-                 */
-                fetch: (tag: string) => Promise<IAppWebhookEvent>;
-                /**
-                 * Updates a webhook event by tag.
-                 * @param {string} tag - The webhook event tag.
-                 * @param {Partial<IAppWebhookEvent>} data - The webhook event data to update.
-                 * @returns {Promise<void>} Resolves when the webhook event is updated. Throws on error.
-                 */
-                update: (tag: string, data: Partial<IAppWebhookEvent>) => Promise<void>;
-            };
-        };
+        /**
+         * Updates data validation for an app.
+         * @param {string} appTag - The app tag.
+         * @param {string} selector - The selector for the data validation.
+         * @param {Partial<IParsedSample>} update - The update data.
+         * @returns {Promise<void>} Resolves when the validation is updated. Throws on error.
+         */
+        validation: (appTag: string, selector: string, update: Partial<IParsedSample>) => Promise<void>;
         environments: {
             /**
              * Creates an environment for an app.
+             * @param {string} appTag - The app tag.
              * @param {IAppEnv} data - The environment data.
              * @returns {Promise<void>} Resolves when the environment is created. Throws on error.
              */
-            create: (data: IAppEnv) => Promise<void>;
+            create: (appTag: string, data: IAppEnv) => Promise<void>;
             /**
              * Fetches all environments for an app.
+             * @param {string} appTag - The app tag.
              * @returns {IAppEnv[]} The list of environments.
              */
-            fetchAll: () => Promise<IAppEnv[]>;
+            list: (appTag: string) => Promise<IAppEnv[]>;
             /**
              * Fetches an environment by slug.
+             * @param {string} appTag - The app tag.
              * @param {string} slug - The environment slug.
              * @returns {IAppEnv|null} The fetched environment, or null if not found.
              */
-            fetch: (slug: string) => Promise<IAppEnv>;
+            fetch: (appTag: string, slug: string) => Promise<IAppEnv>;
             /**
              * Updates an environment by slug.
+             * @param {string} appTag - The app tag.
              * @param {string} slug - The environment slug.
              * @param {Partial<IAppEnv>} data - The environment data to update.
              * @returns {Promise<void>} Resolves when the environment is updated. Throws on error.
              */
-            update: (slug: string, data: Partial<IAppEnv>) => Promise<void>;
+            update: (appTag: string, slug: string, data: Partial<IAppEnv>) => Promise<void>;
         };
-        /**
-         * Updates data validation for an app.
-         * @param {string} selector - The selector for the data validation.
-         * @param {Partial<IParsedSample>} update - The update data.
-         * @returns {Promise<void>} Resolves when the validation is updated. Throws on error.
-         */
-        validation: (selector: string, update: Partial<IParsedSample>) => Promise<void>;
     };
     /**
-     * Job-related operations for scheduling jobs.
+     * Variable-related operations for managing app variables.
      */
-    job: {
+    variables: {
         /**
-         * Schedules a job for a product.
-         * @param {IProduct} data - The product data.
-         * @returns {Promise<any>} The result of the job scheduling.
+         * Creates a variable for an app.
+         * @param {string} appTag - The app tag.
+         * @param {IAppVariables} data - The variable data.
+         * @returns {Promise<void>} Resolves when the variable is created. Throws on error.
          */
-        schedule: (data: IProduct) => Promise<void>;
-    };
-    /**
-     * Action-related operations for running actions.
-     */
-    action: {
+        create: (appTag: string, data: IAppVariables) => Promise<void>;
         /**
-         * Runs an action processor.
-         * @param {IActionProcessorInput} data - The action processor input.
-         * @returns {Promise<any>} The result of the action processing.
+         * Fetches all variables for an app.
+         * @param {string} appTag - The app tag.
+         * @returns {IAppVariables[]} The list of variables.
          */
-        run: (data: IActionProcessorInput) => Promise<any>;
+        list: (appTag: string) => Promise<IAppVariables[]>;
+        /**
+         * Fetches a variable by tag.
+         * @param {string} appTag - The app tag.
+         * @param {string} tag - The variable tag.
+         * @returns {IAppVariables|null} The fetched variable, or null if not found.
+         */
+        fetch: (appTag: string, tag: string) => Promise<IAppVariables>;
+        /**
+         * Updates a variable by tag.
+         * @param {string} appTag - The app tag.
+         * @param {string} tag - The variable tag.
+         * @param {Partial<IAppVariables>} data - The variable data to update.
+         * @returns {Promise<void>} Resolves when the variable is updated. Throws on error.
+         */
+        update: (appTag: string, tag: string, data: Partial<IAppVariables>) => Promise<void>;
     };
     /**
-     * Session-related operations for creating, validating, and refreshing sessions.
+     * Constant-related operations for managing app constants.
      */
-    sessions: {
+    constants: {
         /**
-         * Starts a new session.
-         * @param {ISessionInput} data - The session input data.
-         * @returns {Promise<any>} The result of the session generation.
+         * Creates a constant for an app.
+         * @param {string} appTag - The app tag.
+         * @param {IAppConstants} data - The constant data.
+         * @returns {Promise<void>} Resolves when the constant is created. Throws on error.
          */
-        create: (data: ISessionInput) => Promise<import("./types").ISessionOutput>;
+        create: (appTag: string, data: IAppConstants) => Promise<void>;
         /**
-         * Decrypts a session.
-         * @param {ISessionPayload} data - The session payload.
-         * @returns {Promise<any>} The decrypted session.
+         * Fetches all constants for an app.
+         * @param {string} appTag - The app tag.
+         * @returns {IAppConstants[]} The list of constants.
          */
-        validate: (data: ISessionPayload) => Promise<any>;
+        list: (appTag: string) => Promise<IAppConstants[]>;
         /**
-         * Refreshes a session.
-         * @param {ISessionRefreshPayload} data - The session refresh payload.
-         * @returns {Promise<any>} The refreshed session.
+         * Fetches a constant by tag.
+         * @param {string} appTag - The app tag.
+         * @param {string} tag - The constant tag.
+         * @returns {IAppConstants|null} The fetched constant, or null if not found.
          */
-        refresh: (data: ISessionRefreshPayload) => Promise<import("./types").ISessionOutput>;
+        fetch: (appTag: string, tag: string) => Promise<IAppConstants>;
+        /**
+         * Updates a constant by tag.
+         * @param {string} appTag - The app tag.
+         * @param {string} tag - The constant tag.
+         * @param {Partial<IAppVariables>} data - The constant data to update.
+         * @returns {Promise<void>} Resolves when the constant is updated. Throws on error.
+         */
+        update: (appTag: string, tag: string, data: Partial<IAppVariables>) => Promise<void>;
     };
     /**
-     * Feature-related operations for running, replaying, and resuming features.
+     * Action-related operations for managing app actions.
      */
-    feature: {
+    actions: {
         /**
-         * Runs a feature processor.
-         * @param {IProcessorInput} data - The feature processor input.
-         * @returns {Promise<any>} The result of the feature processing.
+         * Imports actions for an app from a file.
+         * @param {Object} params - The import parameters.
+         * @param {Buffer} params.file - The file buffer.
+         * @param {ImportDocsTypes} params.type - The import type.
+         * @param {string} params.version - The version.
+         * @param {string} [params.appTag] - The app tag (optional).
+         * @param {boolean} [params.updateIfExists] - Whether to update if actions exist (optional).
+         * @returns {Promise<void>} Resolves when the import is complete. Throws on error.
          */
-        run: (data: IProcessorInput) => Promise<{
-            process_id: string;
-        }>;
+        import: ({ file, type, version, appTag, updateIfExists, isAdminImport, }: {
+            file: Buffer;
+            type: ImportDocsTypes;
+            version: string;
+            appTag?: string;
+            updateIfExists?: boolean;
+            isAdminImport?: boolean;
+        }) => Promise<void>;
         /**
-         * Generates output for a process by ID.
-         * @param {string} process_id - The process ID.
-         * @returns {Promise<any>} The generated output.
+         * Updates an action by tag.
+         * @param {string} appTag - The app tag.
+         * @param {string} tag - The action tag.
+         * @param {Partial<IActionUpdate>} data - The action data to update.
+         * @returns {Promise<void>} Resolves when the action is updated. Throws on error.
          */
-        output: (process_id: string) => Promise<{
-            process_id: string;
-            status: import("./types").LogEventStatus;
-            data: Record<string, unknown>;
-            errors?: undefined;
-        } | {
-            process_id: string;
-            status: import("./types").LogEventStatus;
-            errors: string[];
-            data?: undefined;
-        } | {
-            process_id: string;
-            status: import("./types").LogEventStatus;
-            data?: undefined;
-            errors?: undefined;
-        }>;
+        update: (appTag: string, tag: string, data: Partial<IActionUpdate>) => Promise<void>;
         /**
-         * Replays a process by ID.
-         * @param {string} process_id - The process ID.
-         * @returns {Promise<any>} The result of the replay.
+         * Creates an action.
+         * @param {string} appTag - The app tag.
+         * @param {Partial<IActionUpdate> & { tag: string; name: string; resource: string; method: string }} data - The action data.
+         * @returns {Promise<void>} Resolves when the action is created. Throws on error.
          */
-        replay: (process_id: string) => Promise<{
-            process_id: string;
-        }>;
+        create: (appTag: string, data: Partial<IActionUpdate> & {
+            tag: string;
+            name: string;
+            resource: string;
+            method: string;
+        }) => Promise<void>;
         /**
-         * Resumes a process by ID.
-         * @param {string} process_id - The process ID.
-         * @returns {Promise<any>} The result of the resume.
+         * Fetches all actions for an app.
+         * @param {string} appTag - The app tag.
+         * @returns {IAppAction[]} The list of actions.
          */
-        resume: (process_id: string) => Promise<{
-            process_id: string;
-        }>;
-    };
-    /**
-     * Quota-related operations for running quota processors.
-     */
-    quota: {
+        list: (appTag: string) => Promise<IAppAction[]>;
         /**
-         * Runs a quota processor.
-         * @param {IProcessorInput} data - The quota processor input.
-         * @returns {Promise<any>} The result of the quota processing.
+         * Fetches an action by tag.
+         * @param {string} appTag - The app tag.
+         * @param {string} tag - The action tag.
+         * @returns {IAppAction|null} The fetched action, or null if not found.
          */
-        run: (data: IProcessorInput) => Promise<any>;
-    };
-    /**
-     * Fallback-related operations for running fallback processors.
-     */
-    fallback: {
+        fetch: (appTag: string, tag: string) => Promise<IAppAction>;
         /**
-         * Runs a fallback processor.
-         * @param {IProcessorInput} data - The fallback processor input.
-         * @returns {Promise<any>} The result of the fallback processing.
+         * Runs an action processor immediately.
+         * @param {IActionProcessorInput} data - The action processor input.
+         * @returns {Promise<any>} The result of the action processing.
+         * @example
+         * await ductape.actions.run({
+         *   product: 'my-product',
+         *   env: 'production',
+         *   app: 'stripe',
+         *   action: 'charge',
+         *   input: { amount: 1000, currency: 'usd' }
+         * });
          */
-        run: (data: IProcessorInput) => Promise<any>;
-    };
-    /**
-     * Notification-related operations for sending notifications.
-     */
-    notification: {
+        run: (data: IActionProcessorInput) => Promise<any>;
         /**
-         * Sends a notification using the notification processor.
-         * @param {INotificationProcessorInput} data - The notification processor input.
-         * @returns {Promise<any>} The result of the notification processing.
+         * Dispatches an action to run as a scheduled job.
+         * @param {IActionDispatchInput} data - The action dispatch input with scheduling options.
+         * @returns {Promise<IDispatchResult>} The dispatch result with job ID and status.
+         * @example
+         * // Run once at a specific time
+         * await ductape.actions.dispatch({
+         *   product: 'my-product',
+         *   env: 'production',
+         *   app: 'stripe',
+         *   event: 'charge',
+         *   input: { amount: 1000 },
+         *   schedule: { start_at: Date.now() + 3600000 } // 1 hour from now
+         * });
+         *
+         * // Run on a cron schedule
+         * await ductape.actions.dispatch({
+         *   product: 'my-product',
+         *   env: 'production',
+         *   app: 'analytics',
+         *   event: 'daily-report',
+         *   input: {},
+         *   schedule: { cron: '0 9 * * *', tz: 'America/New_York' } // 9 AM daily
+         * });
          */
-        send: (data: INotificationProcessorInput) => Promise<{
-            process_id: string;
-        }>;
-    };
-    /**
-     * Storage-related operations for reading and saving files.
-     */
-    storage: {
+        dispatch: (data: IActionDispatchInput) => Promise<IDispatchResult>;
         /**
-         * Reads a file from storage.
-         * @param {string} path - The file path.
-         * @returns {Promise<IFileReadResult>} The file read result.
+         * Set shared configuration (credentials) for a product/app/env combination.
+         * Credentials are automatically merged into action inputs before resolution.
+         * @param {IShareCredentialsConfig} config - The credential configuration.
+         * @example
+         * // Define app configuration and set credentials
+         * const stripeConfig = { product: 'my-product', app: 'stripe', env: 'prd' };
+         *
+         * ductape.actions.config({
+         *   ...stripeConfig,
+         *   credentials: {
+         *     'headers:Authorization': '$Secret{StripeApiKey}',
+         *   }
+         * });
+         *
+         * // Now all stripe actions automatically include the Authorization header
+         * await ductape.actions.run({
+         *   ...stripeConfig,
+         *   action: 'create-charge',
+         *   input: { amount: 1000, currency: 'usd' }
+         * });
          */
-        read: (path: string) => Promise<IFileReadResult>;
+        config: (config: IShareCredentialsConfig) => void;
         /**
-         * Saves data to storage using the storage processor.
-         * @param {IStorageProcessorInput} data - The storage processor input.
-         * @returns {Promise<any>} The result of the storage processing.
+         * Set up OAuth configuration with automatic token refresh for a product/app/env combination.
+         * Tokens are stored securely using $Secret{} and automatically refreshed when expired.
+         * @param {IOAuthConfig} config - The OAuth configuration.
+         * @example
+         * // Set up OAuth with automatic refresh using ductape.actions.run
+         * await ductape.actions.oauth({
+         *   product: 'my-product',
+         *   app: 'salesforce',
+         *   env: 'prd',
+         *   tokens: {
+         *     accessToken: initialAccessToken,
+         *     refreshToken: initialRefreshToken,
+         *   },
+         *   expiresAt: tokenExpiry,
+         *   credentials: (tokens) => ({
+         *     'headers:Authorization': `Bearer ${tokens.accessToken}`
+         *   }),
+         *   onExpiry: async (currentTokens) => {
+         *     // Use ductape.actions.run to call your refresh token action
+         *     const response = await ductape.actions.run({
+         *       product: 'my-product',
+         *       app: 'salesforce',
+         *       env: 'prd',
+         *       action: 'refresh-token',
+         *       input: {
+         *         'body:grant_type': 'refresh_token',
+         *         'body:refresh_token': currentTokens.refreshToken,
+         *       }
+         *     });
+         *     return {
+         *       tokens: {
+         *         accessToken: response.access_token,
+         *         refreshToken: response.refresh_token || currentTokens.refreshToken
+         *       },
+         *       expiresIn: response.expires_in
+         *     };
+         *   }
+         * });
+         *
+         * // Now all salesforce actions automatically include OAuth tokens
+         * // and refresh automatically when expired
+         * await ductape.actions.run({
+         *   product: 'my-product',
+         *   app: 'salesforce',
+         *   env: 'prd',
+         *   action: 'get-contacts',
+         *   input: { limit: 10 }
+         * });
          */
-        save: (data: IStorageProcessorInput) => Promise<any>;
+        oauth: (config: IOAuthConfig) => Promise<void>;
     };
     /**
-     * Message broker-related operations for publishing and subscribing to topics.
+     * Auth-related operations for managing app auths.
      */
-    broker: {
+    auths: {
         /**
-         * Publishes a message using the message broker processor.
-         * @param {IMessageBrokerPublishInput} data - The publish input.
-         * @returns {Promise<any>} The result of the publish operation.
+         * Creates an auth for an app.
+         * @param {string} appTag - The app tag.
+         * @param {IAppAuth} data - The auth data.
+         * @returns {Promise<void>} Resolves when the auth is created. Throws on error.
          */
-        publish: (data: IMessageBrokerPublishInput) => Promise<void | {
-            process_id: string;
-        }>;
+        create: (appTag: string, data: IAppAuth) => Promise<void>;
         /**
-         * Subscribes to a message broker topic.
-         * @param {IMessageBrokerSubscribeInput} data - The subscribe input.
-         * @returns {Promise<any>} The result of the subscribe operation.
+         * Fetches all auths for an app.
+         * @param {string} appTag - The app tag.
+         * @returns {IAppAuth[]} The list of auths.
          */
-        subcribe: (data: IMessageBrokerSubscribeInput) => Promise<void | {
-            process_id: string;
-        }>;
+        list: (appTag: string) => Promise<IAppAuth[]>;
+        /**
+         * Fetches an auth by tag.
+         * @param {string} appTag - The app tag.
+         * @param {string} tag - The auth tag.
+         * @returns {IAppAuth|null} The fetched auth, or null if not found.
+         */
+        fetch: (appTag: string, tag: string) => Promise<IAppAuth>;
+        /**
+         * Updates an auth by tag.
+         * @param {string} appTag - The app tag.
+         * @param {string} tag - The auth tag.
+         * @param {Partial<IAppAuth>} data - The auth data to update.
+         * @returns {Promise<void>} Resolves when the auth is updated. Throws on error.
+         */
+        update: (appTag: string, tag: string, data: Partial<IAppAuth>) => Promise<void>;
     };
     /**
-     * Processor-related operations for database actions only.
+     * Webhook-related operations for managing app webhooks.
      */
-    processor: {
-        db: {
+    webhooks: {
+        /**
+         * Creates a webhook for an app.
+         * @param {string} appTag - The app tag.
+         * @param {Partial<IAppWebhook>} data - The webhook data.
+         * @returns {Promise<void>} Resolves when the webhook is created. Throws on error.
+         */
+        create: (appTag: string, data: Partial<IAppWebhook>) => Promise<void>;
+        /**
+         * Fetches all webhooks for an app.
+         * @param {string} appTag - The app tag.
+         * @returns {IAppWebhook[]} The list of webhooks.
+         */
+        list: (appTag: string) => Promise<IAppWebhook[]>;
+        /**
+         * Fetches a webhook by tag.
+         * @param {string} appTag - The app tag.
+         * @param {string} tag - The webhook tag.
+         * @returns {IAppWebhook|null} The fetched webhook, or null if not found.
+         */
+        fetch: (appTag: string, tag: string) => Promise<IAppWebhook>;
+        /**
+         * Updates a webhook by tag.
+         * @param {string} appTag - The app tag.
+         * @param {string} tag - The webhook tag.
+         * @param {Partial<IAppWebhook>} data - The webhook data to update.
+         * @returns {Promise<void>} Resolves when the webhook is updated. Throws on error.
+         */
+        update: (appTag: string, tag: string, data: Partial<IAppWebhook>) => Promise<void>;
+        events: {
             /**
-             * Executes a database action processor.
-             * @param {IDBActionProcessorInput} data - The database action processor input.
-             * @returns {Promise<any>} The result of the database action processing.
+             * Creates a webhook event for an app.
+             * @param {string} appTag - The app tag.
+             * @param {IAppWebhookEvent} data - The webhook event data.
+             * @returns {Promise<void>} Resolves when the webhook event is created. Throws on error.
              */
-            execute: (data: IDBActionProcessorInput) => Promise<any>;
-            migration: {
-                /**
-                 * Runs a database migration.
-                 * @param {Object} params - The migration parameters.
-                 * @param {string} params.migration - The migration name.
-                 * @param {string} params.env - The environment.
-                 * @param {string} params.product - The product name.
-                 * @returns {Promise<any>} The result of the migration.
-                 */
-                run: ({ migration, env, product }: {
-                    migration: string;
-                    env: string;
-                    product: string;
-                }) => Promise<{
-                    process_id: string;
-                }>;
-                /**
-                 * Rolls back a database migration.
-                 * @param {Object} params - The migration parameters.
-                 * @param {string} params.migration - The migration name.
-                 * @param {string} params.env - The environment.
-                 * @param {string} params.product - The product name.
-                 * @returns {Promise<any>} The result of the rollback.
-                 */
-                rollback: ({ migration, env, product }: {
-                    migration: string;
-                    env: string;
-                    product: string;
-                }) => Promise<{
-                    process_id: string;
-                }>;
-            };
+            create: (appTag: string, data: IAppWebhookEvent) => Promise<void>;
+            /**
+             * Fetches all webhook events for a webhook by tag.
+             * @param {string} appTag - The app tag.
+             * @param {string} webhookTag - The webhook tag.
+             * @returns {IAppWebhookEvent[]} The list of webhook events.
+             */
+            list: (appTag: string, webhookTag: string) => Promise<IAppWebhookEvent[]>;
+            /**
+             * Fetches a webhook event by tag.
+             * @param {string} appTag - The app tag.
+             * @param {string} tag - The webhook event tag.
+             * @returns {IAppWebhookEvent|null} The fetched webhook event, or null if not found.
+             */
+            fetch: (appTag: string, tag: string) => Promise<IAppWebhookEvent>;
+            /**
+             * Updates a webhook event by tag.
+             * @param {string} appTag - The app tag.
+             * @param {string} tag - The webhook event tag.
+             * @param {Partial<IAppWebhookEvent>} data - The webhook event data to update.
+             * @returns {Promise<void>} Resolves when the webhook event is updated. Throws on error.
+             */
+            update: (appTag: string, tag: string, data: Partial<IAppWebhookEvent>) => Promise<void>;
         };
     };
-    /**
-     * Database operations for querying, inserting, updating, and managing databases.
-     * Provides unified interface for SQL and NoSQL databases.
-     */
-    get database(): DatabaseService;
-    /**
-     * Graph database operations for Neo4j, AWS Neptune, ArangoDB, and Memgraph.
-     * Provides unified interface for graph database CRUD, traversals, and path finding.
-     */
-    get graph(): GraphService;
     /**
      * Logs-related operations for initializing and fetching logs.
      */
     logs: {
         /**
          * Initializes the logger service for a product or app.
-         * @param {string} [productTag] - The product tag (optional).
-         * @param {string} [appTag] - The app tag (optional).
+         * @param {string} [product] - The product tag (optional).
+         * @param {string} [app] - The app tag (optional).
          * @throws {Error} If neither productTag nor appTag is provided.
          * @returns {Promise<void>} Resolves when logger is initialized.
          */
-        init: (productTag?: string, appTag?: string) => Promise<void>;
+        init: (product?: string, app?: string) => Promise<void>;
         add: () => Promise<void>;
         /**
          * Fetches logs based on provided query parameters.
@@ -1346,87 +2386,78 @@ export default class Ductape implements IDuctape {
         fetch: (params: LogQueryParams) => Promise<any>;
         publish: () => Promise<void>;
     };
-    /**
-     * Workspace secrets operations for securely storing encrypted key-value pairs.
-     * Values are encrypted client-side using the workspace's private key.
-     */
-    secrets: {
-        /**
-         * Cached workspace private key for encryption/decryption.
-         * Fetched once and reused for the session.
-         */
-        _privateKey: string | null;
-        /**
-         * Fetches and caches the workspace private key.
-         * @returns {Promise<string>} The decrypted workspace private key.
-         */
-        fetchPrivateKey: () => Promise<string>;
-        /**
-         * Creates a new workspace secret.
-         * The value is encrypted client-side before being sent to the server.
-         * @param {Object} data - The secret data.
-         * @param {string} data.key - The unique key for the secret (alphanumeric + underscores).
-         * @param {string} data.value - The plaintext value to encrypt and store.
-         * @param {string} [data.description] - Optional description.
-         * @param {string} [data.token_type] - Optional token type ('api' or 'access').
-         * @param {string[]} [data.scope] - Optional array of scopes.
-         * @param {string[]} [data.envs] - Optional array of environment slugs.
-         * @param {number|null} [data.expires_at] - Optional expiry timestamp in seconds (Unix epoch).
-         * @returns {Promise<IWorkspaceSecret>} The created secret (without encrypted value).
-         */
-        create: (data: {
-            key: string;
-            value: string;
-            description?: string;
-            token_type?: string;
-            scope?: string[];
-            envs?: string[];
-            expires_at?: number | null;
-        }) => Promise<IWorkspaceSecret>;
-        /**
-         * Lists all workspace secrets.
-         * Returns metadata only, not the encrypted values.
-         * @returns {Promise<IWorkspaceSecret[]>} List of secrets.
-         */
-        fetchAll: () => Promise<IWorkspaceSecret[]>;
-        /**
-         * Fetches a single secret by key and decrypts its value.
-         * @param {string} key - The secret key.
-         * @returns {Promise<IWorkspaceSecret & { value: string }>} The secret with decrypted value.
-         */
-        fetch: (key: string) => Promise<IWorkspaceSecret & {
-            value: string;
-        }>;
-        /**
-         * Updates a workspace secret.
-         * If a new value is provided, it will be encrypted client-side.
-         * @param {string} key - The secret key to update.
-         * @param {Object} data - The update data.
-         * @param {string} [data.value] - New plaintext value to encrypt.
-         * @param {string} [data.description] - New description.
-         * @param {number|null} [data.expires_at] - New expiry timestamp.
-         * @returns {Promise<IWorkspaceSecret>} The updated secret.
-         */
-        update: (key: string, data: {
-            value?: string;
-            description?: string;
-            expires_at?: number | null;
-        }) => Promise<IWorkspaceSecret>;
-        /**
-         * Deletes a workspace secret.
-         * @param {string} key - The secret key to delete.
-         * @returns {Promise<boolean>} True if deleted successfully.
-         */
-        delete: (key: string) => Promise<boolean>;
-    };
     private initUserAuth;
     private createNewLogger;
-    private createNewDatabaseService;
-    private createNewGraphService;
     private createNewProductBuilder;
     private createNewProcessor;
     private createNewImporter;
     private createNewAppBuilder;
+    /**
+     * Create a new DatabaseService instance with authenticated config
+     * @returns DatabaseService instance
+     */
+    private createNewDatabaseService;
+    /**
+     * Create a new GraphService instance with authenticated config
+     * @returns GraphService instance
+     */
+    private createNewGraphService;
+    /**
+     * Create a new WorkflowService instance with authenticated config
+     * @returns WorkflowService instance
+     */
+    private createNewWorkflowService;
+    /**
+     * Create a new AgentsService instance with authenticated config
+     * @returns AgentsService instance
+     */
+    private createNewAgentsService;
+    /**
+     * Create a new ModelService instance with authenticated config
+     * @returns ModelService instance
+     */
+    private createNewModelService;
+    /**
+     * Create a new VectorDatabaseService instance with authenticated config
+     * @returns VectorDatabaseService instance
+     */
+    private createNewVectorService;
+    /**
+     * Create a new CacheService instance with authenticated config
+     * @returns CacheService instance
+     */
+    private createNewCacheService;
+    /**
+     * Create a new JobsService instance with authenticated config
+     * @returns JobsService instance
+     */
+    private createNewJobsService;
+    private createNewSecretsService;
+    /**
+     * Create a new SessionsService instance with authenticated config
+     * @returns SessionsService instance
+     */
+    private createNewSessionsService;
+    /**
+     * Create a new StorageService instance with authenticated config
+     * @returns StorageService instance
+     */
+    private createNewStorageService;
+    /**
+     * Create a new BrokersService instance with authenticated config
+     * @returns BrokersService instance
+     */
+    private createNewBrokersService;
+    /**
+     * Create a new QuotaService instance with authenticated config
+     * @returns QuotaService instance
+     */
+    private createNewQuotaService;
+    /**
+     * Create a new FallbackService instance with authenticated config
+     * @returns FallbackService instance
+     */
+    private createNewFallbackService;
     private fetchSession;
     private validateWorkspace;
     private createNewAppBuilderSession;
@@ -1436,6 +2467,5 @@ export default class Ductape implements IDuctape {
     /**
      * Fetches the latest healthcheck status for a product/env from Redis cache via processor service.
      */
-    getHealthcheckStatus(productTag: string, envSlug: string): Promise<any>;
+    getHealthcheckStatus(product: string, envSlug: string): Promise<any>;
 }
-export type { IWorkspaceSecret } from './api/services/workspaceSecretsApi.service';