@serve.zone/interfaces 32.22.0 → 32.24.0

package/dist_ts/data/servicevolumeinitialization.d.ts

@@ -0,0 +1,91 @@
+import type { IRuntimeLocalStorageOwnership } from './runtimelocalstorageclaim.js';
+import type { IServiceRuntimeProfile } from './serviceruntime.js';
+/**
+ * Where an `import` volume's bytes come from.
+ *
+ * `docker-volume` is a Docker volume on the host the claim's node runs on, named exactly as Docker
+ * lists it; a Corestore-driver volume is named the same way. The operator copies its tree into the
+ * node's import directory; the node never reads this reference, and the local storage claim does
+ * not carry it.
+ */
+export type TServiceVolumeImportSource = {
+    kind: 'docker-volume';
+    volumeName: string;
+};
+/**
+ * The owner and permission bits an `empty` volume's root directory gets.
+ *
+ * `explicit` states the numeric owner. `run-as` takes the owner from the runtime spec's
+ * `profile.runAs` (user and group) when the claim is first issued; the mode is always stated,
+ * because no mode is right for every image.
+ */
+export type TServiceVolumeOwnership = {
+    kind: 'explicit';
+    uid: number;
+    gid: number;
+    mode: number;
+} | {
+    kind: 'run-as';
+    mode: number;
+};
+/**
+ * How a service volume's node-local claim starts: `empty` creates a fresh root with the stated
+ * ownership, `import` waits for the bytes of an existing volume.
+ */
+export type TServiceVolumeInitialization = {
+    kind: 'empty';
+    ownership: TServiceVolumeOwnership;
+} | {
+    kind: 'import';
+    source: TServiceVolumeImportSource;
+};
+/**
+ * What a volume's initialization derives for a local storage claim, or why it derives nothing.
+ *
+ * `volume-initialization-unknown` is a volume with no initialization: Cloudly never assumes
+ * `empty`, because an empty volume in front of a service whose data sits in a legacy volume would
+ * start that service without its data. `volume-ownership-unknown` is a `run-as` ownership while
+ * the runtime spec runs the image's own user (`runAs: null`), whose numeric identity Cloudly does
+ * not know.
+ */
+export type TServiceVolumeClaimInitialization = {
+    status: 'derived';
+    initialization: 'empty';
+    initialOwnership: IRuntimeLocalStorageOwnership;
+} | {
+    status: 'derived';
+    initialization: 'import';
+    initialOwnership: null;
+} | {
+    status: 'refused';
+    reason: 'volume-initialization-unknown' | 'volume-ownership-unknown';
+};
+/**
+ * Why `setServiceVolumeInitialization` wrote nothing. `volume-not-found` names no declared volume
+ * at that mount path, `conflict` a stored initialization other than `expected`,
+ * `volume-initialization-invalid` a value this contract refuses, and
+ * `volume-initialization-bound` a change while a bound local storage claim of the volume exists:
+ * a claim keeps the initialization and ownership it was issued with for its whole life.
+ */
+export type TServiceVolumeInitializationRefusal = 'volume-not-found' | 'conflict' | 'volume-initialization-invalid' | 'volume-initialization-bound';
+/** The named refusal of `setServiceVolumeInitialization`, sent as `TypedResponseError.errorData`. */
+export interface IServiceVolumeInitializationErrorData {
+    code: TServiceVolumeInitializationRefusal;
+    retryable: false;
+}
+export declare const serviceVolumeInitializationContract: Readonly<{
+    /** Every permission bit an ownership may state, the local storage claim's own bound. */
+    readonly directoryModeBits: 2047;
+    readonly maximumDockerVolumeNameLength: 255;
+}>;
+/** Validates one volume initialization and names every reason it is refused. */
+export declare const validateServiceVolumeInitialization: (valueArg: unknown, pathArg?: string) => string[];
+/**
+ * The claim fields a volume's initialization derives under a runtime spec's `runAs`.
+ *
+ * Absent initialization refuses as `volume-initialization-unknown`; a `run-as` ownership under
+ * `runAs: null` refuses as `volume-ownership-unknown`. Nothing is defaulted. The answer is for the
+ * first generation of a claim only: later generations carry that claim's own initialization and
+ * ownership, whatever `runAs` says by then. A malformed initialization or `runAs` throws.
+ */
+export declare const deriveServiceVolumeClaimInitialization: (initializationArg: TServiceVolumeInitialization | undefined, runAsArg: IServiceRuntimeProfile["runAs"]) => TServiceVolumeClaimInitialization;

