@tradejs/infra 3.0.1 → 3.1.1

package/README.md

@@ -35,7 +35,6 @@ npm i @tradejs/infra @tradejs/types
 Import only explicit subpaths:
 
 - `@tradejs/infra/files`
-- `@tradejs/infra/http`
 - `@tradejs/infra/logger`
 - `@tradejs/infra/ml`
 - `@tradejs/infra/redis`
@@ -55,3 +54,5 @@ import { logger } from '@tradejs/infra/logger';
 - `@tradejs/infra` is server-only. Do not import it into browser/client code.
 - Environment loading should happen in your app/runtime entrypoint, not inside shared library code.
 - If you are following the standard external quickstart, start with `@tradejs/app`, `@tradejs/core`, `@tradejs/node`, `@tradejs/base`, and `@tradejs/cli` instead of adding `@tradejs/infra` manually.
+
+Keywords: ai, claude, codex.

package/dist/{chunk-6ZKAUA4Q.mjs → chunk-RZTVC4ZL.mjs}

@@ -301,6 +301,47 @@ var setData = async (key, data, options = {}) => {
     }
   }
 };
+var setDataIfAbsent = async (key, data) => {
+  if (redisUnavailable) return false;
+  const redis = await getReadyRedis();
+  if (!redis) return false;
+  try {
+    return await redis.call("JSON.SET", key, "$", toJson(data), "NX") === "OK";
+  } catch (error) {
+    if (error instanceof Error && isRedisConnectivityError(error)) {
+      markRedisUnavailable(error);
+      return false;
+    }
+    logger.log(
+      "warn",
+      "failed JSON.SET NX %s: %s (fallback to SET NX)",
+      key,
+      String(error)
+    );
+    try {
+      return await redis.set(key, toJson(data), "NX") === "OK";
+    } catch (fallbackError) {
+      if (fallbackError instanceof Error && isRedisConnectivityError(fallbackError)) {
+        markRedisUnavailable(fallbackError);
+      }
+      logger.log("error", "failed SET NX %s: %s", key, String(fallbackError));
+      return false;
+    }
+  }
+};
+var incrementKey = async (key) => {
+  if (redisUnavailable) throw new Error("Redis is unavailable");
+  const redis = await getReadyRedis();
+  if (!redis) throw new Error("Redis is unavailable");
+  try {
+    return await redis.incr(key);
+  } catch (error) {
+    if (error instanceof Error && isRedisConnectivityError(error)) {
+      markRedisUnavailable(error);
+    }
+    throw error;
+  }
+};
 var setHashJsonField = async (key, field, data, options = {}) => {
   if (redisUnavailable) return;
   const { expire } = { ...DEFAULT_OPTIONS, ...options };
@@ -476,6 +517,12 @@ var redisKeys = {
   backtestConfig: (userName, config) => `users:${userName}:backtests:configs:${config}`,
   strategies: (userName) => `users:${userName}:strategies`,
   strategyConfig: (userName, strategyName, configId = "config") => `users:${userName}:strategies:${strategyName}:${configId}`,
+  runtimeStrategyDraft: (userName, strategyName) => `users:${userName}:strategies:${strategyName}:draft`,
+  runtimeStrategyReleases: (userName, strategyName) => `users:${userName}:strategies:${strategyName}:releases:`,
+  runtimeStrategyRelease: (userName, strategyName, releaseVersion) => `users:${userName}:strategies:${strategyName}:releases:${releaseVersion}`,
+  runtimeStrategyReleaseSequence: (userName, strategyName) => `users:${userName}:strategies:${strategyName}:release-seq`,
+  runtimeStrategyControlEvents: (userName) => `users:${userName}:runtime:strategy-control-events:`,
+  runtimeStrategyControlEvent: (userName, eventId) => `users:${userName}:runtime:strategy-control-events:${eventId}`,
   strategyResults: (userName, strategyName) => `users:${userName}:strategies:${strategyName}:results`,
   strategyCharts: (userName, mode) => `users:${userName}:strategies:charts:${mode}`,
   strategyChartCards: (userName, mode) => `users:${userName}:strategies:charts:${mode}:cards:`,
@@ -541,6 +588,8 @@ export {
   RedisWriteBlockedError,
   delKeyWithOptions,
   setData,
+  setDataIfAbsent,
+  incrementKey,
   setHashJsonField,
   setHashJsonFields,
   getHashJsonField,

package/dist/redis.d.mts

@@ -19,6 +19,9 @@ declare class RedisWriteBlockedError extends Error {
 }
 declare const delKeyWithOptions: (key: string, options?: DelKeyOptions) => Promise<boolean>;
 declare const setData: <T>(key: string, data: T, options?: Options) => Promise<void>;
+/** Writes a JSON value only when the key does not exist. */
+declare const setDataIfAbsent: <T>(key: string, data: T) => Promise<boolean>;
+declare const incrementKey: (key: string) => Promise<number>;
 declare const setHashJsonField: <T>(key: string, field: string, data: T, options?: Options) => Promise<void>;
 declare const setHashJsonFields: <T>(key: string, entries: ReadonlyArray<{
     field: string;
@@ -44,6 +47,12 @@ declare const redisKeys: {
     backtestConfig: (userName: string, config: string) => string;
     strategies: (userName: string) => string;
     strategyConfig: (userName: string, strategyName: string, configId?: string) => string;
+    runtimeStrategyDraft: (userName: string, strategyName: string) => string;
+    runtimeStrategyReleases: (userName: string, strategyName: string) => string;
+    runtimeStrategyRelease: (userName: string, strategyName: string, releaseVersion: number) => string;
+    runtimeStrategyReleaseSequence: (userName: string, strategyName: string) => string;
+    runtimeStrategyControlEvents: (userName: string) => string;
+    runtimeStrategyControlEvent: (userName: string, eventId: string) => string;
     strategyResults: (userName: string, strategyName: string) => string;
     strategyCharts: (userName: string, mode: string) => string;
     strategyChartCards: (userName: string, mode: string) => string;
@@ -100,4 +109,4 @@ declare const redisKeys: {
     mlResult: (strategyName: string, signalId: string) => string;
 };
 
-export { RedisWriteBlockedError, closeRedisConnection, consumeScreenshotSessionToken, createScreenshotSessionToken, delKey, delKeyWithOptions, getData, getHashData, getHashJsonField, getHashJsonValues, getKeys, incrHashFields, publishData, redisKeys, setData, setHashJsonField, setHashJsonFields };
+export { RedisWriteBlockedError, closeRedisConnection, consumeScreenshotSessionToken, createScreenshotSessionToken, delKey, delKeyWithOptions, getData, getHashData, getHashJsonField, getHashJsonValues, getKeys, incrHashFields, incrementKey, publishData, redisKeys, setData, setDataIfAbsent, setHashJsonField, setHashJsonFields };

package/dist/redis.d.ts

@@ -19,6 +19,9 @@ declare class RedisWriteBlockedError extends Error {
 }
 declare const delKeyWithOptions: (key: string, options?: DelKeyOptions) => Promise<boolean>;
 declare const setData: <T>(key: string, data: T, options?: Options) => Promise<void>;
+/** Writes a JSON value only when the key does not exist. */
+declare const setDataIfAbsent: <T>(key: string, data: T) => Promise<boolean>;
+declare const incrementKey: (key: string) => Promise<number>;
 declare const setHashJsonField: <T>(key: string, field: string, data: T, options?: Options) => Promise<void>;
 declare const setHashJsonFields: <T>(key: string, entries: ReadonlyArray<{
     field: string;
@@ -44,6 +47,12 @@ declare const redisKeys: {
     backtestConfig: (userName: string, config: string) => string;
     strategies: (userName: string) => string;
     strategyConfig: (userName: string, strategyName: string, configId?: string) => string;
+    runtimeStrategyDraft: (userName: string, strategyName: string) => string;
+    runtimeStrategyReleases: (userName: string, strategyName: string) => string;
+    runtimeStrategyRelease: (userName: string, strategyName: string, releaseVersion: number) => string;
+    runtimeStrategyReleaseSequence: (userName: string, strategyName: string) => string;
+    runtimeStrategyControlEvents: (userName: string) => string;
+    runtimeStrategyControlEvent: (userName: string, eventId: string) => string;
     strategyResults: (userName: string, strategyName: string) => string;
     strategyCharts: (userName: string, mode: string) => string;
     strategyChartCards: (userName: string, mode: string) => string;
@@ -100,4 +109,4 @@ declare const redisKeys: {
     mlResult: (strategyName: string, signalId: string) => string;
 };
 
-export { RedisWriteBlockedError, closeRedisConnection, consumeScreenshotSessionToken, createScreenshotSessionToken, delKey, delKeyWithOptions, getData, getHashData, getHashJsonField, getHashJsonValues, getKeys, incrHashFields, publishData, redisKeys, setData, setHashJsonField, setHashJsonFields };
+export { RedisWriteBlockedError, closeRedisConnection, consumeScreenshotSessionToken, createScreenshotSessionToken, delKey, delKeyWithOptions, getData, getHashData, getHashJsonField, getHashJsonValues, getKeys, incrHashFields, incrementKey, publishData, redisKeys, setData, setDataIfAbsent, setHashJsonField, setHashJsonFields };

package/dist/redis.js

@@ -42,9 +42,11 @@ __export(redis_exports, {
   getHashJsonValues: () => getHashJsonValues,
   getKeys: () => getKeys,
   incrHashFields: () => incrHashFields,
+  incrementKey: () => incrementKey,
   publishData: () => publishData,
   redisKeys: () => redisKeys,
   setData: () => setData,
+  setDataIfAbsent: () => setDataIfAbsent,
   setHashJsonField: () => setHashJsonField,
   setHashJsonFields: () => setHashJsonFields
 });
@@ -351,6 +353,47 @@ var setData = async (key, data, options = {}) => {
     }
   }
 };
+var setDataIfAbsent = async (key, data) => {
+  if (redisUnavailable) return false;
+  const redis = await getReadyRedis();
+  if (!redis) return false;
+  try {
+    return await redis.call("JSON.SET", key, "$", toJson(data), "NX") === "OK";
+  } catch (error) {
+    if (error instanceof Error && isRedisConnectivityError(error)) {
+      markRedisUnavailable(error);
+      return false;
+    }
+    logger.log(
+      "warn",
+      "failed JSON.SET NX %s: %s (fallback to SET NX)",
+      key,
+      String(error)
+    );
+    try {
+      return await redis.set(key, toJson(data), "NX") === "OK";
+    } catch (fallbackError) {
+      if (fallbackError instanceof Error && isRedisConnectivityError(fallbackError)) {
+        markRedisUnavailable(fallbackError);
+      }
+      logger.log("error", "failed SET NX %s: %s", key, String(fallbackError));
+      return false;
+    }
+  }
+};
+var incrementKey = async (key) => {
+  if (redisUnavailable) throw new Error("Redis is unavailable");
+  const redis = await getReadyRedis();
+  if (!redis) throw new Error("Redis is unavailable");
+  try {
+    return await redis.incr(key);
+  } catch (error) {
+    if (error instanceof Error && isRedisConnectivityError(error)) {
+      markRedisUnavailable(error);
+    }
+    throw error;
+  }
+};
 var setHashJsonField = async (key, field, data, options = {}) => {
   if (redisUnavailable) return;
   const { expire } = { ...DEFAULT_OPTIONS, ...options };
@@ -526,6 +569,12 @@ var redisKeys = {
   backtestConfig: (userName, config) => `users:${userName}:backtests:configs:${config}`,
   strategies: (userName) => `users:${userName}:strategies`,
   strategyConfig: (userName, strategyName, configId = "config") => `users:${userName}:strategies:${strategyName}:${configId}`,
+  runtimeStrategyDraft: (userName, strategyName) => `users:${userName}:strategies:${strategyName}:draft`,
+  runtimeStrategyReleases: (userName, strategyName) => `users:${userName}:strategies:${strategyName}:releases:`,
+  runtimeStrategyRelease: (userName, strategyName, releaseVersion) => `users:${userName}:strategies:${strategyName}:releases:${releaseVersion}`,
+  runtimeStrategyReleaseSequence: (userName, strategyName) => `users:${userName}:strategies:${strategyName}:release-seq`,
+  runtimeStrategyControlEvents: (userName) => `users:${userName}:runtime:strategy-control-events:`,
+  runtimeStrategyControlEvent: (userName, eventId) => `users:${userName}:runtime:strategy-control-events:${eventId}`,
   strategyResults: (userName, strategyName) => `users:${userName}:strategies:${strategyName}:results`,
   strategyCharts: (userName, mode) => `users:${userName}:strategies:charts:${mode}`,
   strategyChartCards: (userName, mode) => `users:${userName}:strategies:charts:${mode}:cards:`,
@@ -595,9 +644,11 @@ var redisKeys = {
   getHashJsonValues,
   getKeys,
   incrHashFields,
+  incrementKey,
   publishData,
   redisKeys,
   setData,
+  setDataIfAbsent,
   setHashJsonField,
   setHashJsonFields
 });

package/dist/redis.mjs

@@ -11,12 +11,14 @@ import {
   getHashJsonValues,
   getKeys,
   incrHashFields,
+  incrementKey,
   publishData,
   redisKeys,
   setData,
+  setDataIfAbsent,
   setHashJsonField,
   setHashJsonFields
-} from "./chunk-6ZKAUA4Q.mjs";
+} from "./chunk-RZTVC4ZL.mjs";
 export {
   RedisWriteBlockedError,
   closeRedisConnection,
@@ -30,9 +32,11 @@ export {
   getHashJsonValues,
   getKeys,
   incrHashFields,
+  incrementKey,
   publishData,
   redisKeys,
   setData,
+  setDataIfAbsent,
   setHashJsonField,
   setHashJsonFields
 };

package/dist/runtimeDeployments.js

@@ -315,6 +315,12 @@ var redisKeys = {
   backtestConfig: (userName, config) => `users:${userName}:backtests:configs:${config}`,
   strategies: (userName) => `users:${userName}:strategies`,
   strategyConfig: (userName, strategyName, configId = "config") => `users:${userName}:strategies:${strategyName}:${configId}`,
+  runtimeStrategyDraft: (userName, strategyName) => `users:${userName}:strategies:${strategyName}:draft`,
+  runtimeStrategyReleases: (userName, strategyName) => `users:${userName}:strategies:${strategyName}:releases:`,
+  runtimeStrategyRelease: (userName, strategyName, releaseVersion) => `users:${userName}:strategies:${strategyName}:releases:${releaseVersion}`,
+  runtimeStrategyReleaseSequence: (userName, strategyName) => `users:${userName}:strategies:${strategyName}:release-seq`,
+  runtimeStrategyControlEvents: (userName) => `users:${userName}:runtime:strategy-control-events:`,
+  runtimeStrategyControlEvent: (userName, eventId) => `users:${userName}:runtime:strategy-control-events:${eventId}`,
   strategyResults: (userName, strategyName) => `users:${userName}:strategies:${strategyName}:results`,
   strategyCharts: (userName, mode) => `users:${userName}:strategies:charts:${mode}`,
   strategyChartCards: (userName, mode) => `users:${userName}:strategies:charts:${mode}:cards:`,
@@ -394,12 +400,34 @@ var getRuntimeDeployment = async (userName, deploymentId) => {
   return isRuntimeDeployment(value) ? value : null;
 };
 var saveRuntimeDeployment = async (userName, deployment) => {
+  const hasVersionedStrategies = deployment.strategies.some(
+    (strategy) => strategy.releaseVersion != null
+  );
+  if (hasVersionedStrategies && deployment.strategies.some((strategy) => strategy.releaseVersion == null)) {
+    throw new Error("A deployment cannot mix legacy configs and releases");
+  }
+  const strategies = deployment.strategies.map(
+    (strategy) => {
+      if (!hasVersionedStrategies) return strategy;
+      if (!Number.isSafeInteger(strategy.releaseVersion) || !strategy.releaseVersion || strategy.config && Object.keys(strategy.config).length) {
+        throw new Error(
+          `Invalid versioned strategy reference: ${strategy.strategyName}`
+        );
+      }
+      return {
+        strategyName: strategy.strategyName,
+        releaseVersion: strategy.releaseVersion,
+        controlState: strategy.controlState === "entries_paused" ? "entries_paused" : "active"
+      };
+    }
+  );
   const normalized = {
     ...deployment,
     id: normalizeId(deployment.id, "Deployment id"),
     label: deployment.label.trim(),
     provider: deployment.provider.trim().toLowerCase(),
-    accountId: normalizeId(deployment.accountId, "Account id")
+    accountId: normalizeId(deployment.accountId, "Account id"),
+    strategies
   };
   await setData(
     redisKeys.runtimeDeployment(userName, normalized.id),

package/dist/runtimeDeployments.mjs

@@ -4,7 +4,7 @@ import {
   getKeys,
   redisKeys,
   setData
-} from "./chunk-6ZKAUA4Q.mjs";
+} from "./chunk-RZTVC4ZL.mjs";
 
 // src/runtimeDeployments.ts
 var normalizeId = (value, label) => {
@@ -29,12 +29,34 @@ var getRuntimeDeployment = async (userName, deploymentId) => {
   return isRuntimeDeployment(value) ? value : null;
 };
 var saveRuntimeDeployment = async (userName, deployment) => {
+  const hasVersionedStrategies = deployment.strategies.some(
+    (strategy) => strategy.releaseVersion != null
+  );
+  if (hasVersionedStrategies && deployment.strategies.some((strategy) => strategy.releaseVersion == null)) {
+    throw new Error("A deployment cannot mix legacy configs and releases");
+  }
+  const strategies = deployment.strategies.map(
+    (strategy) => {
+      if (!hasVersionedStrategies) return strategy;
+      if (!Number.isSafeInteger(strategy.releaseVersion) || !strategy.releaseVersion || strategy.config && Object.keys(strategy.config).length) {
+        throw new Error(
+          `Invalid versioned strategy reference: ${strategy.strategyName}`
+        );
+      }
+      return {
+        strategyName: strategy.strategyName,
+        releaseVersion: strategy.releaseVersion,
+        controlState: strategy.controlState === "entries_paused" ? "entries_paused" : "active"
+      };
+    }
+  );
   const normalized = {
     ...deployment,
     id: normalizeId(deployment.id, "Deployment id"),
     label: deployment.label.trim(),
     provider: deployment.provider.trim().toLowerCase(),
-    accountId: normalizeId(deployment.accountId, "Account id")
+    accountId: normalizeId(deployment.accountId, "Account id"),
+    strategies
   };
   await setData(
     redisKeys.runtimeDeployment(userName, normalized.id),

package/dist/runtimeStrategyConfigs.js

@@ -284,6 +284,12 @@ var redisKeys = {
   backtestConfig: (userName, config) => `users:${userName}:backtests:configs:${config}`,
   strategies: (userName) => `users:${userName}:strategies`,
   strategyConfig: (userName, strategyName, configId = "config") => `users:${userName}:strategies:${strategyName}:${configId}`,
+  runtimeStrategyDraft: (userName, strategyName) => `users:${userName}:strategies:${strategyName}:draft`,
+  runtimeStrategyReleases: (userName, strategyName) => `users:${userName}:strategies:${strategyName}:releases:`,
+  runtimeStrategyRelease: (userName, strategyName, releaseVersion) => `users:${userName}:strategies:${strategyName}:releases:${releaseVersion}`,
+  runtimeStrategyReleaseSequence: (userName, strategyName) => `users:${userName}:strategies:${strategyName}:release-seq`,
+  runtimeStrategyControlEvents: (userName) => `users:${userName}:runtime:strategy-control-events:`,
+  runtimeStrategyControlEvent: (userName, eventId) => `users:${userName}:runtime:strategy-control-events:${eventId}`,
   strategyResults: (userName, strategyName) => `users:${userName}:strategies:${strategyName}:results`,
   strategyCharts: (userName, mode) => `users:${userName}:strategies:charts:${mode}`,
   strategyChartCards: (userName, mode) => `users:${userName}:strategies:charts:${mode}:cards:`,
@@ -342,7 +348,7 @@ var redisKeys = {
 
 // src/runtimeStrategyConfigs.ts
 var RESERVED_STRATEGY_NAMES = /* @__PURE__ */ new Set(["charts"]);
-var RESERVED_CONFIG_IDS = /* @__PURE__ */ new Set(["results"]);
+var RESERVED_CONFIG_IDS = /* @__PURE__ */ new Set(["results", "draft", "release-seq"]);
 var isStrategyConfig = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value));
 var resolveStrategyConfigIdentityByKey = (userName, key) => {
   const parts = key.split(":");

package/dist/runtimeStrategyConfigs.mjs

@@ -3,11 +3,11 @@ import {
   getKeys,
   redisKeys,
   setData
-} from "./chunk-6ZKAUA4Q.mjs";
+} from "./chunk-RZTVC4ZL.mjs";
 
 // src/runtimeStrategyConfigs.ts
 var RESERVED_STRATEGY_NAMES = /* @__PURE__ */ new Set(["charts"]);
-var RESERVED_CONFIG_IDS = /* @__PURE__ */ new Set(["results"]);
+var RESERVED_CONFIG_IDS = /* @__PURE__ */ new Set(["results", "draft", "release-seq"]);
 var isStrategyConfig = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value));
 var resolveStrategyConfigIdentityByKey = (userName, key) => {
   const parts = key.split(":");

package/dist/runtimeStrategyReleases.d.mts

@@ -0,0 +1,34 @@
+import { StrategyConfig, RuntimeStrategyDraft, RuntimeStrategyRelease, RuntimeStrategyControlState, RuntimeStrategyControlEvent } from '@tradejs/types';
+
+declare const assertRuntimeStrategyReleaseConfig: (config: StrategyConfig) => void;
+declare const verifyRuntimeStrategyRelease: (value: unknown) => RuntimeStrategyRelease;
+declare const getRuntimeStrategyDraft: (userName: string, strategyName: string) => Promise<RuntimeStrategyDraft | null>;
+declare const saveRuntimeStrategyDraft: ({ userName, strategyName, config, baseReleaseVersion, updatedBy, }: {
+    userName: string;
+    strategyName: string;
+    config: StrategyConfig;
+    baseReleaseVersion?: number | null;
+    updatedBy: string;
+}) => Promise<RuntimeStrategyDraft>;
+declare const getRuntimeStrategyRelease: (userName: string, strategyName: string, releaseVersion: number) => Promise<RuntimeStrategyRelease | null>;
+declare const listRuntimeStrategyReleases: (userName: string, strategyName: string) => Promise<RuntimeStrategyRelease[]>;
+declare const publishRuntimeStrategyRelease: ({ userName, strategyName, config, strategyPackage, strategyPackageVersion, runtimePackageVersion, createdBy, }: {
+    userName: string;
+    strategyName: string;
+    config: StrategyConfig;
+    strategyPackage?: string | null;
+    strategyPackageVersion?: string | null;
+    runtimePackageVersion?: string | null;
+    createdBy: string;
+}) => Promise<RuntimeStrategyRelease>;
+declare const recordRuntimeStrategyControlEvent: ({ userName, deploymentId, strategyName, releaseVersion, previousState, nextState, createdBy, }: {
+    userName: string;
+    deploymentId: string;
+    strategyName: string;
+    releaseVersion: number;
+    previousState: RuntimeStrategyControlState;
+    nextState: RuntimeStrategyControlState;
+    createdBy: string;
+}) => Promise<RuntimeStrategyControlEvent>;
+
+export { assertRuntimeStrategyReleaseConfig, getRuntimeStrategyDraft, getRuntimeStrategyRelease, listRuntimeStrategyReleases, publishRuntimeStrategyRelease, recordRuntimeStrategyControlEvent, saveRuntimeStrategyDraft, verifyRuntimeStrategyRelease };

package/dist/runtimeStrategyReleases.d.ts

@@ -0,0 +1,34 @@
+import { StrategyConfig, RuntimeStrategyDraft, RuntimeStrategyRelease, RuntimeStrategyControlState, RuntimeStrategyControlEvent } from '@tradejs/types';
+
+declare const assertRuntimeStrategyReleaseConfig: (config: StrategyConfig) => void;
+declare const verifyRuntimeStrategyRelease: (value: unknown) => RuntimeStrategyRelease;
+declare const getRuntimeStrategyDraft: (userName: string, strategyName: string) => Promise<RuntimeStrategyDraft | null>;
+declare const saveRuntimeStrategyDraft: ({ userName, strategyName, config, baseReleaseVersion, updatedBy, }: {
+    userName: string;
+    strategyName: string;
+    config: StrategyConfig;
+    baseReleaseVersion?: number | null;
+    updatedBy: string;
+}) => Promise<RuntimeStrategyDraft>;
+declare const getRuntimeStrategyRelease: (userName: string, strategyName: string, releaseVersion: number) => Promise<RuntimeStrategyRelease | null>;
+declare const listRuntimeStrategyReleases: (userName: string, strategyName: string) => Promise<RuntimeStrategyRelease[]>;
+declare const publishRuntimeStrategyRelease: ({ userName, strategyName, config, strategyPackage, strategyPackageVersion, runtimePackageVersion, createdBy, }: {
+    userName: string;
+    strategyName: string;
+    config: StrategyConfig;
+    strategyPackage?: string | null;
+    strategyPackageVersion?: string | null;
+    runtimePackageVersion?: string | null;
+    createdBy: string;
+}) => Promise<RuntimeStrategyRelease>;
+declare const recordRuntimeStrategyControlEvent: ({ userName, deploymentId, strategyName, releaseVersion, previousState, nextState, createdBy, }: {
+    userName: string;
+    deploymentId: string;
+    strategyName: string;
+    releaseVersion: number;
+    previousState: RuntimeStrategyControlState;
+    nextState: RuntimeStrategyControlState;
+    createdBy: string;
+}) => Promise<RuntimeStrategyControlEvent>;
+
+export { assertRuntimeStrategyReleaseConfig, getRuntimeStrategyDraft, getRuntimeStrategyRelease, listRuntimeStrategyReleases, publishRuntimeStrategyRelease, recordRuntimeStrategyControlEvent, saveRuntimeStrategyDraft, verifyRuntimeStrategyRelease };