@qtsurfer/api-client 0.15.0 → 0.17.0

package/src/generated/schemas.gen.ts

@@ -163,6 +163,174 @@ export const HalLinkSchema = {
   },
 } as const;
 
+export const AccountSchema = {
+  type: "object",
+  description: `Your identity and tier limits. No database call behind this one — safe to fetch on every
+page load. Live usage against these limits is a separate resource, \`GET /account/usage\`,
+deliberately: usage changes on every upload/execution and costs a query to compute, this
+one doesn't.
+`,
+  required: [
+    "userId",
+    "tier",
+    "maxDatasets",
+    "maxDatasetBytes",
+    "maxTotalStorageBytes",
+    "_links",
+  ],
+  properties: {
+    userId: {
+      type: "string",
+      description: "Your account id — the JWT `sub` claim.",
+      example: "00000000-0000-0000-0000-000000000000",
+    },
+    tier: {
+      type: "string",
+      description: "Your current subscription tier.",
+      example: "free",
+    },
+    maxDatasets: {
+      type: "integer",
+      description: "Maximum number of active datasets your tier allows.",
+      example: 3,
+    },
+    maxDatasetBytes: {
+      type: "integer",
+      format: "int64",
+      description: "Maximum size, in bytes, of a single dataset version.",
+      example: 52428800,
+    },
+    maxTotalStorageBytes: {
+      type: "integer",
+      format: "int64",
+      description: `Maximum combined storage, in bytes, across every dataset, strategy-execution signal,
+and registered strategy on your account — one shared pool, not a separate cap per
+resource type, since they all compete for the same underlying storage. See \`GET
+/account/usage\`'s \`storageBytesUsed\` for your current usage against this number.
+`,
+      example: 104857600,
+    },
+    _links: {
+      $ref: "#/components/schemas/AccountLinks",
+    },
+  },
+} as const;
+
+export const AccountLinksSchema = {
+  description: "HAL `_links` for `GET /account`",
+  type: "object",
+  required: ["self", "usage"],
+  properties: {
+    self: {
+      allOf: [
+        {
+          $ref: "#/components/schemas/HalLink",
+        },
+      ],
+      description: "Link to this resource.",
+    },
+    usage: {
+      allOf: [
+        {
+          $ref: "#/components/schemas/HalLink",
+        },
+      ],
+      description: "Link to your live usage, `GET /account/usage`.",
+    },
+  },
+} as const;
+
+export const AccountUsageSchema = {
+  type: "object",
+  description: `Your live usage of the shared storage pool \`GET /account\`'s \`maxTotalStorageBytes\` caps.
+Not guaranteed real-time — a just-completed upload or strategy execution may take a short
+moment to be reflected here.
+`,
+  required: [
+    "datasetsUsed",
+    "datasetBytesUsed",
+    "signalsUsed",
+    "signalBytesUsed",
+    "strategiesUsed",
+    "strategyBytesUsed",
+    "storageBytesUsed",
+    "_links",
+  ],
+  properties: {
+    datasetsUsed: {
+      type: "integer",
+      description:
+        "Active datasets counted — the same set `GET /account`'s `maxDatasets` limits.",
+      example: 2,
+    },
+    datasetBytesUsed: {
+      type: "integer",
+      format: "int64",
+      description: "Combined bytes of every active dataset's current version.",
+      example: 15728640,
+    },
+    signalsUsed: {
+      type: "integer",
+      description: "Recorded strategy-execution signal uploads.",
+      example: 1,
+    },
+    signalBytesUsed: {
+      type: "integer",
+      format: "int64",
+      description: "Combined bytes of every recorded signal upload.",
+      example: 524288,
+    },
+    strategiesUsed: {
+      type: "integer",
+      description: "Registered strategies (see `GET /strategies`).",
+      example: 4,
+    },
+    strategyBytesUsed: {
+      type: "integer",
+      format: "int64",
+      description: `Combined bytes of each registered strategy's source plus its latest compiled
+bytecode. Superseded (non-latest) compilations aren't counted.
+`,
+      example: 40960,
+    },
+    storageBytesUsed: {
+      type: "integer",
+      format: "int64",
+      description: `\`datasetBytesUsed + signalBytesUsed + strategyBytesUsed\` — the number checked
+against \`GET /account\`'s \`maxTotalStorageBytes\`.
+`,
+      example: 16293888,
+    },
+    _links: {
+      $ref: "#/components/schemas/AccountUsageLinks",
+    },
+  },
+} as const;
+
+export const AccountUsageLinksSchema = {
+  description: "HAL `_links` for `GET /account/usage`",
+  type: "object",
+  required: ["self", "account"],
+  properties: {
+    self: {
+      allOf: [
+        {
+          $ref: "#/components/schemas/HalLink",
+        },
+      ],
+      description: "Link to this resource.",
+    },
+    account: {
+      allOf: [
+        {
+          $ref: "#/components/schemas/HalLink",
+        },
+      ],
+      description: "Link to your tier limits, `GET /account`.",
+    },
+  },
+} as const;
+
 export const InstrumentDetailSchema = {
   description:
     "Exchange instrument with per-data-type coverage and market info",
@@ -277,8 +445,17 @@ export const ExchangeSchema = {
 
 export const DataSourceTypeSchema = {
   type: "string",
-  description: "Managed exchange data sources available for backtesting.",
-  enum: ["ticker"],
+  description: `Managed exchange data sources available for backtesting.
+
+* \`ticker\` — trades. Can be prepared, executed and swept.
+* \`kline\` — aggregated bars (candlesticks). Can be prepared, executed and swept. A run reads
+  bars of the \`cadence\` the data was prepared at: you choose the bar width when you prepare,
+  and the strategy does not fix it. See \`PrepareRequest.cadence\` for the accepted values.
+* \`funding\` — funding rates. Can be **prepared but not executed or swept yet**: a \`funding\`
+  request to \`execute\` or \`executeSweep\` is rejected with \`400\` before anything is queued,
+  and the message names the sources that can be run.
+`,
+  enum: ["ticker", "kline", "funding"],
   example: "ticker",
 } as const;
 
@@ -340,9 +517,14 @@ resampling the source and stored alongside the native blob in cache. A target fi
 than the source, or not an exact multiple of it, returns \`400\`. What's accepted, and
 what omitting it means, depends on the source:
 
-* Managed exchange — one of \`1s\`, \`5s\`, \`1m\`, \`3m\`, \`5m\`, \`15m\`, \`30m\`, \`1h\`, \`2h\`,
-  \`4h\`, \`8h\`, \`12h\`, \`1d\`, \`1w\`, \`1q\`; any other label returns \`400\`. Omitted = \`1s\`,
-  the publisher's native cadence.
+* Managed exchange, \`ticker\` or \`funding\` — one of \`1s\`, \`5s\`, \`1m\`, \`3m\`, \`5m\`, \`15m\`,
+  \`30m\`, \`1h\`, \`2h\`, \`4h\`, \`8h\`, \`12h\`, \`1d\`, \`1w\`, \`1q\`; any other label returns \`400\`.
+  Omitted = \`1s\`, the publisher's native cadence.
+* Managed exchange, \`kline\` — one of \`1s\`, \`1m\`, \`5m\`, \`15m\`, \`30m\`, \`1h\`, \`4h\`, \`1d\`;
+  any other label, including \`5s\`, \`3m\` and \`8h\`, returns \`400\` and names the accepted
+  ones. Omitted = \`1s\`. This is the width of the bars a run reads: it is chosen here,
+  once, and the same strategy can be run at several cadences by preparing the range at
+  each.
 * Dataset (\`exchangeId: user\`) — omitted = the dataset version's own discovered
   \`cadence\` (see \`DatasetVersion.cadence\`), served as-is. Any cadence equal to or
   coarser than it and an exact multiple of it is accepted, including ones outside the
@@ -369,7 +551,7 @@ export const JobStateSchema = {
       description:
         "Identifier for the job's execution context. Its current shape is a colon-delimited string encoding the data source type, an internal user id, the exchange, the job id, and the instrument — but that structure is not a committed contract and may change without notice. Treat it as an opaque token: store and pass it back, don't parse it.",
       example:
-        "jctx:ticker:76b90203-03c2-46f6-b366-9944f167e818:binance:5ikyamio8b3v9wcnfxztzg:btc/usdt:0vicnz3thzhrqvfczks1pu",
+        "jctx:ticker:00000000-0000-0000-0000-000000000000:binance:5ikyamio8b3v9wcnfxztzg:btc/usdt:0vicnz3thzhrqvfczks1pu",
     },
     status: {
       type: "string",
@@ -1712,8 +1894,9 @@ export const EquityCurveResultSchema = {
 
 export const strategyIdSchema = {
   description: `Unique identifier for a compiled strategy, derived from the source itself: the same code
-always yields the same id, for every caller, whatever its formatting. See
-\`POST /strategy\` for exactly which rewrites preserve it and which do not.
+always yields the same id, for every caller. How much formatting the id ignores depends on
+the language — see \`POST /strategy\` for exactly which rewrites preserve it and which do
+not.
 `,
   type: "string",
   example: "6bsh31ikwkuivhtgcoa6s4",
@@ -1964,11 +2147,12 @@ export const DatasetSchema = {
   description: `A dataset's own metadata — not its data. \`currentVersionId\` is what a prepare against
 \`exchangeId: user\` reads by default; see \`DatasetVersion\` for what a version carries.
 
-\`from\`/\`to\`/\`cadence\` mirror that current version's own discovered range and cadence, so
-you don't need a second call to \`GET /datasets/{datasetId}/uploads/{uploadId}\` just to see
-what a dataset covers. Absent until a version exists.
+\`from\`/\`to\`/\`cadence\`/\`timestampUnit\`/\`bytes\`/\`rows\`/\`gaps\`/\`largestGapSteps\` mirror that
+current version's own discovered range, cadence, timestamp unit and metrics, so you don't
+need a second call to \`GET /datasets/{datasetId}/uploads/{uploadId}\` just to see what a
+dataset covers.
 `,
-  required: ["datasetId", "name", "type", "instrument", "createdAt"],
+  required: ["datasetId", "name", "type", "instrument", "createdAt", "status"],
   properties: {
     datasetId: {
       type: "string",
@@ -2035,6 +2219,56 @@ a version exists.
 `,
       example: "1m",
     },
+    timestampUnit: {
+      type: "string",
+      enum: ["iso", "s", "ms", "us"],
+      description: `\`currentVersionId\`'s own timestamp unit (see \`DatasetVersion.timestampUnit\`) — decode
+the \`timestamp\` column of \`dataUrl\`'s file accordingly. Present only when \`status\` is
+\`ready\`.
+`,
+      example: "iso",
+    },
+    status: {
+      type: "string",
+      enum: ["ready", "failed", "pending"],
+      description: `* \`ready\` — \`currentVersionId\` is set; \`from\`/\`to\`/\`cadence\`/\`bytes\`/\`rows\`/\`gaps\`/
+  \`largestGapSteps\` describe it.
+* \`failed\` — the most recent upload/import attempt failed. \`currentVersionId\` and the
+  fields above are absent — there is nothing to read yet. See \`error\`.
+* \`pending\` — nothing has ever been attempted (just created, or an upload was never
+  finalized).
+`,
+      example: "ready",
+    },
+    bytes: {
+      type: "integer",
+      description: `Size of \`currentVersionId\`'s own stored file. Present only when \`status\` is \`ready\` —
+see \`DatasetVersion.bytes\` for what it measures exactly.
+`,
+      example: 4831022,
+    },
+    rows: {
+      type: "integer",
+      description: `\`currentVersionId\`'s own row count. Present only when \`status\` is \`ready\`.`,
+      example: 86400,
+    },
+    gaps: {
+      type: "integer",
+      description: `\`currentVersionId\`'s own gap count at its discovered cadence. Present only when \`status\` is \`ready\`.`,
+      example: 0,
+    },
+    largestGapSteps: {
+      type: "integer",
+      description: `\`currentVersionId\`'s own largest gap, in units of its discovered cadence step. Present only when \`status\` is \`ready\`.`,
+      example: 0,
+    },
+    error: {
+      type: "string",
+      description: `A human-readable reason the most recent upload/import attempt failed. Present only
+when \`status\` is \`failed\`.
+`,
+      example: "line 3: column 'close' is not a number: not-a-number",
+    },
   },
 } as const;
 
@@ -2064,8 +2298,9 @@ session, not in one shot like a browser upload.
           enum: ["lastra", "parquet"],
           description: `Which format \`dataUrl\` is actually in — check this rather than assuming it
 matches how you uploaded it. \`lastra\` — our native columnar format — for a CSV (or
-gzip/zip of one) upload, always converted on ingest. \`parquet\` for a parquet
-upload, stored as-is today.
+gzip/zip of one) upload, always converted on ingest, or for a lastra upload,
+stored as-is (the value alone doesn't tell you which). \`parquet\` for a parquet
+upload, also stored as-is today.
 `,
           example: "lastra",
         },
@@ -2244,8 +2479,9 @@ an extended viewing session, not in one shot like a browser upload.
       enum: ["lastra", "parquet"],
       description: `Which format \`dataUrl\` is actually in — check this rather than assuming it matches
 how you uploaded it. \`lastra\` — our native columnar format — for a CSV (or gzip/zip
-of one) upload, always converted on ingest. \`parquet\` for a parquet upload, stored
-as-is today.
+of one) upload, always converted on ingest, or for a lastra upload, stored as-is
+(the value alone doesn't tell you which). \`parquet\` for a parquet upload, also
+stored as-is today.
 `,
       example: "lastra",
     },
