@ductape/sdk 0.1.8 → 0.1.10

package/dist/index.d.ts

@@ -0,0 +1,4233 @@
+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, IActionDispatchInput, INotificationDispatchInput, IStorageDispatchInput, IPublishDispatchInput, IDispatchResult, IDispatchSchedule } from './types';
+import { IDuctapeInit } from './types/index.types';
+import { PublicStates } from './types/enums';
+import { DatabaseService, IActionCreateOptions, IActionUpdateOptions, ISimpleSchemaDefinition, ISimpleCreateOptions, ISimpleDropOptions, ISimpleFieldDefinition, SimpleFieldType, ISimpleIndexOptions, ISchemaOperationResult, IIndexFieldDefinition, ITableSchema, ITableInfo, IIndexInfo } from './database';
+import { IConstraintDefinition as IMigrationConstraintDefinition } from './database/types/migration.interface';
+import { IDBActionDispatchInput } from './types/processor.types';
+import { IGraphConfig } from './graph';
+import { WorkflowService } from './workflows';
+import { IHealthcheckDefineOptions, IDefinedHealthcheck, IQuotaDefineOptions, IDefinedQuota, IFallbackDefineOptions, IDefinedFallback } from './resilience';
+import { AgentsService } from './agents';
+import { ModelService } from './models';
+import { ICreateVectorDbOptions, 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';
+import { IWarehouseQuery, IDataSource } from './warehouse';
+import { CloudService, ICreateCloudConnectionInput, ICloudConnectionSetup, ICloudConnection, ICompleteCloudConnectionInput, IValidateCloudConnectionResult, IListCloudResourcesInput, IListCloudResourcesResult, IImportCloudResourceInput, IImportCloudResourceResult, IProvisionCloudResourceInput, IProvisionCloudResourceResult, ICloudRuntimeCredentialsInput, ICloudRuntimeCredentials } from './cloud';
+/**
+ * @typedef {Object} IProduct
+ * @property {string} tag - Unique product tag.
+ * @property {string} name - Product name.
+ * @property {string} [description] - Optional product description.
+ * @property {Array<IProductApp>} [apps] - Associated apps.
+ * @property {Array<IProductSession>} [sessions] - Product sessions.
+ * @property {Array<IProductFeature>} [features] - Product features.
+ * @property {Array<IProductQuota>} [quotas] - Product quotas.
+ * @property {Array<IProductFallback>} [fallbacks] - Product fallbacks.
+ * @property {Array<IProductEnv>} [environments] - Product environments.
+ * @property {Array<IProductStorage>} [storages] - Product storages.
+ * @property {Array<IProductMessageBroker>} [messageBrokers] - Product message brokers.
+ * @property {Array<IProductNotification>} [notifications] - Product notifications.
+ * @property {Array<IProductDatabase>} [databases] - Product databases.
+ * @property {Array<IProductJobs>} [jobs] - Product jobs.
+ * @property {Array<IProductCache>} [caches] - Product caches.
+ * @property {Array<IProductFunction>} [functions] - Product functions.
+ * @see ts/src/types/productsBuilder.types.ts
+ */
+/**
+ * @typedef {Object} IApp
+ * @property {string} tag - Unique app tag.
+ * @property {string} name - App name.
+ * @property {string} [description] - Optional app description.
+ * @property {Array<IAppVariables>} [variables] - App variables.
+ * @property {Array<IAppConstants>} [constants] - App constants.
+ * @property {Array<IAppWebhook>} [webhooks] - App webhooks.
+ * @property {Array<IAppEnv>} [environments] - App environments.
+ * @property {Array<IAppAction>} [actions] - App actions.
+ * @property {Array<IAppAuth>} [auths] - App authentication configs.
+ * @see ts/src/types/appBuilder.types.ts
+ */
+/**
+ * @typedef {Object} IProductSession
+ * @property {string} tag - Session tag.
+ * @property {string} token - Session token.
+ * @property {string} [user_id] - Associated user ID.
+ * @property {string} [product_tag] - Associated product tag.
+ * @property {Record<string, unknown>} [data] - Session data.
+ * @see ts/src/types/productsBuilder.types.ts
+ */
+/**
+ * @typedef {Object} IProductApp
+ * @property {string} tag - App tag.
+ * @property {string} name - App name.
+ * @property {string} [description] - App description.
+ * @property {Array<IAppEnv>} [environments] - App environments.
+ * @see ts/src/types/productsBuilder.types.ts
+ */
+/**
+ * @typedef {Object} IProductFeature
+ * @property {string} tag - Feature tag.
+ * @property {string} name - Feature name.
+ * @property {string} [description] - Feature description.
+ * @property {Array<any>} [actions] - Feature actions.
+ * @see ts/src/types/productsBuilder.types.ts
+ */
+/**
+ * @typedef {Object} IProductQuota
+ * @property {string} tag - Quota tag.
+ * @property {string} name - Quota name.
+ * @property {number} [limit] - Quota limit.
+ * @property {string} [period] - Quota period.
+ * @see ts/src/types/productsBuilder.types.ts
+ */
+/**
+ * @typedef {Object} IProductFallback
+ * @property {string} tag - Fallback tag.
+ * @property {string} name - Fallback name.
+ * @property {string} [description] - Fallback description.
+ * @see ts/src/types/productsBuilder.types.ts
+ */
+/**
+ * @typedef {Object} IProductEnv
+ * @property {string} slug - Environment slug.
+ * @property {string} [name] - Environment name.
+ * @property {string} [description] - Environment description.
+ * @see ts/src/types/productsBuilder.types.ts
+ */
+/**
+ * @typedef {Object} IProductStorage
+ * @property {string} tag - Storage tag.
+ * @property {string} name - Storage name.
+ * @property {string} [description] - Storage description.
+ * @see ts/src/types/productsBuilder.types.ts
+ */
+/**
+ * @typedef {Object} IProductMessageBroker
+ * @property {string} tag - Message broker tag.
+ * @property {string} name - Message broker name.
+ * @property {string} [description] - Message broker description.
+ * @property {Array<IProductMessageBrokerTopic>} [topics] - Message broker topics.
+ * @see ts/src/types/productsBuilder.types.ts
+ */
+/**
+ * @typedef {Object} IProductNotification
+ * @property {string} tag - Notification tag.
+ * @property {string} name - Notification name.
+ * @property {string} [description] - Notification description.
+ * @property {Array<IProductNotificationTemplate>} [messages] - Notification messages.
+ * @see ts/src/types/productsBuilder.types.ts
+ */
+/**
+ * @typedef {Object} IProductDatabase
+ * @property {string} tag - Database tag.
+ * @property {string} name - Database name.
+ * @property {string} [description] - Database description.
+ * @property {Array<IProductDatabaseAction>} [actions] - Database actions.
+ * @property {Array<IProductDatabaseMigration>} [migrations] - Database migrations.
+ * @see ts/src/types/productsBuilder.types.ts
+ */
+/**
+ * @typedef {Object} IProductJobs
+ * @property {string} tag - Job tag.
+ * @property {string} name - Job name.
+ * @property {string} [description] - Job description.
+ * @see ts/src/types/productsBuilder.types.ts
+ */
+/**
+ * @typedef {Object} IProductCache
+ * @property {string} tag - Cache tag.
+ * @property {string} name - Cache name.
+ * @property {string} [description] - Cache description.
+ * @see ts/src/types/productsBuilder.types.ts
+ */
+/**
+ * @typedef {Object} IProductFunction
+ * @property {string} tag - Function tag.
+ * @property {string} name - Function name.
+ * @property {string} [description] - Function description.
+ * @see ts/src/types/productsBuilder.types.ts
+ */
+/**
+ * @typedef {Object} IAppVariables
+ * @property {string} tag - Variable tag.
+ * @property {string} name - Variable name.
+ * @property {string} [description] - Variable description.
+ * @see ts/src/types/appBuilder.types.ts
+ */
+/**
+ * @typedef {Object} IAppConstants
+ * @property {string} tag - Constant tag.
+ * @property {string} name - Constant name.
+ * @property {string} [description] - Constant description.
+ * @see ts/src/types/appBuilder.types.ts
+ */
+/**
+ * @typedef {Object} IAppWebhook
+ * @property {string} tag - Webhook tag.
+ * @property {string} url - Webhook URL.
+ * @property {string} [description] - Webhook description.
+ * @property {Array<IAppWebhookEvent>} [events] - Webhook events.
+ * @see ts/src/types/appBuilder.types.ts
+ */
+/**
+ * @typedef {Object} IAppWebhookEvent
+ * @property {string} tag - Webhook event tag.
+ * @property {string} name - Webhook event name.
+ * @property {string} [description] - Webhook event description.
+ * @see ts/src/types/appBuilder.types.ts
+ */
+/**
+ * @typedef {Object} IAppEnv
+ * @property {string} slug - Environment slug.
+ * @property {string} [name] - Environment name.
+ * @property {string} [description] - Environment description.
+ * @see ts/src/types/appBuilder.types.ts
+ */
+/**
+ * @typedef {Object} IAppAction
+ * @property {string} tag - Action tag.
+ * @property {string} name - Action name.
+ * @property {string} [description] - Action description.
+ * @see ts/src/types/appBuilder.types.ts
+ */
+/**
+ * @typedef {Object} IAppAuth
+ * @property {string} tag - Auth tag.
+ * @property {string} name - Auth name.
+ * @property {string} [description] - Auth description.
+ * @see ts/src/types/appBuilder.types.ts
+ */
+/**
+ * @typedef {Object} IProductAppHealth
+ * @property {string} name - Health check name.
+ * @property {string} description - Health check description.
+ * @property {string} tag - Health check tag.
+ * @property {string} app - App access tag.
+ * @property {string} action - Action to execute for health check.
+ * @property {number} checkIntervals - Interval between health checks in milliseconds.
+ * @property {number} retries - Number of retry attempts.
+ * @property {Array<CheckEnvStatus>} envs - Environment-specific health check configurations.
+ * @see ts/src/types/productsBuilder.types.ts
+ */
+/**
+ * @typedef {Object} CheckEnvStatus
+ * @property {string} slug - Environment slug.
+ * @property {string} [status] - Current health status.
+ * @property {string} [lastAvailable] - Last available timestamp.
+ * @property {string} [lastChecked] - Last check timestamp.
+ * @property {string} [lastLatency] - Last response latency.
+ * @property {string} [averageLatency] - Average response latency.
+ * @property {any} input - Health check input data.
+ * @see ts/src/types/productsBuilder.types.ts
+ */
+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, cacheLogger, CacheLogger } 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, 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 { 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 { CloudService, CloudError } from './cloud';
+export type { CloudProvider, CloudAuthMode, CloudConnectionStatus, CloudConnectionScope, ICloudConnection, ICreateCloudConnectionInput, ICloudConnectionSetup, ICompleteCloudConnectionInput, IValidateCloudConnectionResult, CloudResourceService, ICloudResource, IListCloudResourcesInput, IListCloudResourcesResult, CloudComponentType, IImportCloudResourceInput, IProvisionCloudResourceInput, ICloudComponentDraft, IImportCloudResourceResult, IProvisionCloudResourceResult, ICloudRuntimeCredentialsInput, ICloudRuntimeCredentials, ComponentCloudAuthMode, ICloudLinkedComponentFields, } from './cloud';
+export interface IDuctape {
+}
+export default class Ductape implements IDuctape {
+    private user_id;
+    private workspace_id;
+    private accessKey;
+    private public_key;
+    private session;
+    private token;
+    private apps;
+    private products;
+    private userApi;
+    private appApi;
+    private productsApi;
+    private workspaceApi;
+    private productBuilders;
+    private appBuilders;
+    private _databaseService;
+    private _graphService;
+    private _workflowService;
+    private _agentsService;
+    private _modelService;
+    private _vectorService;
+    private _warehouseService;
+    private _cacheService;
+    private _jobsService;
+    private _secretsService;
+    private _cloudService;
+    private _privateKey;
+    private _quotaService;
+    private _fallbackService;
+    private _healthcheckService;
+    private _brokersService;
+    private loggerService;
+    private importService;
+    private environment;
+    private redis_url;
+    /** Inherited by connect/query payloads when product/env omitted */
+    private defaultProduct?;
+    private defaultEnv?;
+    private redisClient?;
+    private jobsQueue;
+    private healthCheckQueue;
+    private healthCheckUpdaterQueue;
+    jobsWorker: any;
+    healthCheckWorker: any;
+    healthCheckUpdaterWorker: any;
+    private loadRedis;
+    /**
+     * Connect to Redis for caching purposes (lazy initialization)
+     * This is separate from monitor() which sets up job queues
+     */
+    private connectCacheRedis;
+    constructor({ accessKey, redis_url, product, env, local }: IDuctapeInit);
+    private loadBullMQ;
+    /**
+     * Connects to Redis and initializes job and health check queues and workers.
+     * @throws {Error} If called in a browser environment or if Redis URL is missing.
+     * @returns {Promise<void>} Resolves when Redis and queues are initialized.
+     */
+    monitor(): Promise<void>;
+    /**
+     * Schedules all healthcheck jobs for all products and environments.
+     */
+    private scheduleAllHealthcheckJobs;
+    /**
+     * Schedules a single healthcheck job with the given interval (ms).
+     * If interval is not provided, defaults to 60s.
+     */
+    private scheduleHealthcheckJob;
+    setUserId(user_id: string): void;
+    setWorkspaceId(workspace_id: string): void;
+    /**
+     * Sets the authentication token for API requests.
+     * @param {string} token - The authentication token.
+     */
+    setToken(token: string): void;
+    /**
+     * Sets the public key for API requests.
+     * @param {string} public_key - The public key.
+     */
+    setPublicKey(public_key: string): void;
+    private runtimeDefaultsForServices;
+    /** Merge constructor product/env into call options (sessions, storage, cache, notifications, resilience, etc.). */
+    private mergeRuntime;
+    private getProductBuilder;
+    private getAppBuilder;
+    private initProductBuilder;
+    private initAppBuilder;
+    /**
+     * Product-related operations for managing products.
+     */
+    product: {
+        /**
+         * Creates a new product.
+         * @param {IProduct} data - The product data.
+         * @returns {Promise<void>} Resolves when the product is created. Throws on error.
+         */
+        create: (data: IProduct) => Promise<void>;
+        /**
+         * Fetches a product by tag.
+         * @param {string} tag - The product tag.
+         * @returns {Promise<IProduct|null>} The fetched product, or null if not found.
+         */
+        fetch: (tag: string) => Promise<IProduct>;
+        /**
+         * Updates a product by tag.
+         * @param {string} tag - The product tag.
+         * @param {Partial<IProduct>} data - The product data to update.
+         * @returns {Promise<void>} Resolves when the product is updated. Throws on error.
+         */
+        update: (tag: string, data: Partial<IProduct>) => Promise<void>;
+        /**
+         * 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: (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: {
+            /**
+             * 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.
+             */
+            create: (product: string, data: IProductEnv) => Promise<void>;
+            /**
+             * Fetches all environments for a product.
+             * @param {string} product - The product tag.
+             * @returns {IAppEnv[]} The list of environments.
+             */
+            list: (product: string) => Promise<IProductEnv[]>;
+            /**
+             * 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: (product: string, slug: string) => Promise<IProductEnv>;
+            /**
+             * 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.
+             */
+            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: (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: (product: string, app: IProductApp) => Promise<void>;
+            /**
+             * Fetches all apps for a product.
+             * @param {string} product - The product tag.
+             * @returns {IProductApp[]} The list of apps.
+             */
+            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: (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: (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.
+                 */
+                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.
+                 * @returns {Promise<string>} The generated webhook link.
+                 */
+                generateLink: (data: IGenerateWebhookLink) => Promise<string>;
+            };
+        };
+    };
+    /**
+     * 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: (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>;
+        /**
+         * Fetches paginated session users.
+         * @param data - The fetch users payload.
+         * @returns The paginated list of session users.
+         */
+        fetchUsers: (data: {
+            product: string;
+            session: string;
+            env?: string;
+            page?: number;
+            limit?: number;
+        }) => Promise<import("./sessions").IFetchSessionUsersResult>;
+        /**
+         * Fetches detailed information for a specific session user.
+         * @param data - The fetch user details payload.
+         * @returns The user details with their sessions.
+         */
+        fetchUserDetails: (data: {
+            product: string;
+            session: string;
+            identifier: string;
+            env?: string;
+        }) => Promise<import("./sessions").ISessionUserDetails>;
+        /**
+         * Fetches session dashboard metrics.
+         * @param data - The fetch dashboard payload.
+         * @returns The dashboard metrics for the session.
+         */
+        fetchDashboard: (data: {
+            product: string;
+            session: string;
+            env?: string;
+        }) => Promise<import("./sessions").ISessionDashboardMetrics>;
+    };
+    /**
+     * Quota-related operations for managing product quotas with weighted distribution.
+     */
+    quota: {
+        /**
+         * Defines a quota using code-first API.
+         * @param {IQuotaDefineOptions} options - The quota definition options.
+         * @param {string} [options.product] - The product tag (if provided, registers immediately).
+         * @param {string} options.tag - The quota tag.
+         * @param {string} [options.name] - The quota name.
+         * @param {string} [options.description] - The quota description.
+         * @param {Object} [options.input] - The input schema definition.
+         * @param {Function} options.handler - The handler function to configure the quota.
+         * @returns {Promise<IDefinedQuota>} The defined quota.
+         */
+        define: (options: IQuotaDefineOptions) => Promise<IDefinedQuota>;
+        /**
+         * Creates a quota for a product.
+         * @param {string} product - The product tag.
+         * @param {any} data - The quota data (schema or defined quota).
+         * @returns {Promise<any>} The created quota schema.
+         */
+        create: (product: string, data: any) => Promise<IProductQuota>;
+        /**
+         * Fetches a quota by tag.
+         * @param {string} product - The product tag.
+         * @param {string} tag - The quota tag.
+         * @returns {Promise<any>} The fetched quota.
+         */
+        fetch: (product: string, tag: string) => Promise<IProductQuota>;
+        /**
+         * Fetches all quotas for a product.
+         * @param {string} product - The product tag.
+         * @returns {Promise<any[]>} 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 {any} data - The quota data to update.
+         * @returns {Promise<any>} The updated quota schema.
+         */
+        update: (product: string, tag: string, data: any) => 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.
+         */
+        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<import("./resilience/quota.service").IQuotaRunResult<unknown>>;
+        /**
+         * Dispatches a quota for deferred execution.
+         * @param {Object} data - The quota dispatch 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.
+         * @param {IDispatchSchedule} [data.schedule] - Optional schedule for deferred execution.
+         * @returns {Promise<{ jobId: string }>} The dispatch result with job ID.
+         */
+        dispatch: (data: {
+            product: string;
+            env: string;
+            tag: string;
+            input: Record<string, unknown>;
+            schedule?: IDispatchSchedule;
+        }) => Promise<{
+            jobId: string;
+        }>;
+    };
+    /**
+     * Fallback-related operations for managing product fallbacks with sequential failover.
+     */
+    fallback: {
+        /**
+         * Defines a fallback using code-first API.
+         * @param {IFallbackDefineOptions} options - The fallback definition options.
+         * @param {string} [options.product] - The product tag (if provided, registers immediately).
+         * @param {string} options.tag - The fallback tag.
+         * @param {string} [options.name] - The fallback name.
+         * @param {string} [options.description] - The fallback description.
+         * @param {Object} [options.input] - The input schema definition.
+         * @param {Function} options.handler - The handler function to configure the fallback.
+         * @returns {Promise<IDefinedFallback>} The defined fallback.
+         */
+        define: (options: IFallbackDefineOptions) => Promise<IDefinedFallback>;
+        /**
+         * Creates a fallback for a product.
+         * @param {string} product - The product tag.
+         * @param {any} data - The fallback data (schema or defined fallback).
+         * @returns {Promise<any>} The created fallback schema.
+         */
+        create: (product: string, data: any) => Promise<IProductFallback>;
+        /**
+         * Fetches a fallback by tag.
+         * @param {string} product - The product tag.
+         * @param {string} tag - The fallback tag.
+         * @returns {Promise<any>} The fetched fallback.
+         */
+        fetch: (product: string, tag: string) => Promise<IProductFallback>;
+        /**
+         * Fetches all fallbacks for a product.
+         * @param {string} product - The product tag.
+         * @returns {Promise<any[]>} 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 {any} data - The fallback data to update.
+         * @returns {Promise<any>} The updated fallback schema.
+         */
+        update: (product: string, tag: string, data: any) => 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.
+         */
+        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<import("./resilience/fallback.service").IFallbackRunResult<unknown>>;
+        /**
+         * Dispatches a fallback for deferred execution.
+         * @param {Object} data - The fallback dispatch 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.
+         * @param {IDispatchSchedule} [data.schedule] - Optional schedule for deferred execution.
+         * @returns {Promise<{ jobId: string }>} The dispatch result with job ID.
+         */
+        dispatch: (data: {
+            product: string;
+            env: string;
+            tag: string;
+            input: Record<string, unknown>;
+            schedule?: IDispatchSchedule;
+        }) => Promise<{
+            jobId: string;
+        }>;
+    };
+    /**
+     * Healthcheck-related operations for managing product healthchecks.
+     */
+    health: {
+        /**
+         * Defines a healthcheck using code-first API.
+         * @param {IHealthcheckDefineOptions} options - The healthcheck definition options.
+         * @param {string} [options.product] - The product tag (if provided, registers immediately).
+         * @param {string} options.tag - The healthcheck tag.
+         * @param {string} [options.name] - The healthcheck name.
+         * @param {string} [options.description] - The healthcheck description.
+         * @param {Function} options.handler - The handler function to configure the healthcheck.
+         * @returns {Promise<IDefinedHealthcheck>} The defined healthcheck.
+         */
+        define: (options: IHealthcheckDefineOptions) => Promise<IDefinedHealthcheck>;
+        /**
+         * Creates a healthcheck for a product.
+         * @param {string} product - The product tag.
+         * @param {Object} data - The healthcheck data (schema or defined healthcheck).
+         * @returns {Promise<IHealthcheckSchema>} The created healthcheck schema.
+         */
+        create: (product: string, data: any) => Promise<import("./resilience").IHealthcheckSchema>;
+        /**
+         * Fetches a healthcheck by tag.
+         * @param {string} product - The product tag.
+         * @param {string} tag - The healthcheck tag.
+         * @returns {Promise<IHealthcheckSchema>} The fetched healthcheck.
+         */
+        fetch: (product: string, tag: string) => Promise<import("./resilience").IHealthcheckSchema>;
+        /**
+         * Fetches all healthchecks for a product.
+         * @param {string} product - The product tag.
+         * @returns {Promise<IHealthcheckSchema[]>} The list of healthchecks.
+         */
+        list: (product: string) => Promise<import("./resilience").IHealthcheckSchema[]>;
+        /**
+         * Updates a healthcheck by tag.
+         * @param {string} product - The product tag.
+         * @param {string} tag - The healthcheck tag.
+         * @param {Object} data - The healthcheck data to update.
+         * @returns {Promise<IHealthcheckSchema>} The updated healthcheck schema.
+         */
+        update: (product: string, tag: string, data: any) => Promise<import("./resilience").IHealthcheckSchema>;
+        /**
+         * Deletes a healthcheck by tag.
+         * @param {string} product - The product tag.
+         * @param {string} tag - The healthcheck tag.
+         * @returns {Promise<void>} Resolves when the healthcheck is deleted.
+         */
+        delete: (product: string, tag: string) => Promise<void>;
+        /**
+         * Gets the current status of a healthcheck.
+         * @param {Object} options - The status check options.
+         * @param {string} options.product - The product tag.
+         * @param {string} options.env - The environment slug.
+         * @param {string} options.tag - The healthcheck tag.
+         * @returns {Promise<IHealthcheckStatus>} The healthcheck status.
+         */
+        status: (options: {
+            product: string;
+            env: string;
+            tag: string;
+        }) => Promise<import("./resilience").IHealthcheckStatus>;
+        /**
+         * Manually triggers a healthcheck run.
+         * @param {Object} options - The run options.
+         * @param {string} options.product - The product tag.
+         * @param {string} options.env - The environment slug.
+         * @param {string} options.tag - The healthcheck tag.
+         * @returns {Promise<IHealthcheckRunResult>} The result of the healthcheck run.
+         */
+        run: (options: {
+            product: string;
+            env: string;
+            tag: string;
+        }) => Promise<import("./resilience").IHealthcheckRunResult>;
+        /**
+         * Checks the health of a service (alias for status).
+         * @param {Object} options - The check options.
+         * @param {string} options.product - The product tag.
+         * @param {string} options.env - The environment slug.
+         * @param {string} options.tag - The healthcheck tag.
+         * @returns {Promise<IHealthcheckStatus>} The healthcheck status.
+         */
+        check: (options: {
+            product: string;
+            env: string;
+            tag: string;
+        }) => Promise<import("./resilience").IHealthcheckStatus>;
+    };
+    /**
+     * 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: (data: IProductStorage & {
+            product: string;
+        }) => Promise<void>;
+        /**
+         * Creates a storage for a product (alternative method).
+          const builder = await this.getProductBuilder(product);
+          return builder.createStorage(data);
+        },
+        /**
+         * 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>;
+        /**
+         * Tests connection to a storage provider.
+         * Validates storage configuration and attempts to list objects (with limit 1)
+         * to verify connectivity and credentials.
+         * @param data - The test connection options.
+         * @returns The connection test result.
+         * @example
+         * const result = await ductape.storage.testConnection({
+         *   product: 'my-product',
+         *   env: 'production',
+         *   storage: 's3-bucket'
+         * });
+         * console.log(result.connected); // true or false
+         * console.log(result.latency); // connection latency in ms
+         */
+        testConnection: (data: {
+            product: string;
+            env: string;
+            storage: string;
+        }) => Promise<{
+            connected: boolean;
+            latency?: number;
+            error?: string;
+        }>;
+        /**
+         * Uploads a file to cloud storage (top-level convenience method).
+         * @param data - The upload options.
+         * @returns The upload result with file URL.
+         */
+        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 (top-level convenience method).
+         * @param data - The download options.
+         * @returns The download result with file data.
+         */
+        download: (data: {
+            product: string;
+            env: string;
+            storage: string;
+            fileName: string;
+        }) => Promise<import("./storage").IDownloadResult>;
+        /**
+         * Removes a file from cloud storage (top-level convenience method).
+         * @param data - The delete options.
+         * @returns The delete result.
+         */
+        remove: (data: {
+            product: string;
+            env: string;
+            storage: string;
+            fileName: string;
+        }) => Promise<import("./storage").IDeleteResult>;
+        /**
+         * Lists files in cloud storage with pagination (top-level convenience method).
+         * @param data - The list options.
+         * @returns The list result with files and pagination info.
+         */
+        listFiles: (data: {
+            product: string;
+            env: string;
+            cache?: string;
+            storage: string;
+            prefix?: string;
+            limit?: number;
+            continuationToken?: string;
+        }) => Promise<import("./storage").IListFilesResult>;
+        /**
+         * Generates a signed URL for temporary file access (top-level convenience method).
+         * @param data - The signed URL options.
+         * @returns The signed URL result.
+         */
+        getSignedUrl: (data: {
+            product: string;
+            env: string;
+            storage: string;
+            fileName: string;
+            expiresIn?: number;
+            action?: "read" | "write";
+        }) => Promise<import("./storage").ISignedUrlResult>;
+        /**
+         * Gets storage statistics (file counts and sizes by type).
+         * Efficiently counts all files without downloading content.
+         * @param data - The stats options.
+         * @returns The stats result with total counts and breakdown by type.
+         * @example
+         * const stats = await ductape.storage.stats({
+         *   product: 'my-product',
+         *   env: 'production',
+         *   storage: 's3-bucket'
+         * });
+         * console.log(stats.totalFiles); // 1234
+         * console.log(stats.byType.image.count); // 567
+         */
+        stats: (data: {
+            product: string;
+            env: string;
+            storage: string;
+            prefix?: string;
+            session?: string;
+            cache?: string;
+        }) => Promise<import("./storage").IStorageStatsResult>;
+        files: {
+            /**
+             * Reads a file from local storage.
+             * @param {string} path - The file path.
+             * @returns {Promise<IFileReadResult>} The file read result.
+             */
+            read: (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<{
+                process_id: string;
+                output: 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.delete({
+             *   product: 'my-product',
+             *   env: 'production',
+             *   storage: 's3-bucket',
+             *   fileName: 'documents/report.pdf'
+             * });
+             */
+            delete: (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
+             * });
+             */
+            list: (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).
+     */
+    messaging: {
+        /**
+         * 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: (data: Partial<IProductMessageBroker> & {
+            product: string;
+        }) => 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: {
+            /**
+             * 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.
+             */
+            create: (product: string, data: IProductMessageBrokerTopic) => Promise<void>;
+            /**
+             * 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.
+             */
+            list: (product: string, messageBrokerTag: string) => Promise<IProductMessageBrokerTopic[]>;
+            /**
+             * 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.
+             */
+            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>;
+        };
+        /**
+         * 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' }
+         * });
+         * @example
+         * // With session token for user-context publishing
+         * await ductape.events.produce({
+         *   product: 'my-product',
+         *   env: 'production',
+         *   event: 'broker-tag:topic-tag',
+         *   message: { orderId: '123', status: 'pending' },
+         *   session: 'session-token-from-sessions.start()'
+         * });
+         */
+        produce: (data: {
+            product: string;
+            env: string;
+            event: string;
+            message: Record<string, unknown>;
+            session?: string;
+            cache?: string;
+        }) => Promise<import("./brokers").IPublishResult>;
+        /**
+         * consume to a message broker topic.
+         * @param data - The subscribe input.
+         * @returns The result of the subscribe operation.
+         * @example
+         * await ductape.events.consume({
+         *   product: 'my-product',
+         *   env: 'production',
+         *   event: 'broker-tag:topic-tag',
+         *   callback: async (message) => console.log(message)
+         * });
+         */
+        consume: (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>;
+        /**
+         * Messages namespace for broker message tracking and queries.
+         * All query methods decrypt message content before returning.
+         */
+        messages: {
+            /**
+             * Query broker messages with filtering and pagination.
+             * Messages are decrypted before returning.
+             */
+            query: (options: {
+                product: string;
+                env: string;
+                brokerTag: string;
+                topicTag?: string;
+                producerTag?: string;
+                consumerTag?: string;
+                status?: string;
+                startDate?: string;
+                endDate?: string;
+                page?: number;
+                limit?: number;
+            }) => Promise<{
+                messages: any[];
+                total: number;
+                page: number;
+                limit: number;
+                hasMore: boolean;
+            }>;
+            /**
+             * Get broker producers with pagination.
+             */
+            getProducers: (options: {
+                product: string;
+                env: string;
+                brokerTag: string;
+                topicTag?: string;
+                page?: number;
+                limit?: number;
+            }) => Promise<{
+                producers: any[];
+                total: number;
+                page: number;
+                limit: number;
+                hasMore: boolean;
+            }>;
+            /**
+             * Get broker consumers with pagination.
+             */
+            getConsumers: (options: {
+                product: string;
+                env: string;
+                brokerTag: string;
+                topicTag?: string;
+                page?: number;
+                limit?: number;
+            }) => Promise<{
+                consumers: any[];
+                total: number;
+                page: number;
+                limit: number;
+                hasMore: boolean;
+            }>;
+            /**
+             * Get broker dead letters with pagination.
+             * Messages are decrypted before returning.
+             */
+            getDeadLetters: (options: {
+                product: string;
+                env: string;
+                brokerTag: string;
+                topicTag?: string;
+                consumerTag?: string;
+                startDate?: string;
+                endDate?: string;
+                page?: number;
+                limit?: number;
+            }) => Promise<{
+                deadLetters: any[];
+                total: number;
+                page: number;
+                limit: number;
+                hasMore: boolean;
+            }>;
+            /**
+             * Get comprehensive broker message statistics.
+             */
+            getStats: (options: {
+                product: string;
+                env: string;
+                brokerTag: string;
+            }) => Promise<any>;
+            /**
+             * Get broker dashboard overview data.
+             * Recent messages are decrypted before returning.
+             */
+            getDashboard: (options: {
+                product: string;
+                env: string;
+                brokerTag: string;
+            }) => Promise<any>;
+        };
+    };
+    /**
+     * 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 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: (product: string, data: IProductNotificationTemplate) => Promise<void>;
+            /**
+             * 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.
+             */
+            list: (product: string, notificationTag: string) => Promise<IProductNotificationTemplate[]>;
+            /**
+             * 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: (product: string, tag: string) => Promise<IProductNotificationTemplate>;
+            /**
+             * 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: (product: string, tag: string, data: Partial<IProductNotificationTemplate>) => Promise<void>;
+        };
+        /**
+         * Send a notification via the email channel only.
+         * @param options - Email options (product, env, notification, input, session?, cache?).
+         * @returns {Promise<any>} The result of the notification processing.
+         * @example
+         * await ductape.notifications.email.send({
+         *   product: 'my-product',
+         *   env: 'production',
+         *   notification: 'emails:order-confirmation',
+         *   input: { recipients: ['user@example.com'], subject: { orderId: '123' }, template: { ... } }
+         * });
+         */
+        email: {
+            send: (options: import("./notifications").IEmailOptions) => Promise<{
+                process_id: string;
+                output: {
+                    sent: boolean;
+                };
+            }>;
+        };
+        /**
+         * Send a notification via the push channel only.
+         * @param options - Push options (product, env, notification, input, session?, cache?).
+         * @returns {Promise<any>} The result of the notification processing.
+         * @example
+         * await ductape.notifications.push.send({
+         *   product: 'my-product',
+         *   env: 'production',
+         *   notification: 'alerts:welcome-message',
+         *   input: { device_tokens: ['token1'], title: { name: 'John' }, body: { message: 'Welcome!' }, data: {} }
+         * });
+         */
+        push: {
+            send: (options: import("./notifications").IPushOptions) => Promise<{
+                process_id: string;
+                output: {
+                    sent: boolean;
+                };
+            }>;
+        };
+        /**
+         * Send a notification via the SMS channel only.
+         * @param options - SMS options (product, env, notification, input, session?, cache?).
+         * @returns {Promise<any>} The result of the notification processing.
+         * @example
+         * await ductape.notifications.sms.send({
+         *   product: 'my-product',
+         *   env: 'production',
+         *   notification: 'sms:verification',
+         *   input: { recipients: ['+1234567890'], body: { code: '123456' } }
+         * });
+         */
+        sms: {
+            send: (options: import("./notifications").ISmsOptions) => Promise<{
+                process_id: string;
+                output: {
+                    sent: boolean;
+                };
+            }>;
+        };
+        /**
+         * Send a notification via the callback (webhook) channel only.
+         * @param options - Callback options (product, env, notification, input, session?, cache?).
+         * @returns {Promise<any>} The result of the notification processing.
+         * @example
+         * await ductape.notifications.callback.send({
+         *   product: 'my-product',
+         *   env: 'production',
+         *   notification: 'webhooks:order-created',
+         *   input: { body: { orderId: '123' }, headers: { 'X-Custom': 'value' }, query: {}, params: {} }
+         * });
+         */
+        callback: {
+            send: (options: import("./notifications").ICallbackOptions) => Promise<{
+                process_id: string;
+                output: {
+                    sent: boolean;
+                };
+            }>;
+        };
+        /**
+         * 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;
+            output: {
+                sent: boolean;
+            };
+        }>;
+        /**
+         * 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>;
+        /**
+         * Fetches notification message logs (send history) with time filters. Secured via user auth.
+         * @param {Object} options - Query options.
+         * @param {string} [options.product_tag] - Product tag filter (e.g. ductape:rematch).
+         * @param {string} [options.env] - Environment slug filter (e.g. prd).
+         * @param {string} [options.notification_tag] - Notification event filter (e.g. rematch-notifications:order-placed).
+         * @param {string} [options.status] - Status filter: pending | sent | failed | reprocessing.
+         * @param {string} [options.type] - Type filter: email | push | sms | callback | slack | discord | notification.
+         * @param {string|Date} [options.start_date] - Start of time range (ISO string or Date).
+         * @param {string|Date} [options.end_date] - End of time range (ISO string or Date).
+         * @param {number} [options.page] - Page number (default 1).
+         * @param {number} [options.limit] - Page size (default 20).
+         * @returns {Promise<{ items: any[]; total: number; page: number; limit: number; hasMore: boolean }>}
+         * @example
+         * const { items, total, hasMore } = await ductape.notifications.getMessages({
+         *   product_tag: 'ductape:rematch',
+         *   env: 'prd',
+         *   start_date: new Date(Date.now() - 7 * 864e5).toISOString(),
+         *   end_date: new Date().toISOString(),
+         *   page: 1,
+         *   limit: 50,
+         * });
+         */
+        getMessages: (options: {
+            product_tag?: string;
+            product_id?: string;
+            env?: string;
+            notification_tag?: string;
+            status?: string;
+            type?: string;
+            process_id?: string;
+            start_date?: string | Date;
+            end_date?: string | Date;
+            page?: number;
+            limit?: number;
+        }) => Promise<{
+            items: any[];
+            total: number;
+            page: number;
+            limit: number;
+            hasMore: boolean;
+        }>;
+    };
+    /**
+     * 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
+         */
+        updateDatabase: (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
+         */
+        update: <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: {
+            /**
+             * 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: (name: string, definition: ISimpleSchemaDefinition, options?: ISimpleCreateOptions) => Promise<ISchemaOperationResult>;
+            /**
+             * Drop a collection/table
+             */
+            drop: (name: string, options?: ISimpleDropOptions) => Promise<ISchemaOperationResult>;
+            /**
+             * Add a field to a collection
+             */
+            addField: (collection: string, fieldName: string, definition: SimpleFieldType | ISimpleFieldDefinition) => Promise<ISchemaOperationResult>;
+            /**
+             * Drop a field from a collection
+             */
+            dropField: (collection: string, fieldName: string) => Promise<ISchemaOperationResult>;
+            /**
+             * Rename a field in a collection
+             */
+            renameField: (collection: string, oldName: string, newName: string) => Promise<ISchemaOperationResult>;
+            /**
+             * Modify a field's definition
+             */
+            modifyField: (collection: string, fieldName: string, changes: Partial<ISimpleFieldDefinition>) => Promise<ISchemaOperationResult>;
+            /**
+             * Create an index on a collection
+             */
+            createIndex: (collection: string, fields: string[] | IIndexFieldDefinition[], options?: ISimpleIndexOptions) => Promise<ISchemaOperationResult>;
+            /**
+             * Drop an index from a collection
+             */
+            dropIndex: (collection: string, indexName: string) => Promise<ISchemaOperationResult>;
+            /**
+             * Add a constraint (SQL databases only)
+             */
+            addConstraint: (collection: string, constraint: IMigrationConstraintDefinition) => Promise<ISchemaOperationResult>;
+            /**
+             * Drop a constraint (SQL databases only)
+             */
+            dropConstraint: (collection: string, constraintName: string) => Promise<ISchemaOperationResult>;
+            /**
+             * Rename a collection/table
+             */
+            rename: (oldName: string, newName: string) => Promise<ISchemaOperationResult>;
+            /**
+             * Check if a collection/table exists
+             */
+            exists: (name: string) => Promise<boolean>;
+            /**
+             * List all collections/tables
+             */
+            list: (schemaName?: string) => Promise<string[]>;
+            /**
+             * Get detailed schema information for a collection
+             */
+            describe: (name: string) => Promise<ITableSchema>;
+            /**
+             * List indexes on a collection
+             */
+            indexes: (collection: string) => Promise<IIndexInfo[]>;
+        };
+        /**
+         * 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>;
+            /**
+             * Run a migration
+             */
+            run: (migrations: Parameters<DatabaseService["runMigration"]>[0], options?: Parameters<DatabaseService["runMigration"]>[1]) => Promise<Map<string, import("./database").IMigrationResult>>;
+            /**
+             * Rollback migrations
+             */
+            rollback: (migrations: Parameters<DatabaseService["rollbackMigration"]>[0], count?: number) => Promise<Map<string, import("./database").IMigrationResult>>;
+            /**
+             * Get migration history
+             */
+            history: () => Promise<import("./database").IMigrationHistory[]>;
+            /**
+             * Get migration status
+             */
+            status: (migrations: Parameters<DatabaseService["getMigrationStatus"]>[0]) => Promise<import("./database").IMigrationStatusResult>;
+        };
+        /**
+         * 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>;
+        };
+        /**
+         * List all tables in the database
+         */
+        listTables: (connectionConfig?: Parameters<DatabaseService["listTables"]>[0]) => Promise<string[]>;
+        /**
+         * List all tables with basic information including row counts
+         */
+        listTablesWithInfo: (connectionConfig?: Parameters<DatabaseService["listTablesWithInfo"]>[0]) => Promise<ITableInfo[]>;
+        /**
+         * Create a new table
+         */
+        createTable: (connectionConfigOrTableDef: Parameters<DatabaseService["createTable"]>[0], tableDefOrOptions?: Parameters<DatabaseService["createTable"]>[1], options?: Parameters<DatabaseService["createTable"]>[2]) => Promise<void>;
+        /**
+         * Drop a table
+         */
+        dropTable: (connectionConfigOrTableName: Parameters<DatabaseService["dropTable"]>[0], tableName?: Parameters<DatabaseService["dropTable"]>[1]) => Promise<void>;
+        /**
+         * Alter a table
+         */
+        alterTable: (connectionConfigOrTableName: Parameters<DatabaseService["alterTable"]>[0], tableNameOrAlterations?: Parameters<DatabaseService["alterTable"]>[1], alterations?: Parameters<DatabaseService["alterTable"]>[2]) => Promise<void>;
+        /**
+         * List all indexes
+         */
+        listIndexes: (options: Parameters<DatabaseService["listIndexes"]>[0]) => Promise<IIndexInfo[]>;
+        /**
+         * Create an index
+         */
+        createIndex: (options: Parameters<DatabaseService["createIndex"]>[0]) => Promise<void>;
+        /**
+         * Drop an index
+         */
+        dropIndex: (options: Parameters<DatabaseService["dropIndex"]>[0]) => Promise<void>;
+        /**
+         * 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: {
+        /**
+         * Creates a graph configuration for a product.
+         * @param {any} graphConfig - The graph configuration.
+         * @param {string} [productTag] - The product tag.
+         * @returns {Promise<void>} Resolves when the graph is created.
+         */
+        create: (graphConfig: IGraphConfig & {
+            product: string;
+        }) => Promise<void>;
+        /**
+         * Fetches a graph configuration by tag.
+         * @param {string} [productTag] - The product tag.
+         * @param {string} graphTag - The graph tag.
+         * @returns {Promise<any>} The fetched graph configuration.
+         */
+        fetch: (productTag: string, graphTag: string) => Promise<IGraphConfig>;
+        /**
+         * Fetches all graph configurations for a product.
+         * @param {string} [productTag] - The product tag.
+         * @returns {Promise<any[]>} The list of graph configurations.
+         */
+        list: (productTag?: string) => Promise<IGraphConfig[]>;
+        /**
+         * Updates a graph configuration by tag.
+         * @param {string} [productTag] - The product tag.
+         * @param {string} graphTag - The graph tag.
+         * @param {any} updates - The updates to apply.
+         * @returns {Promise<void>} Resolves when the graph is updated.
+         */
+        update: (productTag: string, graphTag: string, updates: Partial<IGraphConfig>) => Promise<void>;
+        /**
+         * Deletes a graph configuration by tag.
+         * @param {string} graphTag - The graph tag.
+         * @param {string} [productTag] - The product tag.
+         * @returns {Promise<void>} Resolves when the graph is deleted.
+         */
+        delete: (graphTag: string, productTag?: string) => Promise<void>;
+        /**
+         * Connects to a graph database.
+         * @param {any} config - The connection configuration.
+         * @returns {Promise<any>} The connection result.
+         */
+        connect: (config: any) => Promise<import("./graph").IGraphConnectionResult>;
+        /**
+         * Disconnects from the current graph database.
+         * @returns {Promise<void>} Resolves when disconnected.
+         */
+        disconnect: () => Promise<void>;
+        /**
+         * Closes all graph database connections.
+         * @returns {Promise<void>} Resolves when all connections are closed.
+         */
+        closeAll: () => Promise<void>;
+        /**
+         * Tests a connection to a graph database without persisting.
+         * @param {any} config - The connection configuration.
+         * @returns {Promise<any>} The test connection result.
+         */
+        testConnection: (config: any) => Promise<import("./graph").IGraphTestConnectionResult>;
+        /**
+         * Creates a node in the graph.
+         * @param {any} options - The node creation options.
+         * @param {any} [transaction] - Optional transaction.
+         * @returns {Promise<any>} The created node result.
+         */
+        createNode: (options: any, transaction?: any) => Promise<import("./graph").ICreateNodeResult<any>>;
+        /**
+         * Finds nodes by criteria.
+         * @param {any} options - The find options.
+         * @param {any} [transaction] - Optional transaction.
+         * @returns {Promise<any>} The found nodes result.
+         */
+        findNodes: (options: any, transaction?: any) => Promise<import("./graph").IFindNodesResult<any>>;
+        /**
+         * Finds a node by ID.
+         * @param {string | number} id - The node ID.
+         * @param {any} [transaction] - Optional transaction.
+         * @returns {Promise<any>} The found node or null.
+         */
+        findNodeById: (id: string | number, transaction?: any) => Promise<import("./graph").INode<any>>;
+        /**
+         * Updates a node.
+         * @param {any} options - The update options.
+         * @param {any} [transaction] - Optional transaction.
+         * @returns {Promise<any>} The updated node result.
+         */
+        updateNode: (options: any, transaction?: any) => Promise<import("./graph").IUpdateNodeResult<any>>;
+        /**
+         * Deletes a node.
+         * @param {any} options - The delete options.
+         * @param {any} [transaction] - Optional transaction.
+         * @returns {Promise<any>} The delete result.
+         */
+        deleteNode: (options: any, transaction?: any) => Promise<import("./graph").IDeleteNodeResult>;
+        /**
+         * Merges a node (create or update).
+         * @param {any} options - The merge options.
+         * @param {any} [transaction] - Optional transaction.
+         * @returns {Promise<any>} The merge result.
+         */
+        mergeNode: (options: any, transaction?: any) => Promise<import("./graph").IMergeNodeResult<any>>;
+        /**
+         * Adds labels to an existing node.
+         * @param {any} options - The add labels options (id, labels).
+         * @param {any} [transaction] - Optional transaction.
+         * @returns {Promise<any>} The result with added labels.
+         */
+        addLabels: (options: any, transaction?: any) => Promise<import("./graph").IAddLabelsResult<any>>;
+        /**
+         * Removes labels from an existing node.
+         * @param {any} options - The remove labels options (id, labels).
+         * @param {any} [transaction] - Optional transaction.
+         * @returns {Promise<any>} The result with removed labels.
+         */
+        removeLabels: (options: any, transaction?: any) => Promise<import("./graph").IRemoveLabelsResult<any>>;
+        /**
+         * Sets labels on a node (replaces all existing labels).
+         * @param {any} options - The set labels options (id, labels).
+         * @param {any} [transaction] - Optional transaction.
+         * @returns {Promise<any>} The result with previous and new labels.
+         */
+        setLabels: (options: any, transaction?: any) => Promise<import("./graph").ISetLabelsResult<any>>;
+        /**
+         * Creates a relationship between nodes.
+         * @param {any} options - The relationship creation options.
+         * @param {any} [transaction] - Optional transaction.
+         * @returns {Promise<any>} The created relationship result.
+         */
+        createRelationship: (options: any, transaction?: any) => Promise<import("./graph").ICreateRelationshipResult<any>>;
+        /**
+         * Finds relationships by criteria.
+         * @param {any} options - The find options.
+         * @param {any} [transaction] - Optional transaction.
+         * @returns {Promise<any>} The found relationships result.
+         */
+        findRelationships: (options: any, transaction?: any) => Promise<import("./graph").IFindRelationshipsResult<any>>;
+        /**
+         * Finds a relationship by ID.
+         * @param {string | number} id - The relationship ID.
+         * @param {any} [transaction] - Optional transaction.
+         * @returns {Promise<any>} The found relationship or null.
+         */
+        findRelationshipById: (id: string | number, transaction?: any) => Promise<import("./graph").IRelationship<any>>;
+        /**
+         * Updates a relationship.
+         * @param {any} options - The update options.
+         * @param {any} [transaction] - Optional transaction.
+         * @returns {Promise<any>} The updated relationship result.
+         */
+        updateRelationship: (options: any, transaction?: any) => Promise<import("./graph").IUpdateRelationshipResult<any>>;
+        /**
+         * Deletes a relationship.
+         * @param {any} options - The delete options.
+         * @param {any} [transaction] - Optional transaction.
+         * @returns {Promise<any>} The delete result.
+         */
+        deleteRelationship: (options: any, transaction?: any) => Promise<import("./graph").IDeleteRelationshipResult>;
+        /**
+         * Merges a relationship (create or update).
+         * @param {any} options - The merge options.
+         * @param {any} [transaction] - Optional transaction.
+         * @returns {Promise<any>} The merge result.
+         */
+        mergeRelationship: (options: any, transaction?: any) => Promise<import("./graph").IMergeRelationshipResult<any>>;
+        /**
+         * Traverses the graph from a starting node.
+         * @param {any} options - The traversal options.
+         * @param {any} [transaction] - Optional transaction.
+         * @returns {Promise<any>} The traversal result.
+         */
+        traverse: (options: any, transaction?: any) => Promise<import("./graph").ITraverseResult<any, any>>;
+        /**
+         * Finds the shortest path between two nodes.
+         * @param {any} options - The shortest path options.
+         * @param {any} [transaction] - Optional transaction.
+         * @returns {Promise<any>} The shortest path result.
+         */
+        shortestPath: (options: any, transaction?: any) => Promise<import("./graph").IShortestPathResult<any, any>>;
+        /**
+         * Finds all paths between two nodes.
+         * @param {any} options - The all paths options.
+         * @param {any} [transaction] - Optional transaction.
+         * @returns {Promise<any>} The all paths result.
+         */
+        allPaths: (options: any, transaction?: any) => Promise<import("./graph").IAllPathsResult<any, any>>;
+        /**
+         * Gets the neighborhood of a node.
+         * @param {any} options - The neighborhood options.
+         * @param {any} [transaction] - Optional transaction.
+         * @returns {Promise<any>} The neighborhood result.
+         */
+        getNeighborhood: (options: any, transaction?: any) => Promise<import("./graph").INeighborhoodResult<any, any>>;
+        /**
+         * Finds connected components in the graph.
+         * @param {any} options - The connected components options.
+         * @param {any} [transaction] - Optional transaction.
+         * @returns {Promise<any>} The connected components result.
+         */
+        findConnectedComponents: (options: any, transaction?: any) => Promise<import("./graph").IConnectedComponentsResult<any>>;
+        /**
+         * Executes a raw Cypher query against the graph database.
+         * @param {string} query - The Cypher query string.
+         * @param {Record<string, any>} [params] - Query parameters.
+         * @param {any} [transaction] - Optional transaction.
+         * @returns {Promise<any>} The query result.
+         */
+        query: (query: string, params?: Record<string, any>, transaction?: any) => Promise<import("./graph").IRawQueryResult<any>>;
+        /**
+         * Gets graph statistics.
+         * @param {any} [transaction] - Optional transaction.
+         * @returns {Promise<any>} The graph statistics.
+         */
+        getStatistics: (transaction?: any) => Promise<import("./graph").IGraphStatistics>;
+        /**
+         * Counts nodes matching criteria.
+         * @param {string[]} [labels] - Node labels to filter by.
+         * @param {any} [where] - Where clause for filtering.
+         * @param {any} [transaction] - Optional transaction.
+         * @returns {Promise<any>} The count result.
+         */
+        countNodes: (labels?: string[], where?: any, transaction?: any) => Promise<import("./graph").ICountNodesResult>;
+        /**
+         * Counts relationships matching criteria.
+         * @param {string[]} [types] - Relationship types to filter by.
+         * @param {any} [where] - Where clause for filtering.
+         * @param {any} [transaction] - Optional transaction.
+         * @returns {Promise<any>} The count result.
+         */
+        countRelationships: (types?: string[], where?: any, transaction?: any) => Promise<import("./graph").ICountRelationshipsResult>;
+        /**
+         * Performs full-text search.
+         * @param {any} options - The search options.
+         * @param {any} [transaction] - Optional transaction.
+         * @returns {Promise<any>} The search result.
+         */
+        fullTextSearch: (options: any, transaction?: any) => Promise<import("./graph").IFullTextSearchResult<any>>;
+        /**
+         * Performs vector similarity search.
+         * @param {any} options - The search options.
+         * @param {any} [transaction] - Optional transaction.
+         * @returns {Promise<any>} The search result.
+         */
+        vectorSearch: (options: any, transaction?: any) => Promise<import("./graph").IVectorSearchResult<any>>;
+        /**
+         * Creates a node index.
+         * @param {any} options - The index creation options.
+         * @returns {Promise<any>} The index creation result.
+         */
+        createNodeIndex: (options: any) => Promise<import("./graph").ICreateIndexResult>;
+        /**
+         * Creates a node constraint.
+         * @param {any} options - The constraint creation options.
+         * @returns {Promise<any>} The constraint creation result.
+         */
+        createNodeConstraint: (options: any) => Promise<import("./graph").ICreateConstraintResult>;
+        /**
+         * Creates a relationship index.
+         * @param {any} options - The index creation options.
+         * @returns {Promise<any>} The index creation result.
+         */
+        createRelationshipIndex: (options: any) => Promise<import("./graph").ICreateIndexResult>;
+        /**
+         * Lists all indexes.
+         * @returns {Promise<any>} The list of indexes.
+         */
+        listIndexes: () => Promise<import("./graph").IListIndexesResult>;
+        /**
+         * Lists all constraints.
+         * @returns {Promise<any>} The list of constraints.
+         */
+        listConstraints: () => Promise<import("./graph").IListConstraintsResult>;
+        /**
+         * Drops an index by name.
+         * @param {string} name - The index name.
+         * @returns {Promise<any>} The drop result.
+         */
+        dropIndex: (name: string) => Promise<import("./graph").IDropIndexResult>;
+        /**
+         * Drops a constraint by name.
+         * @param {string} name - The constraint name.
+         * @returns {Promise<any>} The drop result.
+         */
+        dropConstraint: (name: string) => Promise<import("./graph").IDropConstraintResult>;
+        /**
+         * Lists all node labels.
+         * @returns {Promise<any>} The list of labels.
+         */
+        listLabels: () => Promise<import("./graph").IListLabelsResult>;
+        /**
+         * Lists all relationship types.
+         * @returns {Promise<any>} The list of relationship types.
+         */
+        listRelationshipTypes: () => Promise<import("./graph").IListRelationshipTypesResult>;
+        /**
+         * Creates a graph action.
+         * @param {any} options - The action creation options.
+         * @param {string} [productTag] - The product tag.
+         * @returns {Promise<any>} The created action.
+         */
+        createAction: (options: any, productTag?: string) => Promise<import("./graph").IGraphAction>;
+        /**
+         * Lists graph actions.
+         * @param {string} [graphTag] - The graph tag.
+         * @param {string} [productTag] - The product tag.
+         * @returns {Promise<any>} The list of actions.
+         */
+        listActions: (graphTag?: string, productTag?: string) => Promise<import("./graph").IListGraphActionsResult>;
+        /**
+         * Gets a graph action by tag.
+         * @param {string} actionTag - The action tag.
+         * @param {string} [graphTag] - The graph tag.
+         * @param {string} [productTag] - The product tag.
+         * @returns {Promise<any>} The action or null.
+         */
+        getAction: (actionTag: string, graphTag?: string, productTag?: string) => Promise<import("./graph").IGraphAction>;
+        /**
+         * Updates a graph action.
+         * @param {string} actionTag - The action tag.
+         * @param {any} updates - The updates to apply.
+         * @param {string} [graphTag] - The graph tag.
+         * @param {string} [productTag] - The product tag.
+         * @returns {Promise<any>} The updated action.
+         */
+        updateAction: (actionTag: string, updates: any, graphTag?: string, productTag?: string) => Promise<import("./graph").IGraphAction>;
+        /**
+         * Deletes a graph action.
+         * @param {string} actionTag - The action tag.
+         * @param {string} [graphTag] - The graph tag.
+         * @param {string} [productTag] - The product tag.
+         * @returns {Promise<void>} Resolves when the action is deleted.
+         */
+        deleteAction: (actionTag: string, graphTag?: string, productTag?: string) => Promise<void>;
+        /**
+         * Begins a new transaction.
+         * @param {any} [options] - Transaction options.
+         * @returns {Promise<any>} The transaction object.
+         */
+        beginTransaction: (options?: any) => Promise<import("./graph").IGraphTransaction>;
+        /**
+         * Commits a transaction.
+         * @param {any} transaction - The transaction to commit.
+         * @returns {Promise<void>} Resolves when committed.
+         */
+        commitTransaction: (transaction: any) => Promise<void>;
+        /**
+         * Rolls back a transaction.
+         * @param {any} transaction - The transaction to rollback.
+         * @returns {Promise<void>} Resolves when rolled back.
+         */
+        rollbackTransaction: (transaction: any) => Promise<void>;
+        /**
+         * Executes operations within a transaction with automatic commit/rollback.
+         * @param {Function} callback - The callback function receiving the transaction.
+         * @param {any} [options] - Transaction options.
+         * @returns {Promise<T>} The result of the callback.
+         * @example
+         * const result = await ductape.graph.executeTransaction(async (tx) => {
+         *   const node1 = await ductape.graph.createNode({ labels: ['User'], properties: { name: 'Alice' } }, tx);
+         *   const node2 = await ductape.graph.createNode({ labels: ['User'], properties: { name: 'Bob' } }, tx);
+         *   return { node1, node2 };
+         * });
+         */
+        executeTransaction: <T>(callback: (transaction: any) => Promise<T>, options?: any) => Promise<T>;
+        /**
+         * Dispatches a graph operation for deferred execution.
+         * @param {any} data - The dispatch input.
+         * @returns {Promise<any>} The dispatch result.
+         */
+        dispatch: (data: any) => Promise<IDispatchResult>;
+    };
+    /**
+     * Workflow API – define, execute, and manage workflows without getService().
+     *
+     * @example
+     * await ductape.workflow.define({ product: 'my-product', tag: 'orders', name: 'Orders', handler: async (ctx) => { ... } });
+     * const result = await ductape.workflow.execute({ product: 'my-product', env: 'prd', tag: 'orders', input: { orderId: '1' } });
+     */
+    workflow: {
+        define: (options: import("./workflows").IDefineWorkflowOptions<unknown, unknown>) => Promise<import("./workflows").IDefinedWorkflow<unknown, unknown>>;
+        execute: (options: import("./workflows").IExecuteWorkflowOptions) => Promise<import("./workflows").IWorkflowExecutionResult<unknown>>;
+        fetch: (workflowTag: string, productTag?: string) => Promise<import("./workflows").IWorkflowConfig>;
+        fetchAll: (productTag?: string) => Promise<import("./workflows").IWorkflowConfig[]>;
+        create: (productTag: string, workflowData: Partial<import("./types").IProductWorkflow>) => Promise<void>;
+        update: (workflowTag: string, productTag: string, updates: Partial<import("./types").IProductWorkflow>) => Promise<void>;
+        delete: (workflowTag: string, productTag: string) => Promise<void>;
+        dispatch: (data: import("./workflows").IWorkflowDispatchInput) => Promise<import("./workflows").IWorkflowDispatchResult>;
+        signal: (options: import("./workflows").ISendSignalOptions) => Promise<void>;
+        query: (options: import("./workflows").IQueryWorkflowOptions) => Promise<unknown>;
+        status: (options: import("./workflows").IWorkflowStatusInput) => Promise<import("./workflows").IWorkflowStatus>;
+        cancel: (options: import("./workflows").IWorkflowCancelInput) => Promise<import("./workflows").IWorkflowCancelResult>;
+        replay: (options: import("./workflows").IWorkflowReplayInput) => Promise<import("./workflows").IWorkflowReplayResult>;
+        restart: (options: import("./workflows").IWorkflowRestartInput) => Promise<import("./workflows").IWorkflowRestartResult>;
+        resume: (options: import("./workflows").IWorkflowResumeInput) => Promise<import("./workflows").IWorkflowResumeResult>;
+        replayFromStep: (options: import("./workflows").IWorkflowReplayFromStepInput) => Promise<import("./workflows").IWorkflowReplayResult>;
+        history: (options: import("./workflows").IWorkflowHistoryInput) => Promise<import("./workflows").IWorkflowHistory>;
+        stepDetail: (options: import("./workflows").IStepDetailInput) => Promise<import("./workflows").IStepDetail>;
+        relatedExecutions: (options: import("./workflows").IRelatedExecutionsInput) => Promise<import("./workflows").IRelatedExecutions>;
+        compare: (options: import("./workflows").ICompareExecutionsInput) => Promise<import("./workflows").IExecutionComparison>;
+    };
+    /**
+     * @deprecated Use ductape.workflow.* instead. getService() remains for advanced usage.
+     */
+    workflows: {
+        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 for advanced operations.
+         * @returns {Promise<VectorDatabaseService>} The vector database service instance.
+         */
+        getService: () => Promise<VectorDatabaseService>;
+        /**
+         * Creates a vector database configuration for a product.
+         * @param {ICreateVectorDbOptions} options - The vector configuration options.
+         * @returns {Promise<void>} Resolves when the vector config is created.
+         */
+        create: (options: ICreateVectorDbOptions) => Promise<void>;
+        /**
+         * Fetches a vector database configuration by tag.
+         * @param {IFetchVectorOptions} options - The fetch options.
+         * @returns {Promise<IProductVector | null>} The fetched vector configuration.
+         */
+        fetch: (options: import("./vector/vector-database.service").IFetchVectorOptions) => Promise<import("./types").IProductVector>;
+        /**
+         * Fetches all vector database configurations for a product.
+         * @param {object} options - The fetch options containing product tag.
+         * @returns {Promise<IProductVector[]>} The list of vector configurations.
+         */
+        list: (options: {
+            product: string;
+        }) => Promise<import("./types").IProductVector[]>;
+        /**
+         * Updates a vector database configuration.
+         * @param {IUpdateVectorDbOptions} options - The update options.
+         * @returns {Promise<void>} Resolves when the vector config is updated.
+         */
+        update: (options: import("./vector/vector-database.service").IUpdateVectorDbOptions) => Promise<void>;
+        /**
+         * Deletes a vector database configuration.
+         * @param {IDeleteVectorConfigOptions} options - The delete options.
+         * @returns {Promise<void>} Resolves when the vector config is deleted.
+         */
+        delete: (options: import("./vector/vector-database.service").IDeleteVectorConfigOptions) => Promise<void>;
+        /**
+         * Connects to a vector database.
+         * @param {object} options - Connection options with product, env, and vector.
+         * @returns {Promise<VectorService>} The connected vector service.
+         */
+        connect: (options: {
+            product: string;
+            env: string;
+            vector: string;
+        }) => Promise<import("./vector").VectorService>;
+        /**
+         * Disconnects from a specific vector database.
+         * @param {object} options - Disconnect options with product, env, and vector.
+         * @returns {Promise<void>} Resolves when disconnected.
+         */
+        disconnect: (options: {
+            product: string;
+            env: string;
+            vector: string;
+        }) => Promise<void>;
+        /**
+         * Disconnects all cached vector database connections.
+         * @returns {Promise<void>} Resolves when all connections are closed.
+         */
+        disconnectAll: () => Promise<void>;
+        /**
+         * Query vectors by similarity.
+         * @param {IProductVectorQueryOptions} options - The query options.
+         * @returns {Promise<IQueryVectorsResult>} The query results.
+         */
+        query: (options: import("./vector/vector-database.service").IProductVectorQueryOptions) => Promise<import("./vector").IQueryVectorsResult>;
+        /**
+         * Upsert vectors (insert or update).
+         * @param {IProductVectorUpsertOptions} options - The upsert options.
+         * @returns {Promise<IUpsertVectorsResult>} The upsert result.
+         */
+        upsert: (options: import("./vector/vector-database.service").IProductVectorUpsertOptions) => Promise<import("./vector").IUpsertVectorsResult>;
+        /**
+         * Fetch vectors by IDs.
+         * @param {IProductVectorFetchOptions} options - The fetch options.
+         * @returns {Promise<IFetchVectorsResult>} The fetched vectors.
+         */
+        fetchVectors: (options: import("./vector/vector-database.service").IProductVectorFetchOptions) => Promise<import("./vector").IFetchVectorsResult>;
+        /**
+         * Delete vectors by IDs.
+         * @param {IProductVectorDeleteOptions} options - The delete options.
+         * @returns {Promise<IDeleteVectorsResult>} The delete result.
+         */
+        deleteVectors: (options: import("./vector/vector-database.service").IProductVectorDeleteOptions) => Promise<import("./vector").IDeleteVectorsResult>;
+        /**
+         * Find similar vectors to a given vector.
+         * @param {object} options - Find similar options with product, env, tag, vector, and topK.
+         * @returns {Promise<IQueryVectorsResult>} The similar vectors.
+         */
+        findSimilar: (options: {
+            product: string;
+            env: string;
+            vector: string;
+            values: number[];
+            topK?: number;
+            filter?: any;
+            namespace?: string;
+            includeValues?: boolean;
+            includeMetadata?: boolean;
+        }) => Promise<import("./vector").IQueryVectorsResult>;
+        /**
+         * Upsert a single vector.
+         * @param {object} options - Single vector upsert options.
+         * @returns {Promise<IUpsertVectorsResult>} The upsert result.
+         */
+        upsertOne: (options: {
+            product: string;
+            env: string;
+            tag: string;
+            id: string;
+            values: number[];
+            metadata?: Record<string, unknown>;
+            namespace?: string;
+            session?: string;
+        }) => Promise<import("./vector").IUpsertVectorsResult>;
+        /**
+         * Fetch a single vector by ID.
+         * @param {object} options - Single vector fetch options.
+         * @returns {Promise<IVector | null>} The fetched vector or null.
+         */
+        fetchOne: (options: {
+            product: string;
+            env: string;
+            vector: string;
+            id: string;
+            namespace?: string;
+        }) => Promise<import("./vector").IVector>;
+        /**
+         * Update a single vector.
+         * @param {object} options - Update options.
+         * @returns {Promise<IUpdateVectorResult>} The update result.
+         */
+        updateVector: (options: {
+            product: string;
+            env: string;
+            vector: string;
+            id: string;
+            values?: number[];
+            setMetadata?: Record<string, unknown>;
+            mergeMetadata?: Record<string, unknown>;
+            namespace?: string;
+        }) => Promise<import("./vector").IUpdateVectorResult>;
+        /**
+         * Update vector metadata.
+         * @param {object} options - Update metadata options.
+         * @returns {Promise<IUpdateVectorResult>} The update result.
+         */
+        updateMetadata: (options: {
+            product: string;
+            env: string;
+            vector: string;
+            id: string;
+            metadata: Record<string, unknown>;
+            merge?: boolean;
+            namespace?: string;
+        }) => Promise<import("./vector").IUpdateVectorResult>;
+        /**
+         * Delete vectors by IDs (convenience method).
+         * @param {object} options - Delete by IDs options.
+         * @returns {Promise<IDeleteVectorsResult>} The delete result.
+         */
+        deleteByIds: (options: {
+            product: string;
+            env: string;
+            vector: string;
+            ids: string[];
+            namespace?: string;
+        }) => Promise<import("./vector").IDeleteVectorsResult>;
+        /**
+         * Delete all vectors in a namespace.
+         * @param {object} options - Delete all options.
+         * @returns {Promise<IDeleteVectorsResult>} The delete result.
+         */
+        deleteAll: (options: {
+            product: string;
+            env: string;
+            vector: string;
+            namespace?: string;
+        }) => Promise<import("./vector").IDeleteVectorsResult>;
+        /**
+         * List vector IDs.
+         * @param {object} options - List options.
+         * @returns {Promise<IListVectorsResult>} The list result.
+         */
+        listVectors: (options: {
+            product: string;
+            env: string;
+            vector: string;
+            namespace?: string;
+            prefix?: string;
+            limit?: number;
+            cursor?: string;
+        }) => Promise<import("./vector").IListVectorsResult>;
+        /**
+         * List all vector IDs (paginated).
+         * @param {object} options - List all options.
+         * @returns {Promise<string[]>} All vector IDs.
+         */
+        listAllVectors: (options: {
+            product: string;
+            env: string;
+            vector: string;
+            namespace?: string;
+            prefix?: string;
+        }) => Promise<string[]>;
+        /**
+         * List available namespaces.
+         * @param {object} options - Namespace list options.
+         * @returns {Promise<IListNamespacesResult>} The namespaces.
+         */
+        listNamespaces: (options: {
+            product: string;
+            env: string;
+            vector: string;
+        }) => Promise<import("./vector").IListNamespacesResult>;
+        /**
+         * Delete a namespace.
+         * @param {object} options - Namespace delete options.
+         * @returns {Promise<void>} Resolves when deleted.
+         */
+        deleteNamespace: (options: {
+            product: string;
+            env: string;
+            vector: string;
+            namespace: string;
+        }) => Promise<void>;
+        /**
+         * Describe the current index.
+         * @param {object} options - Index describe options.
+         * @returns {Promise<IVectorIndexInfo>} The index info.
+         */
+        describeIndex: (options: {
+            product: string;
+            env: string;
+            vector: string;
+        }) => Promise<import("./vector").IVectorIndexInfo>;
+        /**
+         * Get index statistics.
+         * @param {object} options - Stats options.
+         * @returns {Promise<IVectorIndexStats>} The index stats.
+         */
+        getStats: (options: {
+            product: string;
+            env: string;
+            vector: string;
+        }) => Promise<import("./vector").IVectorIndexStats>;
+        /**
+         * Create a new index.
+         * @param {object} options - Create index options.
+         * @returns {Promise<ICreateIndexResult>} The create result.
+         */
+        createIndex: (options: {
+            product: string;
+            env: string;
+            vector: string;
+            name: string;
+            dimensions: number;
+            metric?: import("./vector").DistanceMetric;
+            replicas?: number;
+            shards?: number;
+        }) => Promise<import("./vector").ICreateIndexResult>;
+        /**
+         * Delete an index.
+         * @param {object} options - Delete index options.
+         * @returns {Promise<IDeleteIndexResult>} The delete result.
+         */
+        deleteIndex: (options: {
+            product: string;
+            env: string;
+            vector: string;
+            name: string;
+        }) => Promise<import("./vector").IDeleteIndexResult>;
+        /**
+         * List all indexes.
+         * @param {object} options - List indexes options.
+         * @returns {Promise<IVectorIndexInfo[]>} The list of indexes.
+         */
+        listIndexes: (options: {
+            product: string;
+            env: string;
+            vector: string;
+        }) => Promise<import("./vector").IVectorIndexInfo[]>;
+        /**
+         * Count vectors in the index.
+         * @param {object} options - Count options.
+         * @returns {Promise<number>} The vector count.
+         */
+        count: (options: {
+            product: string;
+            env: string;
+            vector: string;
+            namespace?: string;
+        }) => Promise<number>;
+        /**
+         * Check if a vector exists.
+         * @param {object} options - Exists check options.
+         * @returns {Promise<boolean>} True if exists.
+         */
+        exists: (options: {
+            product: string;
+            env: string;
+            vector: string;
+            id: string;
+            namespace?: string;
+        }) => Promise<boolean>;
+        /**
+         * Test connection to a vector database.
+         * @param {object} options - Test connection options.
+         * @returns {Promise<boolean>} True if connection is healthy.
+         */
+        testConnection: (options: {
+            product: string;
+            env: string;
+            vector: string;
+        }) => Promise<boolean>;
+        /**
+         * Check if a feature is supported.
+         * @param {object} options - Feature check options.
+         * @returns {Promise<boolean>} True if supported.
+         */
+        supportsFeature: (options: {
+            product: string;
+            env: string;
+            vector: string;
+            feature: import("./vector").VectorFeature;
+        }) => Promise<boolean>;
+        /**
+         * Get all supported features.
+         * @param {object} options - Get features options.
+         * @returns {Promise<VectorFeature[]>} The supported features.
+         */
+        getSupportedFeatures: (options: {
+            product: string;
+            env: string;
+            vector: string;
+        }) => Promise<import("./vector").VectorFeature[]>;
+        /**
+         * Vector actions for managing reusable query templates.
+         */
+        actions: {
+            /**
+             * Create a new vector action
+             */
+            create: (options: {
+                product: string;
+                vector: string;
+                name: string;
+                actionTag: string;
+                operation: string;
+                description?: string;
+                template: Record<string, any>;
+                parameters?: Array<{
+                    name: string;
+                    path: string;
+                    type: "string" | "number" | "boolean" | "array" | "object";
+                    required?: boolean;
+                    defaultValue?: any;
+                    description?: string;
+                }>;
+            }) => Promise<import("./types").IProductVectorAction>;
+            /**
+             * Update an existing vector action
+             */
+            update: (options: {
+                product: string;
+                vector: string;
+                actionTag: string;
+                name?: string;
+                description?: string;
+                template?: Record<string, any>;
+                parameters?: Array<{
+                    name: string;
+                    path: string;
+                    type: "string" | "number" | "boolean" | "array" | "object";
+                    required?: boolean;
+                    defaultValue?: any;
+                    description?: string;
+                }>;
+            }) => Promise<import("./types").IProductVectorAction>;
+            /**
+             * Fetch a specific vector action
+             */
+            fetch: (options: {
+                product: string;
+                vector: string;
+                actionTag: string;
+            }) => Promise<import("./vector").IVectorActionDefinition>;
+            /**
+             * Fetch all vector actions for a vector database
+             */
+            fetchAll: (options: {
+                product: string;
+                vector: string;
+            }) => Promise<import("./vector").IVectorActionDefinition[]>;
+            /**
+             * Delete a vector action
+             */
+            delete: (options: {
+                product: string;
+                vector: string;
+                actionTag: string;
+            }) => Promise<void>;
+            /**
+             * Execute a vector action (resolve template placeholders)
+             */
+            execute: (options: {
+                product: string;
+                env: string;
+                vector: string;
+                action: string;
+                input: Record<string, any>;
+            }) => Promise<import("./vector").IVectorActionTemplate>;
+        };
+    };
+    /**
+     * Warehouse interface for unified cross-database queries.
+     *
+     * Provides a single JSON interface for querying and writing data across
+     * databases, graphs, and vector stores with cross-database joins and
+     * distributed transactions. All product databases, graphs, and vectors
+     * are automatically available for use.
+     *
+     * @example
+     * // Cross-database query with join
+     * const result = await ductape.warehouse.query({
+     *   operation: 'select',
+     *   from: { type: 'database', tag: 'users-postgres', entity: 'users', alias: 'u' },
+     *   fields: ['u.name', 'u.email', 'friends.name as friend_name'],
+     *   join: [{
+     *     type: 'left',
+     *     source: { type: 'graph', tag: 'social-neo4j', entity: 'Person', alias: 'friends' },
+     *     graph: { relationship: 'FRIENDS_WITH', direction: 'both' },
+     *     on: { left: 'u.id', right: 'friends.userId' }
+     *   }],
+     *   where: { 'u.status': { $eq: 'active' } },
+     *   limit: 100
+     * });
+     */
+    warehouse: {
+        /**
+         * Execute a warehouse query
+         * @param {object} options - Query options including product, env, and the query
+         * @returns {Promise<IWarehouseResult>} Query result
+         * @example
+         * const result = await ductape.warehouse.query({
+         *   product: 'my-app',
+         *   env: 'production',
+         *   query: {
+         *     operation: 'select',
+         *     from: { type: 'database', tag: 'users', entity: 'users', alias: 'u' },
+         *     fields: ['u.id', 'u.name'],
+         *     where: { 'u.status': { $eq: 'active' } }
+         *   }
+         * });
+         */
+        query: <T = Record<string, any>>(options: {
+            product: string;
+            env: string;
+            query: IWarehouseQuery;
+        }) => Promise<import("./warehouse").IWarehouseResult<T>>;
+        /**
+         * Select from a single source
+         * @param {object} options - Select options including product, env, source, and query options
+         * @returns {Promise<T[]>} Selected records
+         * @example
+         * const users = await ductape.warehouse.select({
+         *   product: 'my-app',
+         *   env: 'production',
+         *   source: { type: 'database', tag: 'users', entity: 'users', alias: 'u' },
+         *   fields: ['id', 'name'],
+         *   where: { status: { $eq: 'active' } }
+         * });
+         */
+        select: <T = Record<string, any>>(options: {
+            product: string;
+            env: string;
+            source: IDataSource;
+            fields?: string[];
+            where?: Record<string, any>;
+            orderBy?: {
+                field: string;
+                order: "ASC" | "DESC";
+            }[];
+            limit?: number;
+            offset?: number;
+        }) => Promise<T[]>;
+        /**
+         * Insert into a source
+         * @param {object} options - Insert options including product, env, source, and data
+         * @returns {Promise<IWarehouseResult>} Insert result
+         * @example
+         * await ductape.warehouse.insert({
+         *   product: 'my-app',
+         *   env: 'production',
+         *   source: { type: 'database', tag: 'users', entity: 'users' },
+         *   data: { name: 'John', email: 'john@example.com' }
+         * });
+         */
+        insert: <T = Record<string, any>>(options: {
+            product: string;
+            env: string;
+            source: IDataSource;
+            data: Record<string, any> | Record<string, any>[];
+            returning?: boolean;
+        }) => Promise<import("./warehouse").IWarehouseResult<T>>;
+        /**
+         * Update in a source
+         * @param {object} options - Update options including product, env, source, data, and where
+         * @returns {Promise<IWarehouseResult>} Update result
+         * @example
+         * await ductape.warehouse.update({
+         *   product: 'my-app',
+         *   env: 'production',
+         *   source: { type: 'database', tag: 'users', entity: 'users' },
+         *   data: { status: 'inactive' },
+         *   where: { id: { $eq: 123 } }
+         * });
+         */
+        update: <T = Record<string, any>>(options: {
+            product: string;
+            env: string;
+            source: IDataSource;
+            data: Record<string, any>;
+            where: Record<string, any>;
+            returning?: boolean;
+        }) => Promise<import("./warehouse").IWarehouseResult<T>>;
+        /**
+         * Delete from a source
+         * @param {object} options - Delete options including product, env, source, and where
+         * @returns {Promise<IWarehouseResult>} Delete result
+         * @example
+         * await ductape.warehouse.delete({
+         *   product: 'my-app',
+         *   env: 'production',
+         *   source: { type: 'database', tag: 'users', entity: 'users' },
+         *   where: { status: { $eq: 'deleted' } }
+         * });
+         */
+        delete: <T = Record<string, any>>(options: {
+            product: string;
+            env: string;
+            source: IDataSource;
+            where: Record<string, any>;
+            returning?: boolean;
+        }) => Promise<import("./warehouse").IWarehouseResult<T>>;
+        /**
+         * Upsert into a source
+         * @param {object} options - Upsert options including product, env, source, and data
+         * @returns {Promise<IWarehouseResult>} Upsert result
+         * @example
+         * await ductape.warehouse.upsert({
+         *   product: 'my-app',
+         *   env: 'production',
+         *   source: { type: 'database', tag: 'users', entity: 'users' },
+         *   data: { id: 123, name: 'John', email: 'john@example.com' }
+         * });
+         */
+        upsert: <T = Record<string, any>>(options: {
+            product: string;
+            env: string;
+            source: IDataSource;
+            data: Record<string, any>;
+            returning?: boolean;
+        }) => Promise<import("./warehouse").IWarehouseResult<T>>;
+        /**
+         * Execute multiple operations in a saga transaction
+         * @param {object} options - Transaction options including product, env, and operations
+         * @returns {Promise<ISagaResult>} Transaction result
+         * @example
+         * const result = await ductape.warehouse.transaction({
+         *   product: 'my-app',
+         *   env: 'production',
+         *   operations: [
+         *     {
+         *       operation: 'insert',
+         *       from: { type: 'database', tag: 'orders', entity: 'orders' },
+         *       data: { userId: 'u1', total: 99.99 }
+         *     },
+         *     {
+         *       operation: 'insert',
+         *       from: { type: 'graph', tag: 'activity', entity: 'Event' },
+         *       data: { type: 'ORDER_PLACED', userId: 'u1' }
+         *     }
+         *   ]
+         * });
+         */
+        transaction: (options: {
+            product: string;
+            env: string;
+            operations: Omit<IWarehouseQuery, "transaction">[];
+            timeout?: number;
+            retryOnFailure?: boolean;
+            maxRetries?: number;
+        }) => Promise<import("./warehouse").ISagaResult>;
+    };
+    /**
+     * 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));
+         */
+        list: () => 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>;
+    };
+    /**
+     * Cloud provider connections (AWS, GCP, Azure) for discovering, importing, and provisioning resources.
+     *
+     * @example
+     * const setup = await ductape.cloud.connections.create({
+     *   provider: 'aws',
+     *   name: 'Production AWS',
+     *   scopes: ['storage', 'broker'],
+     * });
+     * await ductape.cloud.connections.complete(setup.connection.id, { role_arn: 'arn:aws:iam::123:role/Ductape' });
+     */
+    cloud: {
+        connections: {
+            create: (input: ICreateCloudConnectionInput) => Promise<ICloudConnectionSetup>;
+            list: () => Promise<ICloudConnection[]>;
+            fetch: (connectionId: string) => Promise<ICloudConnection>;
+            delete: (connectionId: string) => Promise<void>;
+            complete: (connectionId: string, input: ICompleteCloudConnectionInput) => Promise<ICloudConnection>;
+            validate: (connectionId: string) => Promise<IValidateCloudConnectionResult>;
+        };
+        resources: {
+            list: (input: IListCloudResourcesInput) => Promise<IListCloudResourcesResult>;
+            import: (input: IImportCloudResourceInput) => Promise<IImportCloudResourceResult>;
+            importAndPersist: (input: IImportCloudResourceInput) => Promise<IImportCloudResourceResult>;
+            provision: (input: IProvisionCloudResourceInput) => Promise<IProvisionCloudResourceResult>;
+            provisionAndPersist: (input: IProvisionCloudResourceInput) => Promise<IProvisionCloudResourceResult>;
+        };
+        credentials: {
+            issue: (input: ICloudRuntimeCredentialsInput) => Promise<ICloudRuntimeCredentials>;
+        };
+        getService: () => Promise<CloudService>;
+    };
+    /**
+     * 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: (data: IProductCache & {
+            product: string;
+        }) => 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;
+            expiryFilter?: "all" | "expiring" | "permanent" | "expired";
+        }) => 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: {
+        /**
+         * Creates a new app.
+         * @param {ICreateAppBuilder} data - The app data.
+         * @returns {Promise<{ app_id: string }>} The ID of the created app.
+         */
+        create: (data: ICreateAppBuilder) => Promise<{
+            app_id: string;
+        }>;
+        /**
+         * Fetches an app by tag.
+         * @param {string} tag - The app tag.
+         * @returns {Promise<IApp|null>} The fetched app, or null if not found.
+         */
+        fetch: (tag: string) => Promise<IApp>;
+        /**
+         * Updates an app by tag.
+         * @param {string} tag - The app tag.
+         * @param {Partial<IApp>} data - The app data to update.
+         * @returns {Promise<void>} Resolves when the app is updated. Throws on error.
+         */
+        update: (tag: string, data: Partial<IApp>) => Promise<void>;
+        /**
+         * 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>;
+        /**
+         * 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: (appTag: string, data: IAppEnv) => Promise<void>;
+            /**
+             * Fetches all environments for an app.
+             * @param {string} appTag - The app tag.
+             * @returns {IAppEnv[]} The list of environments.
+             */
+            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: (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: (appTag: string, slug: string, data: Partial<IAppEnv>) => Promise<void>;
+        };
+    };
+    /**
+     * Variable-related operations for managing app variables.
+     */
+    variables: {
+        /**
+         * 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.
+         */
+        create: (appTag: string, data: IAppVariables) => Promise<void>;
+        /**
+         * Fetches all variables for an app.
+         * @param {string} appTag - The app tag.
+         * @returns {IAppVariables[]} The list of variables.
+         */
+        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>;
+    };
+    /**
+     * Constant-related operations for managing app constants.
+     */
+    constants: {
+        /**
+         * 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: (appTag: string, data: IAppConstants) => Promise<void>;
+        /**
+         * Fetches all constants for an app.
+         * @param {string} appTag - The app tag.
+         * @returns {IAppConstants[]} The list of constants.
+         */
+        list: (appTag: string) => Promise<IAppConstants[]>;
+        /**
+         * 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.
+         */
+        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>;
+    };
+    /**
+     * API operations: run/dispatch app actions, credentials, OAuth, and app action CRUD.
+     */
+    api: {
+        /**
+         * 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} 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.
+         */
+        update: (appTag: string, tag: string, data: Partial<IActionUpdate>) => Promise<void>;
+        /**
+         * Creates an action.
+         * @param {string} appTag - The app tag.
+         * @param {Partial<IActionUpdate> & { tag: string; name: string; resource: string; method: string; folder_id?: string }} data - The action data.
+         * @returns {Promise<void>} Resolves when the action is created. Throws on error.
+         */
+        create: (appTag: string, data: Partial<IActionUpdate> & {
+            tag: string;
+            name: string;
+            resource: string;
+            method: string;
+            folder_id?: string;
+        }) => Promise<void>;
+        /**
+         * Fetches all actions for an app.
+         * @param {string} appTag - The app tag.
+         * @returns {IAppAction[]} The list of actions.
+         */
+        list: (appTag: string) => Promise<IAppAction[]>;
+        /**
+         * 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.
+         */
+        fetch: (appTag: string, tag: string) => Promise<IAppAction>;
+        /**
+         * Runs an action processor immediately.
+         * @param {IActionProcessorInput} data - The action processor input.
+         * @returns {Promise<any>} The result of the action processing.
+         * @example
+         * await ductape.api.run({
+         *   product: 'my-product',
+         *   env: 'production',
+         *   app: 'stripe',
+         *   action: 'charge',
+         *   input: { amount: 1000, currency: 'usd' }
+         * });
+         */
+        run: (data: IActionProcessorInput) => Promise<any>;
+        /**
+         * 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.api.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.api.dispatch({
+         *   product: 'my-product',
+         *   env: 'production',
+         *   app: 'analytics',
+         *   event: 'daily-report',
+         *   input: {},
+         *   schedule: { cron: '0 9 * * *', tz: 'America/New_York' } // 9 AM daily
+         * });
+         */
+        dispatch: (data: IActionDispatchInput) => Promise<IDispatchResult>;
+        /**
+         * 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.api.config({
+         *   ...stripeConfig,
+         *   credentials: {
+         *     'headers:Authorization': '$Secret{StripeApiKey}',
+         *   }
+         * });
+         *
+         * // Now all stripe actions automatically include the Authorization header
+         * await ductape.api.run({
+         *   ...stripeConfig,
+         *   action: 'create-charge',
+         *   input: { amount: 1000, currency: 'usd' }
+         * });
+         */
+        config: (config: IShareCredentialsConfig) => void;
+        /**
+         * 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.api.run
+         * await ductape.api.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.api.run to call your refresh token action
+         *     const response = await ductape.api.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.api.run({
+         *   product: 'my-product',
+         *   app: 'salesforce',
+         *   env: 'prd',
+         *   action: 'get-contacts',
+         *   input: { limit: 10 }
+         * });
+         */
+        oauth: (config: IOAuthConfig) => Promise<void>;
+    };
+    /** @deprecated Use {@link Ductape.api} instead. */
+    get 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} 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.
+         */
+        update: (appTag: string, tag: string, data: Partial<IActionUpdate>) => Promise<void>;
+        /**
+         * Creates an action.
+         * @param {string} appTag - The app tag.
+         * @param {Partial<IActionUpdate> & { tag: string; name: string; resource: string; method: string; folder_id?: string }} data - The action data.
+         * @returns {Promise<void>} Resolves when the action is created. Throws on error.
+         */
+        create: (appTag: string, data: Partial<IActionUpdate> & {
+            tag: string;
+            name: string;
+            resource: string;
+            method: string;
+            folder_id?: string;
+        }) => Promise<void>;
+        /**
+         * Fetches all actions for an app.
+         * @param {string} appTag - The app tag.
+         * @returns {IAppAction[]} The list of actions.
+         */
+        list: (appTag: string) => Promise<IAppAction[]>;
+        /**
+         * 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.
+         */
+        fetch: (appTag: string, tag: string) => Promise<IAppAction>;
+        /**
+         * Runs an action processor immediately.
+         * @param {IActionProcessorInput} data - The action processor input.
+         * @returns {Promise<any>} The result of the action processing.
+         * @example
+         * await ductape.api.run({
+         *   product: 'my-product',
+         *   env: 'production',
+         *   app: 'stripe',
+         *   action: 'charge',
+         *   input: { amount: 1000, currency: 'usd' }
+         * });
+         */
+        run: (data: IActionProcessorInput) => Promise<any>;
+        /**
+         * 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.api.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.api.dispatch({
+         *   product: 'my-product',
+         *   env: 'production',
+         *   app: 'analytics',
+         *   event: 'daily-report',
+         *   input: {},
+         *   schedule: { cron: '0 9 * * *', tz: 'America/New_York' } // 9 AM daily
+         * });
+         */
+        dispatch: (data: IActionDispatchInput) => Promise<IDispatchResult>;
+        /**
+         * 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.api.config({
+         *   ...stripeConfig,
+         *   credentials: {
+         *     'headers:Authorization': '$Secret{StripeApiKey}',
+         *   }
+         * });
+         *
+         * // Now all stripe actions automatically include the Authorization header
+         * await ductape.api.run({
+         *   ...stripeConfig,
+         *   action: 'create-charge',
+         *   input: { amount: 1000, currency: 'usd' }
+         * });
+         */
+        config: (config: IShareCredentialsConfig) => void;
+        /**
+         * 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.api.run
+         * await ductape.api.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.api.run to call your refresh token action
+         *     const response = await ductape.api.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.api.run({
+         *   product: 'my-product',
+         *   app: 'salesforce',
+         *   env: 'prd',
+         *   action: 'get-contacts',
+         *   input: { limit: 10 }
+         * });
+         */
+        oauth: (config: IOAuthConfig) => Promise<void>;
+    };
+    /**
+     * Auth-related operations for managing app auths.
+     */
+    auths: {
+        /**
+         * 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.
+         */
+        create: (appTag: string, data: IAppAuth) => Promise<void>;
+        /**
+         * Fetches all auths for an app.
+         * @param {string} appTag - The app tag.
+         * @returns {IAppAuth[]} The list of auths.
+         */
+        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>;
+    };
+    /**
+     * Webhook-related operations for managing app webhooks.
+     */
+    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: {
+            /**
+             * 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.
+             */
+            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>;
+        };
+    };
+    /**
+     * Logs-related operations for initializing and fetching logs.
+     */
+    logs: {
+        /**
+         * Initializes the logger service for a product or app.
+         * @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: (product?: string, app?: string) => Promise<void>;
+        add: () => Promise<void>;
+        /**
+         * Fetches logs based on provided query parameters.
+         * @param {LogQueryParams} params - The log query parameters.
+         * @returns {Promise<any>} The fetched log data.
+         */
+        fetch: (params: LogQueryParams) => Promise<any>;
+        publish: () => Promise<void>;
+    };
+    private initUserAuth;
+    private createNewLogger;
+    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 WarehouseService instance with authenticated config
+     * @param product - Product tag
+     * @param env - Environment
+     * @returns WarehouseService instance
+     */
+    private createNewWarehouseService;
+    /**
+     * 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;
+    private createNewCloudService;
+    /**
+     * 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;
+    /**
+     * Get or create a BrokersService instance with authenticated config (cached)
+     * @returns BrokersService instance
+     */
+    private createNewBrokersService;
+    /**
+     * Create a new QuotaService instance with authenticated config
+     * @returns QuotaService instance (cached)
+     */
+    private createNewQuotaService;
+    /**
+     * Create a new FallbackService instance with authenticated config
+     * @returns FallbackService instance (cached)
+     */
+    private createNewFallbackService;
+    /**
+     * Create a new HealthcheckService instance with authenticated config
+     * @returns HealthcheckService instance (cached)
+     */
+    private createNewHealthcheckService;
+    private fetchSession;
+    private validateWorkspace;
+    private createNewAppBuilderSession;
+    private refreshUserAccessToken;
+    fetchWorkspaceApps(status: PublicStates): Promise<Array<IApp>>;
+    fetchWorkspaceProjects(status: PublicStates): Promise<Array<IProduct>>;
+    /**
+     * Fetches the latest healthcheck status for a product/env from Redis cache via processor service.
+     */
+    getHealthcheckStatus(product: string, envSlug: string): Promise<any>;
+}