@treeseed/sdk 0.12.60 → 0.12.61

package/dist/operations/services/live-hosted-service-checks.js

@@ -16,15 +16,16 @@ import {
   configuredRailwayServices,
   findStaleTreeseedOperationsRunnerResources,
   isTreeseedOperationsRunnerResourceName,
-  railwayLegacyAliasMigrationPolicy
+  railwayObsoleteAliasCleanupPolicy
 } from "./railway-deploy.js";
+import { railwayTreeDxServiceName } from "./railway-source-policy.js";
 import { discoverTreeseedApplications } from "../../hosting/apps.js";
 import {
   collectTreeseedHostedServiceChecks
 } from "./hosted-service-checks.js";
 const DEFAULT_RETRY_ATTEMPTS = 3;
 const DEFAULT_RETRY_INTERVAL_MS = 1500;
-const DEFAULT_RAILWAY_DEPLOYMENT_SETTLE_ATTEMPTS = 120;
+const DEFAULT_RAILWAY_DEPLOYMENT_SETTLE_ATTEMPTS = 12;
 const DEFAULT_RAILWAY_DEPLOYMENT_SETTLE_INTERVAL_MS = 5e3;
 function sleep(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
@@ -92,9 +93,16 @@ async function inspectRailwayServiceDeploymentHealthWithRetry(input) {
       });
       lastDeployment = deployment;
       if (deployment.ok) return deployment;
+      if (input.acceptSleeping && deployment.status === "SLEEPING") {
+        return { ...deployment, ok: true, message: "Serverless deployment is healthy and sleeping until requested." };
+      }
     } catch (error) {
       lastError = error;
     }