package/dist_ts/data/servicevolumeinitialization.js

@@ -0,0 +1,93 @@
+import { runtimeLocalStorageClaimContract } from './runtimelocalstorageclaim.js';
+import { hasExactKeys, isPlainRecord } from '../private/dataproperties.js';
+import { isRuntimeIdentityNumber } from '../private/runtimepolicy.js';
+export const serviceVolumeInitializationContract = Object.freeze({
+    /** Every permission bit an ownership may state, the local storage claim's own bound. */
+    directoryModeBits: runtimeLocalStorageClaimContract.directoryModeBits,
+    maximumDockerVolumeNameLength: 255,
+});
+/** Docker's own volume name grammar, `[a-zA-Z0-9][a-zA-Z0-9_.-]`, which needs two characters. */
+const dockerVolumeNamePattern = /^[A-Za-z0-9][A-Za-z0-9_.-]+$/;
+const isDirectoryMode = (valueArg) => Number.isSafeInteger(valueArg)
+    && valueArg >= 0
+    && (valueArg & ~serviceVolumeInitializationContract.directoryModeBits) === 0;
+const validateOwnership = (valueArg, pathArg) => {
+    if (!isPlainRecord(valueArg))
+        return [`${pathArg} must use its exact schema`];
+    if (valueArg.kind === 'explicit') {
+        if (!hasExactKeys(valueArg, ['kind', 'uid', 'gid', 'mode']))
+            return [`${pathArg} must use its exact schema`];
+        const errors = [];
+        if (!isRuntimeIdentityNumber(valueArg.uid) || !isRuntimeIdentityNumber(valueArg.gid)) {
+            errors.push(`${pathArg} uid and gid must be runtime identity numbers`);
+        }
+        if (!isDirectoryMode(valueArg.mode))
+            errors.push(`${pathArg} mode must hold directory permission bits only`);
+        return errors;
+    }
+    if (valueArg.kind === 'run-as') {
+        if (!hasExactKeys(valueArg, ['kind', 'mode']))
+            return [`${pathArg} must use its exact schema`];
+        return isDirectoryMode(valueArg.mode) ? [] : [`${pathArg} mode must hold directory permission bits only`];
+    }
+    return [`${pathArg} kind must be explicit or run-as`];
+};
+const validateImportSource = (valueArg, pathArg) => {
+    if (!isPlainRecord(valueArg) || valueArg.kind !== 'docker-volume'
+        || !hasExactKeys(valueArg, ['kind', 'volumeName'])) {
+        return [`${pathArg} must be an exact docker-volume source`];
+    }
+    return typeof valueArg.volumeName === 'string'
+        && valueArg.volumeName.length <= serviceVolumeInitializationContract.maximumDockerVolumeNameLength
+        && dockerVolumeNamePattern.test(valueArg.volumeName)
+        ? []
+        : [`${pathArg} volumeName must be a Docker volume name`];
+};
+/** Validates one volume initialization and names every reason it is refused. */
+export const validateServiceVolumeInitialization = (valueArg, pathArg = 'service volume initialization') => {
+    if (!isPlainRecord(valueArg))
+        return [`${pathArg} must use its exact schema`];
+    if (valueArg.kind === 'empty') {
+        if (!hasExactKeys(valueArg, ['kind', 'ownership']))
+            return [`${pathArg} must use its exact schema`];
+        return validateOwnership(valueArg.ownership, `${pathArg} ownership`);
+    }
+    if (valueArg.kind === 'import') {
+        if (!hasExactKeys(valueArg, ['kind', 'source']))
+            return [`${pathArg} must use its exact schema`];
+        return validateImportSource(valueArg.source, `${pathArg} source`);
+    }
+    return [`${pathArg} kind must be empty or import`];
+};
+/**
+ * The claim fields a volume's initialization derives under a runtime spec's `runAs`.
+ *
+ * Absent initialization refuses as `volume-initialization-unknown`; a `run-as` ownership under
+ * `runAs: null` refuses as `volume-ownership-unknown`. Nothing is defaulted. The answer is for the
+ * first generation of a claim only: later generations carry that claim's own initialization and
+ * ownership, whatever `runAs` says by then. A malformed initialization or `runAs` throws.
+ */
+export const deriveServiceVolumeClaimInitialization = (initializationArg, runAsArg) => {
+    if (initializationArg === undefined)
+        return { status: 'refused', reason: 'volume-initialization-unknown' };
+    const errors = validateServiceVolumeInitialization(initializationArg);
+    if (errors.length > 0)
+        throw new Error(errors[0]);
+    if (runAsArg !== null && !(isPlainRecord(runAsArg) && hasExactKeys(runAsArg, ['user', 'group'])
+        && isRuntimeIdentityNumber(runAsArg.user) && isRuntimeIdentityNumber(runAsArg.group))) {
+        throw new Error('runAs must be null or an exact user and group');
+    }
+    if (initializationArg.kind === 'import') {
+        return { status: 'derived', initialization: 'import', initialOwnership: null };
+    }
+    const ownership = initializationArg.ownership;
+    if (ownership.kind === 'explicit') {
+        return { status: 'derived', initialization: 'empty',
+            initialOwnership: { uid: ownership.uid, gid: ownership.gid, mode: ownership.mode } };
+    }
+    if (runAsArg === null)
+        return { status: 'refused', reason: 'volume-ownership-unknown' };
+    return { status: 'derived', initialization: 'empty',
+        initialOwnership: { uid: runAsArg.user, gid: runAsArg.group, mode: ownership.mode } };
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/platform/types.d.ts

@@ -4,6 +4,31 @@ export type TPlatformCapability = 'email' | 'sms' | 'pushnotification' | 'letter
 export type TPlatformAccessMode = 'rpc' | 'binding' | 'sidecar' | 'internal';
 export type TPlatformBindingStatus = 'requested' | 'provisioning' | 'ready' | 'degraded' | 'failed' | 'disabled';
 export type TPlatformDesiredState = 'enabled' | 'disabled';
+export declare const platformBindingStatusReasons: readonly ["legacy-adoption-pending", "legacy-adoption-conflict", "legacy-adoption-mismatch"];
+/**
+ * Why a binding holds the status it reports, where the status alone does not say.
+ *
+ * All three come from Corestore's refusal of a credential binding beside a legacy
+ * `/resources/provision` resource (`code` in its 409 body, read with
+ * `readCorestoreLegacyAdoptionRefusal`):
+ *
+ * - `legacy-adoption-pending` (status `provisioning`): the service owns a legacy resource of this
+ *   capability that no offline adoption authorizes yet. It clears when the operator runs
+ *   Corestore's adoption with the plan Cloudly produced.
+ * - `legacy-adoption-conflict` (status `failed`): the adoption authorizes another binding id, or
+ *   it was already consumed.
+ * - `legacy-adoption-mismatch` (status `failed`): the legacy resource is no longer the one the
+ *   adoption authorized, its database tenant is absent, or the binding's bucket or retention
+ *   intent differs from the legacy bucket's.
+ */
+export type TPlatformBindingStatusReason = typeof platformBindingStatusReasons[number];
+/** The one status each reason is reported with. */
+export declare const getPlatformBindingStatusOfReason: (reasonArg: TPlatformBindingStatusReason) => TPlatformBindingStatus;
+/**
+ * Validates a reported status and its optional reason: a reason must be a member of the
+ * vocabulary and come with its one status. An absent reason is valid with every status.
+ */
+export declare const validatePlatformBindingStatusReason: (statusArg: unknown, reasonArg: unknown, pathArg?: string) => string[];
 export type TPlatformEndpointProtocol = 'typedrequest' | 'http' | 'tcp' | 'udp' | 'smtp' | 's3' | 'postgres' | 'mongodb' | 'sip';
 export interface IPlatformCapability {
     id: TPlatformCapability;
@@ -30,6 +55,22 @@ export interface IPlatformServiceEndpoint {
     networkAlias?: string;
     port?: number;
 }
+/**
+ * The legacy Corestore resource an object-storage or database binding adopts.
+ *
+ * Server-managed: only `adoptCorestoreLegacyResources` writes it, in the same write that creates
+ * the binding, and Cloudly refuses it (and `objectstorageBucketName`) on `upsertPlatformBinding`.
+ * `nodeId` is the node whose Corestore holds the resource, so the binding is placed there and
+ * nowhere else; `resourceName` is the legacy database or bucket name; `inventorySha256` is the
+ * legacy inventory the adoption was checked against. An adopted bucket's
+ * `objectstorageBucketName` is the legacy bucket and its `objectstorageRetention.intent` the legacy
+ * intent exactly, or absent when the legacy bucket has none.
+ */
+export interface IPlatformBindingCorestoreLegacyAdoption {
+    nodeId: string;
+    resourceName: string;
+    inventorySha256: string;
+}
 export interface IPlatformBinding {
     id: string;
     serviceId: string;
@@ -44,6 +85,10 @@ export interface IPlatformBinding {
     objectstorageBucketName?: string;
     /** Capability-specific value-free immutable-retention intent and evidence. */
     objectstorageRetention?: IObjectStorageRetentionBinding;
+    /** Server-managed: the legacy Corestore resource this binding adopts. */
+    corestoreLegacyAdoption?: IPlatformBindingCorestoreLegacyAdoption;
+    /** Why the binding holds its status, as the responsible cluster reported it. */
+    statusReason?: TPlatformBindingStatusReason;
     createdAt?: number;
     updatedAt?: number;
 }

package/dist_ts/platform/types.js

@@ -1,2 +1,27 @@
-export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9wbGF0Zm9ybS90eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=
+export const platformBindingStatusReasons = [
+    'legacy-adoption-pending',
+    'legacy-adoption-conflict',
+    'legacy-adoption-mismatch',
+];
+const platformBindingStatusOfReason = Object.freeze({
+    'legacy-adoption-pending': 'provisioning',
+    'legacy-adoption-conflict': 'failed',
+    'legacy-adoption-mismatch': 'failed',
+});
+/** The one status each reason is reported with. */
+export const getPlatformBindingStatusOfReason = (reasonArg) => platformBindingStatusOfReason[reasonArg];
+/**
+ * Validates a reported status and its optional reason: a reason must be a member of the
+ * vocabulary and come with its one status. An absent reason is valid with every status.
+ */
+export const validatePlatformBindingStatusReason = (statusArg, reasonArg, pathArg = 'platform binding statusReason') => {
+    if (reasonArg === undefined)
+        return [];
+    if (!platformBindingStatusReasons.includes(reasonArg)) {
+        return [`${pathArg} must be a platform binding status reason`];
+    }
+    return platformBindingStatusOfReason[reasonArg] === statusArg
+        ? []
+        : [`${pathArg} ${reasonArg} requires status ${platformBindingStatusOfReason[reasonArg]}`];
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9wbGF0Zm9ybS90eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFtQkEsTUFBTSxDQUFDLE1BQU0sNEJBQTRCLEdBQUc7SUFDMUMseUJBQXlCO0lBQ3pCLDBCQUEwQjtJQUMxQiwwQkFBMEI7Q0FDbEIsQ0FBQztBQW9CWCxNQUFNLDZCQUE2QixHQUNqQyxNQUFNLENBQUMsTUFBTSxDQUFDO0lBQ1oseUJBQXlCLEVBQUUsY0FBYztJQUN6QywwQkFBMEIsRUFBRSxRQUFRO0lBQ3BDLDBCQUEwQixFQUFFLFFBQVE7Q0FDckMsQ0FBQyxDQUFDO0FBRUwsbURBQW1EO0FBQ25ELE1BQU0sQ0FBQyxNQUFNLGdDQUFnQyxHQUFHLENBQzlDLFNBQXVDLEVBQ2YsRUFBRSxDQUFDLDZCQUE2QixDQUFDLFNBQVMsQ0FBQyxDQUFDO0FBRXRFOzs7R0FHRztBQUNILE1BQU0sQ0FBQyxNQUFNLG1DQUFtQyxHQUFHLENBQ2pELFNBQWtCLEVBQ2xCLFNBQWtCLEVBQ2xCLE9BQU8sR0FBRywrQkFBK0IsRUFDL0IsRUFBRTtJQUNaLElBQUksU0FBUyxLQUFLLFNBQVM7UUFBRSxPQUFPLEVBQUUsQ0FBQztJQUN2QyxJQUFJLENBQUUsNEJBQW1ELENBQUMsUUFBUSxDQUFDLFNBQVMsQ0FBQyxFQUFFLENBQUM7UUFDOUUsT0FBTyxDQUFDLEdBQUcsT0FBTywyQ0FBMkMsQ0FBQyxDQUFDO0lBQ2pFLENBQUM7SUFDRCxPQUFPLDZCQUE2QixDQUFDLFNBQXlDLENBQUMsS0FBSyxTQUFTO1FBQzNGLENBQUMsQ0FBQyxFQUFFO1FBQ0osQ0FBQyxDQUFDLENBQUMsR0FBRyxPQUFPLElBQUksU0FBbUIsb0JBQW9CLDZCQUE2QixDQUFDLFNBQXlDLENBQUMsRUFBRSxDQUFDLENBQUM7QUFDeEksQ0FBQyxDQUFDIn0=

package/dist_ts/requests/corestore.d.ts

@@ -1,5 +1,7 @@
 import * as plugins from '../plugins.js';
 import type { IIdentity } from '../data/user.js';
+import type { ICorestoreLegacyResourceAdoptionPlanEntry, ICorestoreLegacyResourceSelection, TClusterCorestoreLegacyResourceInventory } from '../data/corestorelegacyadoption.js';
+import type { IPlatformBinding } from '../platform/types.js';
 /**
  * A provisioned corestore resource (NoSQLDB database or ObjectStorage bucket)
  * as reported by a node's corestore control API.
@@ -131,3 +133,61 @@ export interface IReq_Cloudly_Coreflow_GetCorestoreInventory extends plugins.typ
         inventory: ICorestoreNodeInventory;
     };
 }
+/**
+ * Cloudly asks the relay for one exact node's legacy Corestore resources.
+ *
+ * The relay reads Corestore's `corestoreLegacyAdoptionContract.inventoryPath` with the control
+ * token and answers `reachable: true` with its services, or `reachable: false` with the reason, never
+ * an empty list for a node it could not read.
+ */
+export interface IReq_Cloudly_Relay_GetClusterCorestoreLegacyResources extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_Cloudly_Relay_GetClusterCorestoreLegacyResources> {
+    method: 'getClusterCorestoreLegacyResources';
+    request: {
+        nodeId: string;
+    };
+    response: {
+        inventory: TClusterCorestoreLegacyResourceInventory;
+    };
+}
+/**
+ * An administrator reads one node's legacy Corestore resources through its cluster's relay, with
+ * the digest an adoption is checked against (`null` for an unreachable node).
+ */
+export interface IReq_Any_Cloudly_GetCorestoreLegacyResources extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_Any_Cloudly_GetCorestoreLegacyResources> {
+    method: 'getCorestoreLegacyResources';
+    request: {
+        identity: IIdentity;
+        clusterId: string;
+        nodeId: string;
+    };
+    response: {
+        inventory: TClusterCorestoreLegacyResourceInventory;
+        inventorySha256: string | null;
+    };
+}
+/**
+ * The only path that creates a binding carrying a legacy bucket name.
+ *
+ * Cloudly reads the node's legacy inventory again, requires `expectedInventorySha256`, and for
+ * each selected resource creates the adopting binding in one transaction: enabled, placed on
+ * `nodeId`, with `corestoreLegacyAdoption`, and for a bucket the legacy bucket name and retention
+ * intent (`validatePlatformBindingCorestoreLegacyAdoption`). A resource whose adopting binding
+ * already exists is answered unchanged. The response lists the adopting bindings and the plan
+ * (`createCorestoreLegacyResourceAdoptionPlan`) the operator hands to Corestore's offline
+ * `legacy-resource-adoption` migration. Refusals travel as `ICorestoreLegacyAdoptionErrorData`.
+ */
+export interface IReq_Any_Cloudly_AdoptCorestoreLegacyResources extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_Any_Cloudly_AdoptCorestoreLegacyResources> {
+    method: 'adoptCorestoreLegacyResources';
+    request: {
+        identity: IIdentity;
+        clusterId: string;
+        nodeId: string;
+        expectedInventorySha256: string;
+        /** Sorted by service then capability (`validateCorestoreLegacyResourceSelections`). */
+        resources: ICorestoreLegacyResourceSelection[];
+    };
+    response: {
+        bindings: IPlatformBinding[];
+        plan: ICorestoreLegacyResourceAdoptionPlanEntry[];
+    };
+}

package/dist_ts/requests/corestore.js

@@ -96,4 +96,4 @@ export const validateClusterCorestoreInventory = (valueArg, pathArg = 'cluster c
     }
     return errors;
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/requests/platform.d.ts

@@ -1,6 +1,6 @@
 import * as plugins from '../plugins.js';
 import type { IIdentity } from '../data/user.js';
-import type { IPlatformBinding, IPlatformCapability, IPlatformProviderConfig, TPlatformBindingStatus } from '../platform/types.js';
+import type { IPlatformBinding, IPlatformCapability, IPlatformProviderConfig, TPlatformBindingStatus, TPlatformBindingStatusReason } from '../platform/types.js';
 export interface IReq_Any_Cloudly_GetPlatformDesiredState extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_Any_Cloudly_GetPlatformDesiredState> {
     method: 'getPlatformDesiredState';
     request: {
@@ -111,6 +111,11 @@ export interface IReq_Any_Cloudly_UpdatePlatformBindingStatus extends plugins.ty
         endpoints?: IPlatformBinding['endpoints'];
         /** Reports the exact provider-returned bucket for an objectstorage binding. */
         objectstorageBucketName?: IPlatformBinding['objectstorageBucketName'];
+        /**
+         * Why the binding holds `status`; `validatePlatformBindingStatusReason` pairs each reason with
+         * its one status. Absent clears a stored reason.
+         */
+        statusReason?: TPlatformBindingStatusReason;
         errorText?: string;
     };
     response: {

package/dist_ts/requests/service.d.ts

@@ -2,6 +2,7 @@ import * as plugins from '../plugins.js';
 import type { IService } from '../data/service.js';
 import type { TServiceUpdateWritableData, TServiceWritableData } from '../data/service.js';
 import type { IServicePlacement } from '../data/service.js';
+import type { TServiceVolumeInitialization } from '../data/servicevolumeinitialization.js';
 import type { IRegistryTarget } from '../data/registry.js';
 import type { IIdentity, IIdentityCredential } from '../data/user.js';
 import type { IImageRelease } from '../data/immutableimage.js';
@@ -267,6 +268,28 @@ export interface IRequest_Any_Cloudly_DeleteServiceById extends plugins.typedreq
         success: boolean;
     };
 }
+/**
+ * Sets how one declared volume's node-local storage claim starts, the only write of
+ * `IServiceVolume.initialization`.
+ *
+ * The volume is named by its exact declared `mountPath`. `expected` is the initialization the
+ * caller read, or `null` when the volume has none; any other stored value refuses as `conflict`.
+ * While a bound local storage claim of the volume exists, a different initialization refuses as
+ * `volume-initialization-bound`. Refusals travel as `IServiceVolumeInitializationErrorData`.
+ */
+export interface IRequest_Any_Cloudly_SetServiceVolumeInitialization extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IRequest_Any_Cloudly_SetServiceVolumeInitialization> {
+    method: 'setServiceVolumeInitialization';
+    request: {
+        identity: IIdentity;
+        serviceId: string;
+        mountPath: string;
+        expected: TServiceVolumeInitialization | null;
+        initialization: TServiceVolumeInitialization;
+    };
+    response: {
+        service: IService;
+    };
+}
 /**
  * Writes the complete runtime spec of one service.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serve.zone/interfaces",
-  "version": "32.22.0",
+  "version": "32.24.0",
   "private": false,
   "description": "Shared TypeScript interfaces and TypedRequest contracts for the serve.zone ecosystem.",
   "exports": {