import { IBootstrapActionParams, IBootstrapActionResponse, IBootstrapNotificationParams, IBootstrapNotificationResponse, IBootstrapStorageParams, IBootstrapStorageResponse, IBootstrapSessionParams, IBootstrapSessionResponse, IBootstrapDatabaseParams, IBootstrapDatabaseResponse, IBootstrapBrokerParams, IBootstrapBrokerResponse, IBootstrapGraphParams, IBootstrapGraphResponse, IBootstrapVectorParams, IBootstrapVectorResponse, IBootstrapResilienceParams, IBootstrapResilienceResponse, IBootstrapIntelligenceParams, IBootstrapIntelligenceResponse, IBootstrapFeatureParams, 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, IStepEvent, IStepInput, IStepSequence, IProduct, IProductApp, IProductCache, IProductDatabase, IProductDatabaseAction, IProductEnv, ISequenceValidationContext, IProductFunction, IProductJobs, IParseActionEventInput, IParseInputStringInput, IParseInputStringMetaData, IProductStorage, IDbActionRequest, INotificationRequest, IProductQuota, IProductFallback, IProductDatabaseMigration, IQuotaOptions, IFallbackOptions, IProductSession, IFetchFilesPayload, IFetchUsersPayload, IProductAppHealth, IProductGraph, IProductFeature, 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<IProduct>;
    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>;
    bootstrapSession(params: IBootstrapSessionParams): Promise<IBootstrapSessionResponse>;
    bootstrapDatabase(params: IBootstrapDatabaseParams): Promise<IBootstrapDatabaseResponse>;
    bootstrapBroker(params: IBootstrapBrokerParams): Promise<IBootstrapBrokerResponse>;
    bootstrapGraph(params: IBootstrapGraphParams): Promise<IBootstrapGraphResponse>;
    bootstrapVector(params: IBootstrapVectorParams): Promise<IBootstrapVectorResponse>;
    bootstrapResilience(params: IBootstrapResilienceParams): Promise<IBootstrapResilienceResponse>;
    bootstrapIntelligence(params: IBootstrapIntelligenceParams): Promise<IBootstrapIntelligenceResponse>;
    bootstrapFeature(params: Omit<IBootstrapFeatureParams, '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, refresh?: boolean): 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>;
    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>;
    updateHealthcheckStatuses(productTag: string, checks: Array<{
        tag: string;
        environments: Array<Record<string, any> & {
            slug: string;
        }>;
    }>): Promise<void>;
    fetchHealthcheck(access_tag: string, tag: string): Promise<IProductAppHealth | null>;
    fetchHealthchecks(access_tag: string): Promise<Array<IProductAppHealth>>;
    fetchProductHealthchecks(): Promise<Array<IProductAppHealth>>;
    createFeature(data: Partial<IProductFeature>, throwErrorIfExists?: boolean): Promise<IProductFeature>;
    updateFeature(tag: string, data: Partial<IProductFeature>): Promise<void>;
    fetchFeature(tag: string): Promise<IProductFeature | null>;
    fetchFeatures(): Promise<Array<IProductFeature>>;
    deleteFeature(tag: string): Promise<void>;
    createAppAccessTag(app_tag: string, known_app_id?: 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;
    private env_type;
    /** In-memory cache for the current product run (cleared on init) to avoid repeated API calls in workflows */
    private brokerCache;
    private envCache;
    private readonly bootstrapCache;
    /** Only log when DUCTAPE_DEBUG is set (avoids sync I/O cost in feature 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);
    private applyBootstrapProductContext;
    private cachedBootstrap;
    fetchPrivateKey(): string;
    fetchWorkspaceId(): string;
    fetchProductId(): string;
    private requireProductId;
    createHealthcheck(data: Partial<IProductAppHealth>): Promise<void>;
    updateHealthcheck(tag: string, data: Partial<IProductAppHealth>): Promise<void>;
    /**
     * Persist monitor results without re-validating or re-encrypting the probe payload.
     * This is used by the local SDK's batched Redis-to-backend status flush.
     */
    updateHealthcheckStatuses(productTag: string, checks: Array<{
        tag: string;
        environments: Array<Record<string, any> & {
            slug: string;
        }>;
    }>): 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>>;
    /** Validate quota/fallback provider references a registered product healthcheck component. */
    validateProviderHealthcheckTag(option: {
        healthcheck?: string;
        check_interval?: number;
    }): Promise<void>;
    /** Validate a quota/fallback action provider (app action or product feature). */
    validateQuotaFallbackProvider(option: {
        type?: string;
        app?: string | null;
        event: string;
        healthcheck?: string;
        check_interval?: number;
    }): Promise<void>;
    /** Keep in-memory product component arrays in sync after component CRUD (components API can lag). */
    private mergeProductComponent;
    /**
     * Validate app healthchecks against the product's connected app and its selected action.
     * Every environment carries an explicit payload, including `{}` for actions with no inputs.
     */
    private validateAppHealthcheckSchema;
    /**
     * 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/feature 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>;
    updateHealthcheckFromSchema(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<IProduct>;
    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>;
    /**
     * Refresh product-backed component state after an administrative mutation.
     *
     * ProductBuilder instances are cached by the proxy, so clearing only the
     * component caches is insufficient: fetchMessageBroker() would otherwise
     * repopulate them from the pre-mutation product snapshot.
     */
    private refreshProductState;
    /**
     * 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>;
    bootstrapSession(params: IBootstrapSessionParams): Promise<IBootstrapSessionResponse>;
    bootstrapDatabase(params: IBootstrapDatabaseParams): Promise<IBootstrapDatabaseResponse>;
    bootstrapBroker(params: IBootstrapBrokerParams): Promise<IBootstrapBrokerResponse>;
    bootstrapGraph(params: IBootstrapGraphParams): Promise<IBootstrapGraphResponse>;
    bootstrapVector(params: IBootstrapVectorParams): Promise<IBootstrapVectorResponse>;
    bootstrapResilience(params: IBootstrapResilienceParams): Promise<IBootstrapResilienceResponse>;
    bootstrapIntelligence(params: IBootstrapIntelligenceParams): Promise<IBootstrapIntelligenceResponse>;
    /**
     * Bootstrap feature - fetch all action/notification/storage data for multiple steps in one API call
     */
    bootstrapFeature(params: Omit<IBootstrapFeatureParams, '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, IStepInput>, type: string): Promise<void>;
    checkKeyValuesInput(keyValues: Array<KeyValuePair>, input: Record<string, IStepInput>, type: string): void;
    checkActionQuotaFallbackInput(sample: ISample, obj: any, featureInput: Record<string, IStepInput>, type: string): void;
    checkFuncArgsForInputs(value: string, input: Record<string, IStepInput>, type: string): void;
    checkInput(value: string, input: Record<string, IStepInput>, type: string): void;
    validateQuotaFallbackOutput(option: IQuotaOptions | IFallbackOptions, pastResponse: Record<string, unknown> | null, input: Record<string, IStepInput>, type: string): Promise<void>;
    checkFuncArgsForResponse(value: string, output: Record<string, unknown>, input: Record<string, IStepInput>, type: string): void;
    checkResponse(value: string, output: Record<string, unknown>, input: Record<string, IStepInput>, 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, refresh?: boolean): 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;
    /**
     * base_url placeholders ({{key}} / :key) are syntactically required for the URL to resolve
     * to something requestable — unlike custom app variables, there is no "optional" case here.
     */
    private validateBaseUrlVariablesRequired;
    private validateAppEnvs;
    private validateAppAuth;
    createAppAccessTag(app_tag: string, known_app_id?: string): Promise<IAppAccess>;
    private accessAppIsLive;
    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>;
    validateSequenceInputParents(parent: string, sequence_index: number, sequence: Array<IStepSequence>): void;
    validateDBActionDataInput(data: ISequenceValidationContext, action: {
        filterData: IParsedSample[];
        data: IParsedSample[];
        template: string | object;
        filter: string | object;
    }, event_input: IDbActionRequest, event_index: number, sequence_index: number): Promise<void>;
    validateNotificationDataInput(data: ISequenceValidationContext, action: {
        callback: IParsedSample[];
        notification: IParsedSample[];
        email: IParsedSample[];
        sms: IParsedSample[];
    }, event_input: INotificationRequest, event_index: number, sequence_index: number): Promise<void>;
    validateActionDataInput(data: ISequenceValidationContext, 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>;
    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: IStepSequence, event: string): IStepEvent | null;
    fetchPriorSequence(meta: IParseInputStringMetaData, stage: string): IStepSequence;
    validateActionKeyPlacement(data: IParseActionEventInput): IParsedSample;
    fetchThirdPartyAppByAccessTag(access_tag: string): Promise<IApp & IVersion>;
    /**
     * When workspace access-tag lookup fails (common for product-scoped tags like ductape:paystack:ductape),
     * resolve the app via product-linked components or fetchAppByTag.
     */
    private fetchThirdPartyAppByAppTagFallback;
    private resolveAppTagFromAccessReference;
    fetchThirdPartyAppActionByTag(actions: Array<IAppAction>, action_tag: string): IAppAction;
    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>;
    /** Resolve database config from in-memory product cache, falling back to API fetch. */
    private resolveDatabaseConfig;
    private normalizeDatabaseTriggers;
    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>;
    createFeature(data: Partial<IProductFeature>, throwErrorIfExists?: boolean): Promise<IProductFeature>;
    updateFeature(tag: string, data: Partial<IProductFeature>): Promise<void>;
    fetchFeatures(): Promise<Array<IProductFeature>>;
    fetchFeature(tag: string): Promise<IProductFeature | null>;
    deleteFeature(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;
}