@@ -2549,3 +2785,474 @@ export const AuthTokenErrorSchema = {
     },
   },
 } as const;
+
+export const LiveSourceSchema = {
+  type: "object",
+  required: ["venueType", "exchange", "segment", "type", "instruments"],
+  description:
+    "One market feed a live run consumes. Exactly one entry per run today.",
+  properties: {
+    venueType: {
+      type: "string",
+      example: "cx",
+      description:
+        "Venue category. `cx` (centralized exchange) is the only one live runs support today.",
+    },
+    exchange: {
+      type: "string",
+      example: "binance",
+    },
+    segment: {
+      type: "string",
+      example: "spot",
+    },
+    type: {
+      type: "string",
+      enum: ["ticker", "kline"],
+      description:
+        "Both `ticker` and `kline` connect to the lightest (fastest) cadence available for the exchange — today, 1 tick/second on every supported exchange. Choosing a specific cadence is not offered yet.",
+    },
+    instruments: {
+      type: "array",
+      items: {
+        type: "string",
+      },
+      example: ["BTC/USDT"],
+      description:
+        'Instrument symbols, or `["*"]` for every instrument the exchange/segment offers (tier-gated).',
+    },
+  },
+} as const;
+
+export const StartLiveRequestSchema = {
+  type: "object",
+  required: ["sources"],
+  properties: {
+    sources: {
+      type: "array",
+      minItems: 1,
+      maxItems: 1,
+      items: {
+        $ref: "#/components/schemas/LiveSource",
+      },
+    },
+    params: {
+      type: "object",
+      description:
+        "Strategy parameters to start with. Opaque key/value pairs — see this strategy's own `declaredProperties` (from `POST /strategy`) for the keys it accepts.",
+      additionalProperties: true,
+    },
+    visibility: {
+      type: "string",
+      enum: ["private", "public"],
+      default: "private",
+      description:
+        "A `public` run appears in `GET /live/public` and its signal channel accepts subscriptions from anyone, not only you.",
+    },
+    relay: {
+      type: "boolean",
+      default: false,
+      description: `Request that this run's signals be relayed over its WebSocket channel once it reaches the \`live\` stage — see the "Live execution" guide. Has no effect while the run is still in the \`sandbox\` stage, regardless of this value.`,
+    },
+    name: {
+      type: "string",
+    },
+    description: {
+      type: "string",
+    },
+  },
+} as const;
+
+export const UpdateLiveRequestSchema = {
+  type: "object",
+  properties: {
+    visibility: {
+      type: "string",
+      enum: ["private", "public"],
+    },
+    name: {
+      type: "string",
+    },
+    description: {
+      type: "string",
+    },
+  },
+} as const;
+
+export const UpdateLiveParamsRequestSchema = {
+  type: "object",
+  required: ["params"],
+  properties: {
+    params: {
+      type: "object",
+      additionalProperties: true,
+      description:
+        "Must be non-empty; every key must be a property your strategy declares.",
+    },
+  },
+} as const;
+
+export const LiveRunSchema = {
+  type: "object",
+  required: [
+    "strategyId",
+    "runId",
+    "visibility",
+    "stage",
+    "state",
+    "desired",
+    "sources",
+    "params",
+    "paramsVersion",
+    "relay",
+    "startedAtMs",
+  ],
+  description:
+    "A live run's full state, as returned by starting, reading, or stopping it through its strategy.",
+  properties: {
+    strategyId: {
+      $ref: "#/components/schemas/strategyId",
+    },
+    runId: {
+      type: "string",
+      description:
+        "This run's own id — its canonical identity for `PATCH`/`PUT .../params` and for `GET /live/public`.",
+    },
+    name: {
+      type: "string",
+    },
+    description: {
+      type: "string",
+    },
+    visibility: {
+      type: "string",
+      enum: ["private", "public"],
+    },
+    stage: {
+      type: "string",
+      enum: ["SANDBOX", "LIVE"],
+      description:
+        "A new run always starts `SANDBOX` — a trial run compared against a second execution for agreement — and moves to `LIVE` once it passes.",
+    },
+    state: {
+      type: "string",
+      description: `\`STARTING\` until first observed running; otherwise the runner's own reported state (e.g. \`RUNNING\`).`,
+    },
+    desired: {
+      type: "string",
+      enum: ["RUNNING", "STOPPED"],
+      description:
+        "What you last asked for. `state` can lag this briefly after `DELETE`.",
+    },
+    reason: {
+      type: "string",
+      description:
+        "Present only when the run stopped because it exceeded its resource allowance.",
+    },
+    sources: {
+      type: "array",
+      items: {
+        $ref: "#/components/schemas/LiveSource",
+      },
+    },
+    params: {
+      type: "object",
+      additionalProperties: true,
+    },
+    paramsVersion: {
+      type: "integer",
+      description:
+        "Increments on every accepted `PUT .../params` call, including one that resends the current values.",
+    },
+    relay: {
+      type: "boolean",
+      description: `Whether this run's signals are being relayed over the WebSocket channel described in the "Live execution" guide, right now. This is the effective value — \`false\` on a \`sandbox\` run regardless of what was requested at start; matches the requested value once \`stage\` reaches \`live\`.`,
+    },
+    startedAtMs: {
+      type: "integer",
+      format: "int64",
+      description: "Epoch milliseconds.",
+    },
+    gate: {
+      type: "object",
+      additionalProperties: true,
+      description:
+        "The sandbox trial's promotion verdict, once one exists. Shape is not yet stabilized as public API — treat as opaque diagnostics.",
+    },
+  },
+} as const;
+
+export const LiveRunCompactSchema = {
+  type: "object",
+  required: ["runId", "visibility", "stage", "state", "sources"],
+  description:
+    "A run's state as returned by `PATCH /live/{runId}` — narrower than `LiveRun` (no `strategyId`, `params`, or `desired`), since this endpoint is addressed by `runId` alone.",
+  properties: {
+    runId: {
+      type: "string",
+    },
+    name: {
+      type: "string",
+    },
+    description: {
+      type: "string",
+    },
+    visibility: {
+      type: "string",
+      enum: ["private", "public"],
+    },
+    stage: {
+      type: "string",
+      enum: ["SANDBOX", "LIVE"],
+    },
+    state: {
+      type: "string",
+    },
+    sources: {
+      type: "array",
+      items: {
+        $ref: "#/components/schemas/LiveSource",
+      },
+    },
+  },
+} as const;
+
+export const PublicLiveRunSchema = {
+  type: "object",
+  required: ["runId", "sources", "state", "createdAtMs"],
+  description:
+    "A run as it appears in `GET /live/public` — never reveals who owns it or which strategy it runs.",
+  properties: {
+    runId: {
+      type: "string",
+    },
+    name: {
+      type: "string",
+    },
+    description: {
+      type: "string",
+    },
+    sources: {
+      type: "array",
+      items: {
+        $ref: "#/components/schemas/LiveSource",
+      },
+    },
+    state: {
+      type: "string",
+    },
+    createdAtMs: {
+      type: "integer",
+      format: "int64",
+    },
+  },
+} as const;
+
+export const PublicLiveListResponseSchema = {
+  type: "object",
+  required: ["runs"],
+  properties: {
+    runs: {
+      type: "array",
+      items: {
+        $ref: "#/components/schemas/PublicLiveRun",
+      },
+    },
+    _links: {
+      $ref: "#/components/schemas/PublicLiveListLinks",
+    },
+  },
+} as const;
+
+export const PublicLiveListLinksSchema = {
+  type: "object",
+  description: "Present only when another page exists.",
+  properties: {
+    next: {
+      $ref: "#/components/schemas/PublicLiveNextLink",
+    },
+  },
+} as const;
+
+export const PublicLiveNextLinkSchema = {
+  type: "object",
+  properties: {
+    href: {
+      type: "string",
+    },
+  },
+} as const;
+
+export const LiveSignalPageSchema = {
+  type: "object",
+  required: ["signals"],
+  description: "One page of a run's recorded signals, oldest first.",
+  properties: {
+    signals: {
+      type: "array",
+      items: {
+        $ref: "#/components/schemas/LiveSignal",
+      },
+    },
+    availableSinceMs: {
+      type: "integer",
+      format: "int64",
+      description:
+        "The oldest moment this run's signals can still be read from. Absent when the run has produced nothing yet. It moves forward over time as older signals are discarded, so a `sinceMs` earlier than this is served from here instead.",
+    },
+    _links: {
+      $ref: "#/components/schemas/PublicLiveListLinks",
+    },
+  },
+} as const;
+
+export const LiveSignalSchema = {
+  type: "object",
+  required: [
+    "v",
+    "signalId",
+    "runId",
+    "stage",
+    "type",
+    "eventTsMs",
+    "emittedAtMs",
+    "instrument",
+    "digest",
+  ],
+  description:
+    "One signal, in the same shape the real-time signal channel delivers.",
+  properties: {
+    v: {
+      type: "integer",
+      description: "Envelope schema version.",
+    },
+    signalId: {
+      type: "string",
+      description:
+        "Stable id for this exact signal — dedupe on it across reconnects or overlapping reads.",
+    },
+    runId: {
+      type: "string",
+    },
+    stage: {
+      type: "string",
+      enum: ["sandbox", "live"],
+      description: "The stage the run was in when this signal was produced.",
+    },
+    paramsVersion: {
+      type: "integer",
+      description: "The parameter set in force when this signal was produced.",
+    },
+    type: {
+      type: "string",
+      enum: ["hint", "info", "marker", "command"],
+    },
+    kind: {
+      type: ["string", "null"],
+      description: `\`BUY\`/\`SELL\` for a \`hint\`, the command name for a \`command\`, absent otherwise.`,
+    },
+    eventTsMs: {
+      type: "integer",
+      format: "int64",
+      description: "Market time the signal was produced.",
+    },
+    emittedAtMs: {
+      type: "integer",
+      format: "int64",
+      description: "Time it was published — always at or after `eventTsMs`.",
+    },
+    instrument: {
+      $ref: "#/components/schemas/LiveSignalInstrument",
+    },
+    order: {
+      $ref: "#/components/schemas/LiveSignalOrder",
+    },
+    data: {
+      type: "object",
+      additionalProperties: true,
+      description: "The signal's own free-form payload.",
+    },
+    regenerated: {
+      type: "boolean",
+      description: `\`true\` only for a signal republished to fill a gap in the record.`,
+    },
+    digest: {
+      type: "string",
+      description:
+        "Content hash, for checking that two independent deliveries of the same signal agree.",
+    },
+  },
+} as const;
+
+export const LiveSignalInstrumentSchema = {
+  type: "object",
+  properties: {
+    exchange: {
+      type: "string",
+    },
+    segment: {
+      type: "string",
+    },
+    symbol: {
+      type: "string",
+      description: "Slashed form, e.g. `BTC/USDT`.",
+    },
+  },
+} as const;
+
+export const LiveSignalOrderSchema = {
+  type: ["object", "null"],
+  description: "Present only for a `hint`.",
+  properties: {
+    orderKind: {
+      type: "string",
+    },
+    price: {
+      type: ["string", "null"],
+    },
+    amount: {
+      type: ["string", "null"],
+    },
+    stopPrice: {
+      type: ["string", "null"],
+    },
+    trailPct: {
+      type: ["string", "null"],
+    },
+  },
+} as const;
+
+export const LiveConnectionTokenSchema = {
+  type: "object",
+  required: ["token", "expiresAtMs"],
+  properties: {
+    token: {
+      type: "string",
+      description:
+        'Pass as the `token` field of the WebSocket `connect` command — see the "Live execution" guide.',
+    },
+    expiresAtMs: {
+      type: "integer",
+      format: "int64",
+    },
+  },
+} as const;
+
+export const LiveParamsUpdateResultSchema = {
+  type: "object",
+  required: ["runId", "paramsVersion", "effectiveAtMs"],
+  properties: {
+    runId: {
+      type: "string",
+    },
+    paramsVersion: {
+      type: "integer",
+    },
+    effectiveAtMs: {
+      type: "integer",
+      format: "int64",
+      description:
+        "Epoch milliseconds — the earliest moment the new values are guaranteed to be in effect.",
+    },
+  },
+} as const;