@ductape/sdk 0.1.8 → 0.1.9

package/dist/products/services/products.service.d.ts

@@ -0,0 +1,579 @@
+import { IBootstrapActionParams, IBootstrapActionResponse, IBootstrapNotificationParams, IBootstrapNotificationResponse, IBootstrapStorageParams, IBootstrapStorageResponse, IBootstrapWorkflowParams, IGenerateExecutablePayloadParams, IGenerateExecutablePayloadResponse } from '../../api/services/productsApi.service';
+import { IApp, IAppAccess, IAppAction, IAppWebhook, ISample, IVersion } from '../../types/appBuilder.types';
+import { IBuilderInit } from '../../types/index.types';
+import { IActionDataParserInput, IActionRequest, ICreateProductsBuilder, IFeatureEvent, IFeatureInput, IFeatureSequence, IProduct, IProductApp, IProductCache, IProductDatabase, IProductDatabaseAction, IProductEnv, IProductFeature, IProductFunction, IProductJobs, IParseActionEventInput, IParseInputStringInput, IParseInputStringMetaData, IProductStorage, IDbActionRequest, INotificationRequest, IProductQuota, IProductFallback, IProductDatabaseMigration, IQuotaOptions, IFallbackOptions, IProductSession, IFetchFilesPayload, IFetchUsersPayload, IProductAppHealth, IProductGraph, IProductWorkflow, IProductVector, IProductAgent, IProductLLMModel, IProductDatabaseTrigger, IProductVectorAction } from '../../types/productsBuilder.types';
+import { KeyValuePair } from '../../imports/imports.types';
+import { IProductNotification, INotificationEnv, IProductNotificationTemplate, IProductMessageBroker, IProductMessageBrokerTopic, IMessageBrokerProducer, IMessageBrokerConsumer, IFileURLPayload } from '../../types/processor.types';
+import { IParsedSample } from '../../types/inputs.types';
+export interface IProductsBuilderService {
+    fetchPrivateKey(): string;
+    fetchWorkspaceId(): string;
+    fetchProductId(): string;
+    fetchThirdPartyAppByAccessTag(access_tag: string): Promise<(IApp & IVersion) | null>;
+    createProduct(data: ICreateProductsBuilder): Promise<void>;
+    updateProduct(data: Partial<IProduct>): Promise<void>;
+    initializeProduct(product_id: string): Promise<void>;
+    fetchProduct(): Promise<IProduct>;
+    initializeProductByTag(tag: string): Promise<void>;
+    bootstrapAction(params: IBootstrapActionParams): Promise<IBootstrapActionResponse>;
+    applyBootstrapActionResult(result: IBootstrapActionResponse, product_tag?: string): void;
+    bootstrapNotification(params: IBootstrapNotificationParams): Promise<IBootstrapNotificationResponse>;
+    bootstrapStorage(params: IBootstrapStorageParams): Promise<IBootstrapStorageResponse>;
+    bootstrapWorkflow(params: Omit<IBootstrapWorkflowParams, 'workspace_id'>): Promise<Record<string, unknown>>;
+    generateExecutablePayload(params: IGenerateExecutablePayloadParams): Promise<IGenerateExecutablePayloadResponse>;
+    createEnv(data: Partial<IProductEnv>): Promise<void>;
+    updateEnv(slug: string, data: Partial<IProductEnv>): Promise<void>;
+    fetchEnv(slug: string): Promise<IProductEnv | null>;
+    fetchEnvs(): Promise<Array<IProductEnv>>;
+    createSession(data: IProductSession): Promise<void>;
+    updateSession(tag: string, data: Partial<IProductSession>): Promise<void>;
+    fetchSession(tag: string): Promise<IProductSession | null>;
+    fetchSessions(): Promise<Array<IProductSession>>;
+    createFunction(data: Partial<IProductFunction>): Promise<void>;
+    updateFunction(tag: string, data: Partial<IProductFunction>): Promise<void>;
+    fetchFunction(tag: string): Promise<IProductFunction | null>;
+    fetchFunctions(): Promise<Array<IProductFunction>>;
+    createCache(data: Partial<IProductCache>, throwErrorIfExists?: boolean): Promise<void>;
+    updateCache(tag: string, data: Partial<IProductCache>): Promise<void>;
+    fetchCache(tag: string): Promise<IProductCache | null>;
+    fetchCaches(): Promise<Array<IProductCache>>;
+    createStorage(data: Partial<IProductStorage>): Promise<void>;
+    updateStorage(tag: string, data: Partial<IProductStorage>): Promise<void>;
+    fetchStorage(tag: string): Promise<IProductStorage | null>;
+    fetchStorages(): Promise<Array<IProductStorage>>;
+    createNotification(data: Partial<IProductNotification>): Promise<void>;
+    updateNotification(tag: string, data: Partial<IProductNotification>): Promise<void>;
+    fetchNotification(tag: string): Promise<IProductNotification | INotificationEnv | null>;
+    fetchNotifications(): Promise<Array<IProductNotification>>;
+    createMessageBroker(data: Partial<IProductMessageBroker>): Promise<void>;
+    updateMessageBroker(tag: string, data: Partial<IProductMessageBroker>): Promise<void>;
+    fetchMessageBroker(tag: string): Promise<IProductMessageBroker | null>;
+    fetchMessageBrokers(): Promise<Array<IProductMessageBroker>>;
+    createMessageBrokerTopic(data: Partial<IProductMessageBrokerTopic>): Promise<void>;
+    updateMessageBrokerTopic(data: Partial<IProductMessageBrokerTopic>): Promise<void>;
+    fetchMessageBrokerTopic(tag: string): Promise<IProductMessageBrokerTopic | null>;
+    fetchMessageBrokerTopics(messageBrokerTag: string): Promise<Array<IProductMessageBrokerTopic>>;
+    createMessageBrokerProducer(data: Partial<IMessageBrokerProducer>): Promise<void>;
+    updateMessageBrokerProducer(data: Partial<IMessageBrokerProducer>): Promise<void>;
+    fetchMessageBrokerProducer(brokerTag: string, tag: string): Promise<IMessageBrokerProducer | null>;
+    fetchMessageBrokerProducers(messageBrokerTag: string): Promise<Array<IMessageBrokerProducer>>;
+    createMessageBrokerConsumer(data: Partial<IMessageBrokerConsumer>): Promise<void>;
+    updateMessageBrokerConsumer(data: Partial<IMessageBrokerConsumer>): Promise<void>;
+    fetchMessageBrokerConsumer(brokerTag: string, tag: string): Promise<IMessageBrokerConsumer | null>;
+    fetchMessageBrokerConsumers(messageBrokerTag: string): Promise<Array<IMessageBrokerConsumer>>;
+    createQuota(data: Partial<IProductQuota>): Promise<void>;
+    updateQuota(tag: string, data: Partial<IProductQuota>): Promise<void>;
+    fetchQuota(tag: string): Promise<IProductQuota | null>;
+    fetchQuotas(): Promise<Array<IProductQuota>>;
+    createFallback(data: Partial<IProductFallback>): Promise<void>;
+    updateFallback(tag: string, data: Partial<IProductFallback>): Promise<void>;
+    fetchFallback(tag: string): Promise<IProductFallback | null>;
+    fetchFallbacks(): Promise<Array<IProductFallback>>;
+    createNotificationMessage(data: Partial<IProductNotificationTemplate>): Promise<void>;
+    updateNotificationMessage(data: Partial<IProductNotificationTemplate>): Promise<void>;
+    fetchNotificationMessage(tag: string): Promise<IProductNotificationTemplate | null>;
+    fetchNotificationMessages(notificationTag: string): Promise<Array<IProductNotificationTemplate>>;
+    updateApp(tag: string, data: Partial<IProductApp>): Promise<void>;
+    fetchApp(tag: string): Promise<IProductApp | null>;
+    fetchApps(): Promise<Array<IProductApp>>;
+    addApp(app: IProductApp, throwErrorIfExists?: boolean): Promise<void>;
+    createFeature(data: Partial<IProductFeature>, throwErrorIfExists?: boolean): Promise<void>;
+    updateFeature(tag: string, data: Partial<IProductFeature>): Promise<void>;
+    fetchFeature(tag: string): Promise<IProductFeature | null>;
+    fetchFeatures(): Promise<Array<IProductFeature>>;
+    createDatabase(data: Partial<IProductDatabase>, throwErrorIfExists?: boolean): Promise<void>;
+    updateDatabase(tag: string, data: Partial<IProductDatabase>): Promise<void>;
+    fetchDatabase(tag: string): Promise<IProductDatabase | null>;
+    fetchDatabases(): Promise<Array<IProductDatabase>>;
+    createDatabaseAction(data: Partial<IProductDatabaseAction>, throwErrorIfExists?: boolean): Promise<void>;
+    updateDatabaseAction(data: Partial<IProductDatabaseAction>): Promise<void>;
+    fetchDatabaseAction(tag: string): Promise<IProductDatabaseAction | null>;
+    fetchDatabaseActions(databaseTag: string): Promise<Array<IProductDatabaseAction>>;
+    createDatabaseMigration(data: Partial<IProductDatabaseMigration>, throwErrorIfExists?: boolean): Promise<void>;
+    updateDatabaseMigration(data: Partial<IProductDatabaseMigration>): Promise<void>;
+    fetchDatabaseMigration(tag: string): Promise<IProductDatabaseMigration | null>;
+    fetchDatabaseMigrations(databaseTag: string): Promise<Array<IProductDatabaseMigration>>;
+    createDatabaseTrigger(data: Partial<IProductDatabaseTrigger>, throwErrorIfExists?: boolean): Promise<void>;
+    updateDatabaseTrigger(data: Partial<IProductDatabaseTrigger>): Promise<void>;
+    fetchDatabaseTrigger(tag: string): Promise<IProductDatabaseTrigger | null>;
+    fetchDatabaseTriggers(databaseTag: string): Promise<Array<IProductDatabaseTrigger>>;
+    deleteDatabaseTrigger(tag: string): Promise<void>;
+    createGraph(data: Partial<IProductGraph>, throwErrorIfExists?: boolean): Promise<void>;
+    updateGraph(tag: string, data: Partial<IProductGraph>): Promise<void>;
+    fetchGraph(tag: string): Promise<IProductGraph | null>;
+    fetchGraphs(): Promise<Array<IProductGraph>>;
+    deleteGraph(tag: string): Promise<void>;
+    createGraphAction(graphTag: string, data: any): Promise<void>;
+    updateGraphAction(graphTag: string, actionTag: string, data: any): Promise<void>;
+    fetchGraphAction(graphTag: string, actionTag: string): Promise<any | null>;
+    fetchGraphActions(graphTag: string): Promise<Array<any>>;
+    deleteGraphAction(graphTag: string, actionTag: string): Promise<void>;
+    createVectorAction(vectorTag: string, data: Partial<IProductVectorAction>): Promise<IProductVectorAction>;
+    updateVectorAction(vectorTag: string, data: Partial<IProductVectorAction>): Promise<IProductVectorAction>;
+    fetchVectorAction(vectorTag: string, actionTag: string): Promise<IProductVectorAction | null>;
+    fetchVectorActions(vectorTag: string): Promise<Array<IProductVectorAction>>;
+    deleteVectorAction(vectorTag: string, actionTag: string): Promise<void>;
+    createJob(data: Partial<IProductJobs>, throwErrorIfExists?: boolean): Promise<void>;
+    updateJob(tag: string, data: Partial<IProductJobs>): Promise<void>;
+    fetchJob(tag: string): Promise<IProductJobs | null>;
+    fetchJobs(): Promise<Array<IProductJobs>>;
+    createHealthcheck(data: Partial<IProductAppHealth>): Promise<void>;
+    updateHealthcheck(tag: string, data: Partial<IProductAppHealth>): Promise<void>;
+    fetchHealthcheck(access_tag: string, tag: string): Promise<IProductAppHealth | null>;
+    fetchHealthchecks(access_tag: string): Promise<Array<IProductAppHealth>>;
+    fetchProductHealthchecks(): Promise<Array<IProductAppHealth>>;
+    createWorkflow(data: Partial<IProductWorkflow>, throwErrorIfExists?: boolean): Promise<void>;
+    updateWorkflow(tag: string, data: Partial<IProductWorkflow>): Promise<void>;
+    fetchWorkflow(tag: string): Promise<IProductWorkflow | null>;
+    fetchWorkflows(): Promise<Array<IProductWorkflow>>;
+    deleteWorkflow(tag: string): Promise<void>;
+    createAppAccessTag(app_tag: string): Promise<IAppAccess>;
+    extractStages(input: string): Array<string | number>;
+    updateDataValidation(tag: string, update: Partial<IParsedSample>): Promise<boolean>;
+    fetchStorageFiles(filter: IFetchFilesPayload): Promise<Array<IFileURLPayload>>;
+    fetchSessionUser(ductape_user_id: string): Promise<any>;
+}
+export default class ProductsBuilderService implements IProductsBuilderService {
+    private user_id;
+    private workspace_id;
+    private workspace;
+    private private_key;
+    private workspace_private_key;
+    private product_id;
+    private token;
+    private app_id;
+    private public_key;
+    private access_key;
+    private session;
+    private product;
+    private userApi;
+    private appApi;
+    private webhooksApi;
+    private productApi;
+    private workspaceApi;
+    private inputsService;
+    private thirdPartyApps;
+    private isQuotaFallbackInput;
+    private redisClient?;
+    private queues;
+    /** In-memory cache for the current product run (cleared on init) to avoid repeated API calls in workflows */
+    private brokerCache;
+    private envCache;
+    /** Only log when DUCTAPE_DEBUG is set (avoids sync I/O cost in workflow hot path) */
+    private static _debug;
+    private _debugLog;
+    constructor({ workspace_id, public_key, user_id, token, env_type, redis_client, queues, access_key, workspace_private_key }: IBuilderInit);
+    fetchPrivateKey(): string;
+    fetchWorkspaceId(): string;
+    fetchProductId(): string;
+    createHealthcheck(data: Partial<IProductAppHealth>): Promise<void>;
+    updateHealthcheck(tag: string, data: Partial<IProductAppHealth>): Promise<void>;
+    fetchHealthcheck(access_tag: string, tag: string, throwError?: boolean): Promise<IProductAppHealth | null>;
+    fetchHealthchecks(access_tag: string, throwError?: boolean): Promise<Array<IProductAppHealth>>;
+    fetchProductHealthchecks(): Promise<Array<IProductAppHealth>>;
+    /**
+     * Create a healthcheck from a schema (e.g. from resilience health.define/create).
+     * Persists as product component so processor healthcheck workers and health.list/fetch see it.
+     * Env inputs (probe/action/workflow input) are encrypted with the product private key using
+     * SHA-256 key derivation + AES (see processor.utils encrypt/decrypt).
+     */
+    createHealthcheckFromSchema(schema: {
+        tag: string;
+        name?: string;
+        description?: string;
+        probe?: any;
+        interval: number;
+        retries: number;
+        envs: Array<{
+            slug: string;
+            input?: any;
+            [k: string]: any;
+        }>;
+        onFailure?: any;
+    }): Promise<void>;
+    updateDataValidation(selector: string, update: Partial<IParsedSample>): Promise<boolean>;
+    createProduct(data: ICreateProductsBuilder): Promise<void>;
+    initializeWorkspace(subCheck?: boolean): Promise<void>;
+    /**
+     * Get the workspace private key for secrets encryption
+     * @returns The workspace private key or null if not available
+     */
+    getWorkspacePrivateKey(): string | null;
+    initializeProduct(product_id: string): Promise<void>;
+    initializeProductByTag(tag: string): Promise<void>;
+    /**
+     * Bootstrap action - ultra-lightweight API call to fetch action data needed for processAction
+     * Replaces 5+ separate API calls: initializeProduct, fetchApp, fetchThirdPartyApp, fetchEnv, initializePricing
+     * Returns only the minimal action data needed to execute
+     */
+    bootstrapAction(params: IBootstrapActionParams): Promise<IBootstrapActionResponse>;
+    /**
+     * Apply bootstrap action result to this builder (product_id + minimal product for fetchPrivateKey).
+     * Used when bootstrap data is loaded from cache so fetchPrivateKey() and fetchProductId() work.
+     */
+    applyBootstrapActionResult(result: IBootstrapActionResponse, product_tag?: string): void;
+    bootstrapNotification(params: IBootstrapNotificationParams): Promise<IBootstrapNotificationResponse>;
+    bootstrapStorage(params: IBootstrapStorageParams): Promise<IBootstrapStorageResponse>;
+    /**
+     * Bootstrap workflow - fetch all action/notification/storage data for multiple steps in one API call
+     */
+    bootstrapWorkflow(params: Omit<IBootstrapWorkflowParams, 'workspace_id'>): Promise<Record<string, unknown>>;
+    generateExecutablePayload(params: IGenerateExecutablePayloadParams): Promise<IGenerateExecutablePayloadResponse>;
+    updateProduct(data: Partial<IProduct>): Promise<void>;
+    private createNewProduct;
+    checkIfProductExists(name: string): Promise<false | IProduct>;
+    fetchProduct(): Promise<IProduct>;
+    createSession(data: Partial<IProductSession>, throwErrorIfExists?: boolean): Promise<void>;
+    updateSession(tag: string, data: Partial<IProductSession>): Promise<void>;
+    fetchSessions(version?: string): Promise<Array<IProductSession>>;
+    fetchSession(tag: string): Promise<IProductSession | null>;
+    deleteSession(tag: string): Promise<void>;
+    createMessageBrokerTopic(data: Partial<IProductMessageBrokerTopic>, throwErrorIfExists?: boolean): Promise<void>;
+    updateMessageBrokerTopic(data: Partial<IProductMessageBrokerTopic>): Promise<void>;
+    fetchMessageBrokerTopic(tag: string, throwErrorIfExists?: boolean): Promise<IProductMessageBrokerTopic | null>;
+    fetchMessageBrokerTopics(messageBrokerTag: string): Promise<Array<IProductMessageBrokerTopic>>;
+    createMessageBrokerProducer(data: Partial<IMessageBrokerProducer>): Promise<void>;
+    updateMessageBrokerProducer(data: Partial<IMessageBrokerProducer>): Promise<void>;
+    fetchMessageBrokerProducer(brokerTag: string, tag: string): Promise<IMessageBrokerProducer | null>;
+    fetchMessageBrokerProducers(messageBrokerTag: string): Promise<Array<IMessageBrokerProducer>>;
+    createMessageBrokerConsumer(data: Partial<IMessageBrokerConsumer>): Promise<void>;
+    updateMessageBrokerConsumer(data: Partial<IMessageBrokerConsumer>): Promise<void>;
+    fetchMessageBrokerConsumer(brokerTag: string, tag: string): Promise<IMessageBrokerConsumer | null>;
+    fetchMessageBrokerConsumers(messageBrokerTag: string): Promise<Array<IMessageBrokerConsumer>>;
+    validateQuotaFallbackInputAndOutput(data: Partial<IProductQuota> | Partial<IProductFallback>, type: string): Promise<void>;
+    validateQuotaFallbackInput(option: IQuotaOptions | IFallbackOptions, input: Record<string, IFeatureInput>, type: string): Promise<void>;
+    checkKeyValuesInput(keyValues: Array<KeyValuePair>, input: Record<string, IFeatureInput>, type: string): void;
+    checkActionQuotaFallbackInput(sample: ISample, obj: any, featureInput: Record<string, IFeatureInput>, type: string): void;
+    checkFuncArgsForInputs(value: string, input: Record<string, IFeatureInput>, type: string): void;
+    checkInput(value: string, input: Record<string, IFeatureInput>, type: string): void;
+    validateQuotaFallbackOutput(option: IQuotaOptions | IFallbackOptions, pastResponse: Record<string, unknown> | null, input: Record<string, IFeatureInput>, type: string): Promise<void>;
+    checkFuncArgsForResponse(value: string, output: Record<string, unknown>, input: Record<string, IFeatureInput>, type: string): void;
+    checkResponse(value: string, output: Record<string, unknown>, input: Record<string, IFeatureInput>, type: string): void;
+    createQuota(data: Partial<IProductQuota>): Promise<void>;
+    updateQuota(tag: string, data: Partial<IProductQuota>): Promise<void>;
+    fetchQuotas(version?: string): Promise<Array<IProductQuota>>;
+    fetchQuota(tag: string, version?: string): Promise<IProductQuota | null>;
+    deleteQuota(tag: string): Promise<void>;
+    createFallback(data: Partial<IProductFallback>): Promise<void>;
+    updateFallback(tag: string, data: Partial<IProductFallback>): Promise<void>;
+    fetchFallbacks(version?: string): Promise<Array<IProductFallback>>;
+    fetchFallback(tag: string, version?: string): Promise<IProductFallback | null>;
+    deleteFallback(tag: string): Promise<void>;
+    createEnv(data: IProductEnv, throwErrorIfExists?: boolean): Promise<void>;
+    updateEnv(slug: string, data: Partial<IProductEnv>): Promise<void>;
+    fetchEnvs(version?: string): Promise<Array<IProductEnv>>;
+    fetchEnv(slug: string): Promise<IProductEnv | null>;
+    deleteEnv(slug: string): Promise<void>;
+    createMessageBroker(data: Partial<IProductMessageBroker>, throwErrorIfExists?: boolean): Promise<void>;
+    updateMessageBroker(tag: string, data: Partial<IProductMessageBroker>): Promise<void>;
+    fetchMessageBrokers(version?: string): Promise<Array<IProductMessageBroker>>;
+    fetchMessageBroker(tag: string, version?: string): Promise<IProductMessageBroker | null>;
+    deleteMessageBroker(tag: string): Promise<void>;
+    fetchStorageFiles(filter: IFetchFilesPayload): Promise<Array<IFileURLPayload>>;
+    fetchSessionUsers(filter: IFetchUsersPayload): Promise<Array<IFileURLPayload>>;
+    createStorage(data: Partial<IProductStorage>, throwErrorIfExists?: boolean): Promise<void>;
+    updateStorage(tag: string, data: Partial<IProductStorage>): Promise<void>;
+    fetchStorages(version?: string): Promise<Array<IProductStorage>>;
+    fetchStorage(tag: string, version?: string): Promise<IProductStorage | null>;
+    deleteStorage(tag: string): Promise<void>;
+    /**
+     * Create a new vector database configuration
+     * @param data Vector database configuration
+     * @param throwErrorIfExists Whether to throw error if vector config already exists
+     */
+    createVector(data: Partial<IProductVector>, throwErrorIfExists?: boolean): Promise<void>;
+    /**
+     * Update an existing vector database configuration
+     * @param tag Vector config tag
+     * @param data Updated vector configuration
+     */
+    updateVector(tag: string, data: Partial<IProductVector>): Promise<void>;
+    /**
+     * Fetch all vector database configurations
+     * @param version Optional version
+     */
+    fetchVectors(version?: string): Promise<Array<IProductVector>>;
+    /**
+     * Fetch a specific vector database configuration by tag
+     * @param tag Vector config tag
+     * @param version Optional version
+     */
+    fetchVector(tag: string, version?: string): Promise<IProductVector | null>;
+    /**
+     * Delete a vector database configuration
+     * @param tag Vector config tag
+     */
+    deleteVector(tag: string): Promise<void>;
+    /**
+     * Create a new vector action
+     * @param vectorTag Vector database tag
+     * @param data Vector action data
+     * @returns Created vector action
+     */
+    createVectorAction(vectorTag: string, data: Partial<IProductVectorAction>): Promise<IProductVectorAction>;
+    /**
+     * Update an existing vector action
+     * @param vectorTag Vector database tag
+     * @param data Vector action update data (must include tag)
+     * @returns Updated vector action
+     */
+    updateVectorAction(vectorTag: string, data: Partial<IProductVectorAction>): Promise<IProductVectorAction>;
+    /**
+     * Fetch a specific vector action
+     * @param vectorTag Vector database tag
+     * @param actionTag Action tag
+     * @returns Vector action or null
+     */
+    fetchVectorAction(vectorTag: string, actionTag: string): Promise<IProductVectorAction | null>;
+    /**
+     * Fetch all vector actions for a vector database
+     * @param vectorTag Vector database tag
+     * @returns Array of vector actions
+     */
+    fetchVectorActions(vectorTag: string): Promise<Array<IProductVectorAction>>;
+    /**
+     * Delete a vector action
+     * @param vectorTag Vector database tag
+     * @param actionTag Action tag to delete
+     */
+    deleteVectorAction(vectorTag: string, actionTag: string): Promise<void>;
+    /**
+     * Create a new agent configuration
+     * @param data Agent configuration data
+     * @param throwErrorIfExists Whether to throw an error if agent already exists
+     */
+    createAgent(data: Partial<IProductAgent>, throwErrorIfExists?: boolean): Promise<void>;
+    /**
+     * Update an existing agent configuration
+     * @param tag Agent tag
+     * @param data Updated agent configuration
+     */
+    updateAgent(tag: string, data: Partial<IProductAgent>): Promise<void>;
+    /**
+     * Fetch all agent configurations
+     * @param version Optional version
+     */
+    fetchAgents(version?: string): Promise<Array<IProductAgent>>;
+    /**
+     * Fetch a specific agent configuration by tag
+     * @param tag Agent tag
+     * @param version Optional version
+     */
+    fetchAgent(tag: string, version?: string): Promise<IProductAgent | null>;
+    /**
+     * Delete an agent configuration
+     * @param tag Agent tag
+     */
+    deleteAgent(tag: string): Promise<void>;
+    /**
+     * Create a new LLM model configuration
+     * API keys are automatically encrypted using the product's private key
+     * @param data LLM model configuration
+     * @param throwErrorIfExists Whether to throw error if model already exists
+     */
+    createModel(data: Partial<IProductLLMModel>, throwErrorIfExists?: boolean): Promise<void>;
+    /**
+     * Update an existing LLM model configuration
+     * @param tag Model tag
+     * @param data Updated model configuration
+     */
+    updateModel(tag: string, data: Partial<IProductLLMModel>): Promise<void>;
+    /**
+     * Fetch all LLM model configurations
+     * @param version Optional version
+     */
+    fetchModels(version?: string): Promise<Array<IProductLLMModel>>;
+    /**
+     * Fetch a specific LLM model configuration by tag
+     * @param tag Model tag
+     * @param version Optional version
+     */
+    fetchModel(tag: string, version?: string): Promise<IProductLLMModel | null>;
+    /**
+     * Delete an LLM model configuration
+     * @param tag Model tag
+     */
+    deleteModel(tag: string): Promise<void>;
+    private validateAppData;
+    private validateVariablesSchema;
+    private validateVariablesValues;
+    private validateAppEnvs;
+    private validateAppAuth;
+    createAppAccessTag(app_tag: string): Promise<IAppAccess>;
+    addApp(app: IProductApp, throwErrorIfExists?: boolean): Promise<void>;
+    fetchAppWebhooks(access_tag: string): Promise<Array<IAppWebhook>>;
+    updateApp(access_tag: string, data: Partial<IProductApp>): Promise<void>;
+    fetchApps(): Promise<Array<IProductApp>>;
+    fetchApp(tag: string, throwErrorIfExists?: boolean): Promise<IProductApp | null>;
+    deleteApp(tag: string): Promise<void>;
+    createFunction(data: Partial<IProductFunction>, throwErrorIfExists?: boolean): Promise<void>;
+    updateFunction(tag: string, data: Partial<IProductFunction>): Promise<void>;
+    fetchFunctions(version?: string): Promise<Array<IProductFunction>>;
+    fetchFunction(tag: string, version?: string): Promise<IProductFunction | null>;
+    deleteFunction(tag: string): Promise<void>;
+    createCache(data: Partial<IProductCache>, throwErrorIfExists?: boolean): Promise<void>;
+    updateCache(tag: string, data: Partial<IProductCache>): Promise<void>;
+    fetchCaches(version?: string): Promise<Array<IProductCache>>;
+    fetchCache(tag: string, version?: string): Promise<IProductCache | null>;
+    deleteCache(tag: string): Promise<void>;
+    createNotification(data: Partial<IProductNotification>, throwErrorIfExists?: boolean): Promise<void>;
+    createNotificationMessage(data: Partial<IProductNotificationTemplate>, throwErrorIfExists?: boolean): Promise<void>;
+    fetchNotificationMessage(tag: string, throwErrorIfExists?: boolean): Promise<IProductNotificationTemplate | null>;
+    fetchNotificationMessages(notificationTag: string, throwErrorIfExists?: boolean): Promise<Array<IProductNotificationTemplate>>;
+    updateNotificationMessage(data: Partial<IProductNotificationTemplate>): Promise<void>;
+    updateNotification(tag: string, data: Partial<IProductNotification>): Promise<void>;
+    fetchNotifications(version?: string): Promise<Array<IProductNotification>>;
+    fetchNotification(tag: string, version?: string): Promise<IProductNotification | null>;
+    /**
+     * Decrypt notification env channel configs (push_notifications, emails, callbacks, sms).
+     * @param notification - notification with possibly encrypted env configs
+     * @param privateKey - product private key; when omitted uses this.product.private_key (e.g. from fetch)
+     */
+    private decryptNotificationChannelConfigs;
+    deleteNotification(tag: string): Promise<void>;
+    private validateFeatureSequence;
+    private validateUniqueEventTags;
+    private validateFeatureData;
+    validateSequenceParents(parents: Array<string>, sequence_index: number, sequence: Array<IFeatureSequence>): void;
+    validateSequenceInputParents(parent: string, sequence_index: number, sequence: Array<IFeatureSequence>): void;
+    private checkAndValidateActionDataInput;
+    private checkAndValidateFunctionDataInput;
+    private checkAndValidateDBActionDataInput;
+    private checkAndValidateFeatureDataInput;
+    private checkAndValidateNotificationDataInput;
+    private checkAndValidatePublishDataInput;
+    private checkAndValidateStorageDataInput;
+    private checkAndValidateJobDataInput;
+    private checkAndValidateFallbackDataInput;
+    private validateEvent;
+    validateDBActionDataInput(data: Partial<IProductFeature>, action: {
+        filterData: IParsedSample[];
+        data: IParsedSample[];
+        template: string | object;
+        filter: string | object;
+    }, event_input: IDbActionRequest, event_index: number, sequence_index: number): Promise<void>;
+    validateFeatureDataInput(data: Partial<IProductFeature>, featureInput: Record<string, IFeatureInput>, input: Record<string, unknown>, event_index: number, sequence_index: number): Promise<void>;
+    validateNotificationDataInput(data: Partial<IProductFeature>, action: {
+        callback: IParsedSample[];
+        notification: IParsedSample[];
+        email: IParsedSample[];
+        sms: IParsedSample[];
+    }, event_input: INotificationRequest, event_index: number, sequence_index: number): Promise<void>;
+    validateActionDataInput(data: Partial<IProductFeature>, action: IAppAction, event_input: Partial<IActionRequest>, event_index: number, sequence_index: number): Promise<void>;
+    validateActionInputData(data: IActionDataParserInput, skipSample?: boolean, option?: boolean, optionIndex?: number): Promise<void>;
+    validateConditional(event: IFeatureEvent, feature: Partial<IProductFeature>, sequence_index: number, event_index: number): void;
+    parseActionEventInput(data: IParseActionEventInput): Promise<void>;
+    parseInputString(payload: IParseInputStringInput, meta: IParseInputStringMetaData): Promise<void>;
+    compareInputWithExpectedInput(datapoint: IParsedSample, found_input: IParsedSample, value: string): void;
+    extractStages(input: string): Array<string | number>;
+    fetchSequenceEvent(sequence: IFeatureSequence, event: string): IFeatureEvent | null;
+    fetchPriorSequence(meta: IParseInputStringMetaData, stage: string): IFeatureSequence;
+    validateActionKeyPlacement(data: IParseActionEventInput): IParsedSample;
+    fetchThirdPartyAppByAccessTag(access_tag: string): Promise<IApp & IVersion>;
+    fetchThirdPartyAppActionByTag(actions: Array<IAppAction>, action_tag: string): IAppAction;
+    createFeature(data: Partial<IProductFeature>, throwErrorIfExists?: boolean): Promise<void>;
+    updateFeature(tag: string, data: Partial<IProductFeature>): Promise<void>;
+    fetchFeatures(): Promise<Array<IProductFeature>>;
+    fetchFeature(tag: string): Promise<IProductFeature | null>;
+    deleteFeature(tag: string): Promise<void>;
+    createDatabase(data: Partial<IProductDatabase>, throwErrorIfExists?: boolean): Promise<void>;
+    updateDatabase(tag: string, data: Partial<IProductDatabase>): Promise<void>;
+    fetchDatabases(): Promise<Array<IProductDatabase>>;
+    fetchDatabase(tag: string): Promise<IProductDatabase | null>;
+    deleteDatabase(tag: string): Promise<void>;
+    createGraph(data: Partial<IProductGraph>, throwErrorIfExists?: boolean): Promise<void>;
+    updateGraph(tag: string, data: Partial<IProductGraph>): Promise<void>;
+    fetchGraphs(): Promise<Array<IProductGraph>>;
+    fetchGraph(tag: string): Promise<IProductGraph | null>;
+    deleteGraph(tag: string): Promise<void>;
+    createGraphAction(graphTag: string, data: any): Promise<void>;
+    updateGraphAction(graphTag: string, actionTag: string, data: any): Promise<void>;
+    fetchGraphAction(graphTag: string, actionTag: string): Promise<any | null>;
+    fetchGraphActions(graphTag: string): Promise<Array<any>>;
+    deleteGraphAction(graphTag: string, actionTag: string): Promise<void>;
+    createDatabaseAction(data: Partial<IProductDatabaseAction>, throwErrorIfExists?: boolean): Promise<void>;
+    fetchDatabaseAction(tag: string, throwErrorIfExists?: boolean): Promise<IProductDatabaseAction | null>;
+    updateDatabaseAction(data: Partial<IProductDatabaseAction>): Promise<void>;
+    fetchDatabaseActions(databaseTag: string): Promise<Array<IProductDatabaseAction>>;
+    deleteDatabaseAction(tag: string): Promise<void>;
+    createDatabaseMigration(data: Partial<IProductDatabaseMigration>, throwErrorIfExists?: boolean): Promise<void>;
+    /**
+     * Process migration operations - handles both string and object formats
+     * Strings are passed through as-is (raw SQL/CQL)
+     * Objects are serialized for storage and executed by the migration engine
+     */
+    private processMigrationOperations;
+    updateDatabaseMigration(data: Partial<IProductDatabaseMigration>): Promise<void>;
+    fetchDatabaseMigration(tag: string, throwError?: boolean): Promise<IProductDatabaseMigration | null>;
+    fetchDatabaseMigrations(databaseTag: string): Promise<Array<IProductDatabaseMigration>>;
+    deleteDatabaseMigration(tag: string): Promise<void>;
+    createDatabaseTrigger(data: Partial<IProductDatabaseTrigger>, throwErrorIfExists?: boolean): Promise<void>;
+    updateDatabaseTrigger(data: Partial<IProductDatabaseTrigger>): Promise<void>;
+    fetchDatabaseTrigger(tag: string, throwError?: boolean): Promise<IProductDatabaseTrigger | null>;
+    fetchDatabaseTriggers(databaseTag: string): Promise<Array<IProductDatabaseTrigger>>;
+    deleteDatabaseTrigger(tag: string): Promise<void>;
+    validateJobEvent(data: Partial<IProductJobs>): Promise<void>;
+    createJob(data: Partial<IProductJobs>, throwErrorIfExists?: boolean): Promise<void>;
+    updateJob(tag: string, data: Partial<IProductJobs>): Promise<void>;
+    fetchJobs(): Promise<Array<IProductJobs>>;
+    fetchJob(tag: string): Promise<IProductJobs | null>;
+    deleteJob(tag: string): Promise<void>;
+    createWorkflow(data: Partial<IProductWorkflow>, throwErrorIfExists?: boolean): Promise<void>;
+    updateWorkflow(tag: string, data: Partial<IProductWorkflow>): Promise<void>;
+    fetchWorkflows(): Promise<Array<IProductWorkflow>>;
+    fetchWorkflow(tag: string): Promise<IProductWorkflow | null>;
+    deleteWorkflow(tag: string): Promise<void>;
+    private getUserAccess;
+    fetchSessionUser(ductape_user_id: string): Promise<any>;
+    /**
+     * Process storage config to store sensitive credentials as secrets
+     * Format: STORAGE_{PRODUCT}_{STORAGE_TAG}_{ENV}_{KEY}
+     *
+     * Product parsing: split by ":", select first element
+     * Storage tag: replace "-" with "_"
+     */
+    private processStorageConfigSecrets;
+    /**
+     * Process message broker config to store sensitive credentials as secrets
+     * Format: BROKER_{PRODUCT}_{BROKER_TAG}_{ENV}_{KEY}
+     *
+     * Product parsing: split by ":", select first element
+     * Broker tag: replace "-" with "_"
+     */
+    private processMessageBrokerConfigSecrets;
+    /**
+     * Process notification environment config to store sensitive credentials as secrets
+     * Format: NOTIFIER_{PRODUCT}_{NOTIFIER_TAG}_{ENV}_{KEY}
+     *
+     * Product parsing: split by ":", select first element
+     * Notifier tag: replace "-" with "_"
+     */
+    private processNotificationEnvSecrets;
+    /**
+     * Store graph connection URL as a secret
+     * Format: GRAPH_{PRODUCT}_{GRAPH_TAG}_{ENV}_URL
+     */
+    private storeGraphConnectionUrlAsSecret;
+    /**
+     * Generate a secret key for vector configuration field
+     * Format: VECTOR_{PRODUCT}_{ASSET_TAG}_{ENV}_{KEY}
+     *
+     * Where:
+     * - PRODUCT = productTag.split('.')[1] (second part after workspace)
+     * - ASSET_TAG = if vectorTag starts with same workspace prefix, use second part; otherwise sanitize full tag
+     * - All parts are automatically capitalized
+     */
+    private generateVectorSecretKey;
+    /**
+     * Store a vector field value as a secret if it exists and is not already a secret reference
+     * @returns The secret reference if stored, or the original value
+     */
+    private storeVectorFieldAsSecret;
+    private storeVectorApiKeyAsSecret;
+    private storeVectorEndpointAsSecret;
+    /**
+     * Store LLM model API key as a secret
+     * Format: MODEL_{PRODUCT}_{MODEL_TAG}_{ENV}_API_KEY
+     */
+    private storeModelApiKeyAsSecret;
+}