+    if (attempt === 0 || (attempt + 1) % 3 === 0) {
+      process.stderr.write(`[trsd][railway][live-check] service=${input.serviceName ?? input.serviceId} attempt=${attempt + 1}/${attempts} status=${lastDeployment?.status ?? "unavailable"}
+`);
+    }
     if (attempt + 1 < attempts) await sleep(intervalMs);
   }
   return lastDeployment ?? {
@@ -236,13 +244,37 @@ async function collectRailwayObservations(options) {
   const inspectedRunnerScopes = /* @__PURE__ */ new Set();
   const selectedServiceKeys = selectedServiceKeySet(options);
   const applications = discoverTreeseedApplications(options.tenantRoot);
+  const environmentCache = /* @__PURE__ */ new Map();
+  const serviceCache = /* @__PURE__ */ new Map();
+  const volumeCache = /* @__PURE__ */ new Map();
+  const environmentsFor = (projectId) => {
+    const existing = environmentCache.get(projectId);
+    if (existing) return existing;
+    const loaded = listRailwayEnvironments({ projectId, env: options.env, fetchImpl: options.fetchImpl });
+    environmentCache.set(projectId, loaded);
+    return loaded;
+  };
+  const servicesFor = (projectId) => {
+    const existing = serviceCache.get(projectId);
+    if (existing) return existing;
+    const loaded = listRailwayServices({ projectId, env: options.env, fetchImpl: options.fetchImpl });
+    serviceCache.set(projectId, loaded);
+    return loaded;
+  };
+  const volumesFor = (projectId) => {
+    const existing = volumeCache.get(projectId);
+    if (existing) return existing;
+    const loaded = listRailwayVolumes({ projectId, env: options.env, fetchImpl: options.fetchImpl }).catch(() => []);
+    volumeCache.set(projectId, loaded);
+    return loaded;
+  };
   try {
     const workspace = await resolveRailwayWorkspaceContext({ env: options.env, fetchImpl: options.fetchImpl });
     const projects = await listRailwayProjects({ workspaceId: workspace.id, env: options.env, fetchImpl: options.fetchImpl });
     const configuredServices = configuredRailwayServices(options.tenantRoot, options.target, options.env).filter((entry) => serviceMatchesAppSelection(entry, options.tenantRoot, options.appId, applications)).filter((entry) => serviceIsSelected(selectedServiceKeys, entry.key));
     const siblingTarget = options.target === "staging" ? "prod" : options.target === "prod" ? "staging" : null;
     const configuredSiblingServices = siblingTarget ? configuredRailwayServices(options.tenantRoot, siblingTarget, options.env, { identityOnly: true }).filter((entry) => entry.enabled !== false).filter((entry) => entry.key === "operationsRunner") : [];
-    const retainedMigrationAliases = options.target === "staging" ? railwayLegacyAliasMigrationPolicy("staging", configuredServices).retainedResourceNames : [];
+    const retainedObsoleteAliases = options.target === "staging" ? railwayObsoleteAliasCleanupPolicy("staging", configuredServices).retainedResourceNames : [];
     if (selectedServiceKeys.size === 0 || selectedServiceKeys.has("api") || selectedServiceKeys.has("operationsRunner")) {
       for (const descriptor of treeseedDatabaseDescriptors(options.tenantRoot, options)) {
         await verifyRailwayPostgresTopology({ descriptor, configuredServices, projects, options, issues });
@@ -257,7 +289,7 @@ async function collectRailwayObservations(options) {
         issues.push(`${service.serviceName}: Railway project ${service.projectName} was not found.`);
         continue;
       }
-      const environments = await listRailwayEnvironments({ projectId: project.id, env: options.env, fetchImpl: options.fetchImpl });
+      const environments = await environmentsFor(project.id);
       const environment = findByName(environments, service.railwayEnvironment);
       if (!environment?.id) {
         issues.push(`${service.serviceName}: Railway environment ${service.railwayEnvironment} was not found.`);
@@ -266,7 +298,7 @@ async function collectRailwayObservations(options) {
       const volumeScope = `${project.id}:${environment.id}`;
       if (!inspectedVolumeScopes.has(volumeScope)) {
         inspectedVolumeScopes.add(volumeScope);
-        const volumes2 = await listRailwayVolumes({ projectId: project.id, env: options.env, fetchImpl: options.fetchImpl }).catch(() => []);
+        const volumes2 = await volumesFor(project.id);
         for (const volume of volumes2) {
           if (isRetainedDetachedRailwayVolume(volume.name)) {
             continue;
@@ -282,23 +314,23 @@ async function collectRailwayObservations(options) {
           }
         }
       }
-      const services = await listRailwayServices({ projectId: project.id, env: options.env, fetchImpl: options.fetchImpl });
+      const services = await servicesFor(project.id);
       const runnerScope = `${project.id}:${environment.id}`;
       if (service.key === "operationsRunner" && !inspectedRunnerScopes.has(runnerScope)) {
         inspectedRunnerScopes.add(runnerScope);
         const desiredRunnerNames = /* @__PURE__ */ new Set([
           ...configuredServices.filter((entry) => entry.key === "operationsRunner").filter((entry) => entry.projectId ? entry.projectId === project.id : entry.projectName === project.name).filter((entry) => normalizeRailwayEnvironmentName(entry.railwayEnvironment) === normalizeRailwayEnvironmentName(environment.name)).map((entry) => entry.serviceName).filter(Boolean),
           ...configuredSiblingServices.filter((entry) => entry.projectId ? entry.projectId === project.id : entry.projectName === project.name).map((entry) => entry.serviceName).filter((name) => Boolean(name) && isTreeseedOperationsRunnerResourceName(name)),
-          ...retainedMigrationAliases.filter((name) => isTreeseedOperationsRunnerResourceName(name) && !name.endsWith("-volume"))
+          ...retainedObsoleteAliases.filter((name) => isTreeseedOperationsRunnerResourceName(name) && !name.endsWith("-volume"))
         ]);
         const desiredRunnerServiceIds = new Set(services.filter((entry) => desiredRunnerNames.has(entry.name)).map((entry) => entry.id));
         for (const staleService of findStaleTreeseedOperationsRunnerResources(services, desiredRunnerNames)) {
           issues.push(`${staleService.name}: stale operations runner Railway service remains in project ${project.name}.`);
         }
-        const volumes2 = await listRailwayVolumes({ projectId: project.id, env: options.env, fetchImpl: options.fetchImpl }).catch(() => []);
+        const volumes2 = await volumesFor(project.id);
         const desiredRunnerVolumeNames = /* @__PURE__ */ new Set([
           ...[...desiredRunnerNames].map((name) => `${name}-volume`),
-          ...retainedMigrationAliases.filter((name) => name.endsWith("-volume"))
+          ...retainedObsoleteAliases.filter((name) => name.endsWith("-volume"))
         ]);
         for (const staleVolume of findStaleTreeseedOperationsRunnerResources(volumes2, desiredRunnerVolumeNames)) {
           const activeInstances = activeRailwayVolumeInstances(staleVolume);
@@ -317,7 +349,7 @@ async function collectRailwayObservations(options) {
       const [instance, variables, volumes] = await Promise.all([
         getRailwayServiceInstance({ serviceId: railwayService.id, environmentId: environment.id, env: options.env, fetchImpl: options.fetchImpl }),
         listRailwayVariables({ projectId: project.id, environmentId: environment.id, serviceId: railwayService.id, env: options.env, fetchImpl: options.fetchImpl }).catch(() => ({})),
-        listRailwayVolumes({ projectId: project.id, env: options.env, fetchImpl: options.fetchImpl }).catch(() => [])
+        volumesFor(project.id)
       ]);
       const mountedVolume = Array.isArray(volumes) ? volumes.find((entry) => {
         const instances = Array.isArray(entry.instances) ? entry.instances : Array.isArray(entry.volumeInstances) ? entry.volumeInstances : [];
@@ -332,6 +364,8 @@ async function collectRailwayObservations(options) {
       const deployment = await inspectRailwayServiceDeploymentHealthWithRetry({
         serviceId: railwayService.id,
         environmentId: environment.id,
+        serviceName: service.serviceName,
+        acceptSleeping: service.runtimeMode === "serverless",
         options
       }).catch((error) => ({
         ok: false,
@@ -394,20 +428,21 @@ async function collectRailwayObservations(options) {
           issues.push(`public-treedx: Railway project ${projectName} was not found.`);
           continue;
         }
-        const environments = await listRailwayEnvironments({ projectId: project.id, env: options.env, fetchImpl: options.fetchImpl });
+        const environments = await environmentsFor(project.id);
         const environment = findByName(environments, environmentName);
         if (!environment?.id) {
           issues.push(`public-treedx: Railway environment ${environmentName} was not found.`);
           continue;
         }
         const [services, volumes] = await Promise.all([
-          listRailwayServices({ projectId: project.id, env: options.env, fetchImpl: options.fetchImpl }),
-          listRailwayVolumes({ projectId: project.id, env: options.env, fetchImpl: options.fetchImpl }).catch(() => [])
+          servicesFor(project.id),
+          volumesFor(project.id)
         ]);
         for (let index = 1; index <= bootstrapCount; index += 1) {
-          const serviceName = indexedName("public-treedx-node", index);
+          const logicalServiceName = indexedName("public-treedx-node", index);
+          const serviceName = railwayTreeDxServiceName(index, options.target);
           const volumeName = `${serviceName}-volume`;
-          const configuredNode = Array.isArray(config.services) ? config.services.find((service2) => service2?.id === serviceName || service2?.name === serviceName) : null;
+          const configuredNode = Array.isArray(config.services) ? config.services.find((service2) => service2?.id === logicalServiceName || service2?.name === logicalServiceName) : null;
           const volumeMountPath = typeof configuredNode?.volumeMountPath === "string" && configuredNode.volumeMountPath.trim() ? configuredNode.volumeMountPath.trim() : "/data";
           const service = findByName(services, serviceName);
           if (!service?.id) {
@@ -417,6 +452,7 @@ async function collectRailwayObservations(options) {
           const deployment = await inspectRailwayServiceDeploymentHealthWithRetry({
             serviceId: service.id,
             environmentId: environment.id,
+            serviceName,
             options
           }).catch((error) => ({
             ok: false,

package/dist/operations/services/local-cleanup.d.ts

@@ -26,4 +26,5 @@ export declare function runTreeseedLocalCleanup(input: {
     mode?: TreeseedLocalCleanupMode;
     docker?: boolean;
     npmCache?: boolean;
+    npmCacheRoot?: string;
 }): TreeseedLocalCleanupReport;

package/dist/operations/services/local-cleanup.js

@@ -1,4 +1,5 @@
 import { existsSync, readdirSync, rmSync, statSync } from "node:fs";
+import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 import { spawnSync } from "node:child_process";
 function directoryBytes(path) {
@@ -12,15 +13,23 @@ function directoryBytes(path) {
 }
 function removeDirectory(root, relativePath) {
   const path = join(root, relativePath);
+  return removeDirectoryPath(relativePath, path);
+}
+function removeDirectoryPath(id, path) {
   const beforeBytes = directoryBytes(path);
-  if (!existsSync(path)) return { id: relativePath, kind: "directory", path, status: "skipped", beforeBytes: 0, afterBytes: 0 };
+  if (!existsSync(path)) return { id, kind: "directory", path, status: "skipped", beforeBytes: 0, afterBytes: 0 };
   try {
     rmSync(path, { recursive: true, force: true });
-    return { id: relativePath, kind: "directory", path, status: "removed", beforeBytes, afterBytes: directoryBytes(path) };
+    return { id, kind: "directory", path, status: "removed", beforeBytes, afterBytes: directoryBytes(path) };
   } catch (error) {
-    return { id: relativePath, kind: "directory", path, status: "failed", beforeBytes, afterBytes: directoryBytes(path), error: error instanceof Error ? error.message : String(error) };
+    return { id, kind: "directory", path, status: "failed", beforeBytes, afterBytes: directoryBytes(path), error: error instanceof Error ? error.message : String(error) };
   }
 }
+function workspaceRepositoryRoots(root) {
+  const packagesRoot = join(root, "packages");
+  if (!existsSync(packagesRoot)) return [];
+  return readdirSync(packagesRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join(packagesRoot, entry.name)).filter((path) => existsSync(join(path, ".git")) || existsSync(join(path, "package.json")) || existsSync(join(path, "treeseed.package.yaml")));
+}
 function runCleanupCommand(id, kind, command, cwd) {
   const result = spawnSync(command[0], command.slice(1), { cwd, encoding: "utf8", maxBuffer: 1024 * 1024 * 16 });
   const exitCode = result.status ?? null;
@@ -37,19 +46,29 @@ function runTreeseedLocalCleanup(input) {
   const root = resolve(input.root);
   const mode = input.mode ?? "standard";
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const beforeBytes = directoryBytes(join(root, ".treeseed"));
+  const npmCacheRoot = resolve(input.npmCacheRoot ?? process.env.npm_config_cache ?? process.env.NPM_CONFIG_CACHE ?? join(homedir(), ".npm"));
+  const npmTemporaryDownloads = join(npmCacheRoot, "_cacache", "tmp");
+  const repositoryRoots = [root, ...workspaceRepositoryRoots(root)];
+  const beforeBytes = repositoryRoots.reduce((total, repositoryRoot) => total + directoryBytes(join(repositoryRoot, ".treeseed")), 0) + directoryBytes(npmTemporaryDownloads);
   const actions = [];
   const directoryTargets = mode === "aggressive" ? [
     ".treeseed/tmp",
     ".treeseed/cache",
-    ".treeseed/scenes/runs",
-    ".treeseed/scenes/matrix",
     ".treeseed/scenes/render"
   ] : [".treeseed/tmp", ".treeseed/cache", ".treeseed/scenes/render"];
-  for (const target of directoryTargets) actions.push(removeDirectory(root, target));
-  if (input.docker === true && mode === "aggressive") actions.push(runCleanupCommand("docker-system-prune", "docker", ["docker", "system", "prune", "--all", "--volumes", "--force"], root));
+  for (const repositoryRoot of repositoryRoots) {
+    const repositoryId = repositoryRoot === root ? "" : `${repositoryRoot.slice(root.length + 1)}:`;
+    for (const target of directoryTargets) {
+      actions.push(removeDirectoryPath(`${repositoryId}${target}`, join(repositoryRoot, target)));
+    }
+  }
+  actions.push(removeDirectoryPath("npm-cache-temporary-downloads", npmTemporaryDownloads));
+  if (input.docker === true && mode === "aggressive") {
+    actions.push(runCleanupCommand("docker-builder-prune", "docker", ["docker", "builder", "prune", "--all", "--force"], root));
+    actions.push(runCleanupCommand("docker-image-prune", "docker", ["docker", "image", "prune", "--all", "--force"], root));
+  }
   if (input.npmCache === true) actions.push(runCleanupCommand("npm-cache-clean", "npm-cache", ["npm", "cache", "clean", "--force"], root));
-  const afterBytes = directoryBytes(join(root, ".treeseed"));
+  const afterBytes = repositoryRoots.reduce((total, repositoryRoot) => total + directoryBytes(join(repositoryRoot, ".treeseed")), 0) + directoryBytes(npmTemporaryDownloads);
   const completedAt = (/* @__PURE__ */ new Date()).toISOString();
   return { ok: actions.every((entry) => entry.status !== "failed"), mode, root, startedAt, completedAt, beforeBytes, afterBytes, reclaimedBytes: Math.max(0, beforeBytes - afterBytes), actions };
 }

package/dist/operations/services/package-adapters.js

@@ -838,12 +838,12 @@ ${needsNodeSetup ? `      - uses: actions/setup-node@v4
 function resolveWorkflowSetupCommand(adapter) {
   const scripts = adapter.metadata.scripts;
   if (isRecord(scripts) && typeof scripts["release:setup"] === "string") {
-    return 'npm run release:setup || (echo "dependency install failed; retrying" && npm run release:setup)';
+    return "npm run release:setup";
   }
-  return 'npm ci || (echo "dependency install failed; retrying" && npm ci)';
+  return "npm ci";
 }
 function resolveDockerImageWorkflowSetupCommand() {
-  return 'npm ci --ignore-scripts || (echo "dependency install failed; retrying" && npm ci --ignore-scripts)';
+  return "npm ci --ignore-scripts";
 }
 function isRecord(value) {
   return value != null && typeof value === "object" && !Array.isArray(value);

package/dist/operations/services/railway-api.d.ts

@@ -86,6 +86,7 @@ export declare function isUsableRailwayToken(value: string | undefined | null):
 export declare function resolveRailwayApiToken(env?: NodeJS.ProcessEnv | Record<string, string | undefined>): string;
 export declare function resolveRailwayApiUrl(env?: NodeJS.ProcessEnv | Record<string, string | undefined>): string;
 export declare function resolveRailwayWorkspace(env?: NodeJS.ProcessEnv | Record<string, string | undefined>): string;
+export declare function assertRailwayGraphqlReadOnly(document: string): void;
 export declare function railwayGraphqlRequest<TData = unknown>({ query, variables, env, apiToken, apiUrl, fetchImpl, timeoutMs, retries, }: {
     query: string;
     variables?: Record<string, unknown>;
@@ -167,19 +168,29 @@ export declare function ensureRailwayService({ projectId, serviceName, serviceId
     service: RailwayServiceSummary;
     created: boolean;
 }>;
-export declare function updateRailwayServiceImageSource({ serviceId, imageRef, env, fetchImpl, }: {
+export declare function updateRailwayServiceImageSource({ projectId, serviceId, environmentId, imageRef, env, }: {
+    projectId?: string | null;
     serviceId: string;
+    environmentId?: string | null;
     imageRef: string;
     env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
     fetchImpl?: typeof fetch;
-}): Promise<RailwayServiceSummary>;
-export declare function updateRailwayServiceGitSource({ serviceId, sourceRepo, sourceBranch, env, fetchImpl, }: {
+}): Promise<{
+    id: string;
+    name: string;
+}>;
+export declare function updateRailwayServiceGitSource({ projectId, serviceId, environmentId, sourceRepo, sourceBranch, env, }: {
+    projectId?: string | null;
     serviceId: string;
+    environmentId?: string | null;
     sourceRepo: string;
     sourceBranch?: string | null;
     env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
     fetchImpl?: typeof fetch;
-}): Promise<RailwayServiceSummary>;
+}): Promise<{
+    id: string;
+    name: string;
+}>;
 export declare function ensureRailwayGeneratedServiceDomain({ projectId, environmentId, serviceId, targetPort, env, fetchImpl, }: {
     projectId: string;
     environmentId: string;
@@ -198,7 +209,8 @@ export declare function listRailwayServiceDomains({ projectId, environmentId, se
     env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
     fetchImpl?: typeof fetch;
 }): Promise<RailwayServiceDomainSummary[]>;
-export declare function deployRailwayServiceInstance({ serviceId, environmentId, env, fetchImpl, }: {
+export declare function deployRailwayServiceInstance({ projectId, serviceId, environmentId, env, fetchImpl, }: {
+    projectId?: string | null;
     serviceId: string;
     environmentId: string;
     env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
@@ -211,7 +223,7 @@ export declare function updateRailwayServiceName({ serviceId, name, env, fetchIm
     name: string;
     env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
     fetchImpl?: typeof fetch;
-}): Promise<RailwayServiceSummary>;
+}): Promise<void>;
 export declare function ensureRailwayPostgresService({ projectId, environmentId, serviceName, env, fetchImpl, maxAttempts, }: {
     projectId: string;
     environmentId: string;
@@ -220,7 +232,7 @@ export declare function ensureRailwayPostgresService({ projectId, environmentId,
     fetchImpl?: typeof fetch;
     maxAttempts?: number;
 }): Promise<{
-    service: RailwayServiceSummary;
+    service: void | RailwayServiceSummary;
     created: boolean;
     proof: {
         ok: boolean;
@@ -238,10 +250,13 @@ export declare function inspectRailwayServiceDeploymentHealth({ serviceId, envir
 }): Promise<{
     ok: boolean;
     status: string;
+    deploymentStopped: boolean;
+    instanceStatuses: string[];
     branch: string | null;
     repo: string | null;
     rootDirectory: string | null;
     commitHash: string | null;
+    image: string | null;
     requiredMountPath: string | null;
     volumeMounts: any;
     message: string;
@@ -379,31 +394,22 @@ export declare function listRailwayVolumes({ projectId, env, fetchImpl, }: {
     env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
     fetchImpl?: typeof fetch;
 }): Promise<RailwayVolumeSummary[]>;
-export declare function ensureRailwayServiceVolume({ projectId, environmentId, serviceId, name, mountPath, env, fetchImpl, settleAttempts, settleDelayMs, }: {
+export declare function ensureRailwayServiceVolume({ projectId, environmentId, serviceId, name, mountPath, adoptVolumeId, env, fetchImpl, settleAttempts, settleDelayMs, }: {
     projectId: string;
     environmentId: string;
     serviceId: string;
     name: string;
     mountPath: string;
+    adoptVolumeId?: string | null;
     env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
     fetchImpl?: typeof fetch;
     settleAttempts?: number;
     settleDelayMs?: number;
 }): Promise<{
-    volume: {
-        instances: RailwayVolumeInstanceSummary[];
-        id: string;
-        name: string;
-        projectId: string | null;
-    };
+    volume: RailwayVolumeSummary;
     instance: RailwayVolumeInstanceSummary | null;
     created: boolean;
     updated: boolean;
-} | {
-    volume: RailwayVolumeSummary | null;
-    instance: RailwayVolumeInstanceSummary;
-    created: boolean;
-    updated: boolean;
 }>;
 export declare function listRailwayCustomDomains({ projectId, environmentId, serviceId, env, fetchImpl, }: {
     projectId: string;
@@ -423,28 +429,66 @@ export declare function ensureRailwayCustomDomain({ projectId, environmentId, se
     domain: RailwayCustomDomainSummary;
     created: boolean;
 }>;
-export declare function deleteRailwayCustomDomain({ domainId, env, fetchImpl, }: {
+export declare function deleteRailwayCustomDomain({ projectId, environmentId, serviceId, domainId, env, fetchImpl, }: {
+    projectId?: string | null;
+    environmentId?: string | null;
+    serviceId?: string | null;
     domainId: string;
     env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
     fetchImpl?: typeof fetch;
-}): Promise<Record<string, unknown>>;
-export declare function deleteRailwayService({ serviceId, env, fetchImpl, }: {
+}): Promise<{
+    status: string;
+    id: string;
+} | {
+    status: string;
+    id?: undefined;
+}>;
+export declare function deleteRailwayService({ projectId, environmentId, serviceId, env, fetchImpl, }: {
+    projectId?: string | null;
+    environmentId?: string | null;
     serviceId: string;
     env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
     fetchImpl?: typeof fetch;
-}): Promise<Record<string, unknown>>;
-export declare function deleteRailwayVolume({ volumeId, env, fetchImpl, }: {
+}): Promise<{
+    status: string;
+    id: string;
+} | {
+    status: string;
+    id?: undefined;
+}>;
+export declare function deleteRailwayVolume({ projectId, environmentId, volumeId, env, fetchImpl, }: {
+    projectId?: string | null;
+    environmentId?: string | null;
     volumeId: string;
     env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
     fetchImpl?: typeof fetch;
-}): Promise<Record<string, unknown>>;
-export declare function deleteRailwayEnvironment({ environmentId, env, fetchImpl, }: {
+}): Promise<{
+    status: string;
+    id: string;
+} | {
+    status: string;
+    id?: undefined;
+}>;
+export declare function deleteRailwayEnvironment({ projectId, environmentId, env, fetchImpl, }: {
+    projectId?: string | null;
     environmentId: string;
     env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
     fetchImpl?: typeof fetch;
-}): Promise<Record<string, unknown>>;
+}): Promise<{
+    status: string;
+    id: string;
+} | {
+    status: string;
+    id?: undefined;
+}>;
 export declare function deleteRailwayProject({ projectId, env, fetchImpl, }: {
     projectId: string;
     env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
     fetchImpl?: typeof fetch;
-}): Promise<Record<string, unknown>>;
+}): Promise<{
+    status: string;
+    id: string;
+} | {
+    status: string;
+    id?: undefined;
+}>;