@cobaltcore-dev/aurora 0.12.1 → 0.13.0

package/dist/server/index.js

@@ -4163,10 +4163,10 @@ var require_wrap_handler = __commonJS({
 var require_dispatcher = __commonJS({
   "../../node_modules/.pnpm/undici@7.28.0/node_modules/undici/lib/dispatcher/dispatcher.js"(exports2, module2) {
     "use strict";
-    var EventEmitter3 = require("events");
+    var EventEmitter4 = require("events");
     var WrapHandler = require_wrap_handler();
     var wrapInterceptor = /* @__PURE__ */ __name((dispatch) => (opts, handler) => dispatch(opts, WrapHandler.wrap(handler)), "wrapInterceptor");
-    var Dispatcher = class Dispatcher extends EventEmitter3 {
+    var Dispatcher = class Dispatcher extends EventEmitter4 {
       static {
         __name(this, "Dispatcher");
       }
@@ -11756,7 +11756,7 @@ var require_socks5_utils = __commonJS({
 var require_socks5_client = __commonJS({
   "../../node_modules/.pnpm/undici@7.28.0/node_modules/undici/lib/core/socks5-client.js"(exports2, module2) {
     "use strict";
-    var { EventEmitter: EventEmitter3 } = require("events");
+    var { EventEmitter: EventEmitter4 } = require("events");
     var { Buffer: Buffer2 } = require("buffer");
     var { InvalidArgumentError, Socks5ProxyError } = require_errors();
     var { debuglog } = require("util");
@@ -11801,7 +11801,7 @@ var require_socks5_client = __commonJS({
       ERROR: "error",
       CLOSED: "closed"
     };
-    var Socks5Client = class Socks5Client extends EventEmitter3 {
+    var Socks5Client = class Socks5Client extends EventEmitter4 {
       static {
         __name(this, "Socks5Client");
       }
@@ -18571,9 +18571,9 @@ var require_memory_cache_store = __commonJS({
   "../../node_modules/.pnpm/undici@7.28.0/node_modules/undici/lib/cache/memory-cache-store.js"(exports2, module2) {
     "use strict";
     var { Writable } = require("stream");
-    var { EventEmitter: EventEmitter3 } = require("events");
+    var { EventEmitter: EventEmitter4 } = require("events");
     var { assertCacheKey, assertCacheValue } = require_cache();
-    var MemoryCacheStore = class MemoryCacheStore extends EventEmitter3 {
+    var MemoryCacheStore = class MemoryCacheStore extends EventEmitter4 {
       static {
         __name(this, "MemoryCacheStore");
       }
@@ -33743,6 +33743,15 @@ var updateMetadataInputSchema = projectScopedInputSchema.extend({
   objectKey: import_zod13.z.string().min(1),
   metadata: import_zod13.z.record(import_zod13.z.string(), import_zod13.z.string())
 });
+var downloadObjectInputSchema2 = projectScopedInputSchema.extend({
+  containerName: import_zod13.z.string().min(1),
+  objectKey: import_zod13.z.string().min(1),
+  filename: import_zod13.z.string().min(1),
+  downloadId: import_zod13.z.string().min(1)
+});
+var watchDownloadProgressInputSchema = projectScopedInputSchema.extend({
+  downloadId: import_zod13.z.string().min(1)
+});
 var s3ServiceInfoSchema = import_zod13.z.object({
   // Limits
   limits: import_zod13.z.object({
@@ -34073,11 +34082,52 @@ var containerRouter = {
 var import_client_s33 = require("@aws-sdk/client-s3");
 var import_server13 = require("@trpc/server");
 var import_zod14 = require("zod");
+var import_node_events3 = __toESM(require("events"));
+var downloadProgressEmitter2 = new import_node_events3.default();
+downloadProgressEmitter2.setMaxListeners(0);
+var downloadProgressMap2 = /* @__PURE__ */ new Map();
 var deleteAllObjectsInputSchema = import_zod14.z.object({
   project_id: import_zod14.z.string(),
   containerName: import_zod14.z.string().min(1),
   includeVersionsAndDeleteMarkers: import_zod14.z.boolean().optional().default(true)
 });
+function resolveMimeFromKey(key) {
+  const ext = key.split(".").pop()?.toLowerCase() ?? "";
+  const map = {
+    // Images
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    png: "image/png",
+    gif: "image/gif",
+    webp: "image/webp",
+    svg: "image/svg+xml",
+    ico: "image/x-icon",
+    bmp: "image/bmp",
+    avif: "image/avif",
+    // Video
+    mp4: "video/mp4",
+    webm: "video/webm",
+    ogv: "video/ogg",
+    // Audio
+    mp3: "audio/mpeg",
+    wav: "audio/wav",
+    ogg: "audio/ogg",
+    flac: "audio/flac",
+    aac: "audio/aac",
+    // Documents / text
+    pdf: "application/pdf",
+    txt: "text/plain",
+    md: "text/markdown",
+    csv: "text/csv",
+    log: "text/plain",
+    xml: "application/xml",
+    json: "application/json",
+    html: "text/html",
+    htm: "text/html"
+  };
+  return map[ext] ?? "application/octet-stream";
+}
+__name(resolveMimeFromKey, "resolveMimeFromKey");
 var objectRouter = {
   /**
   * List objects in a container with optional prefix filtering and pagination.
@@ -34580,6 +34630,179 @@ var objectRouter = {
         key: objectKey
       });
     }
+  }),
+  // ============================================================================
+  // DOWNLOAD OPERATIONS
+  // ============================================================================
+  /**
+  * Download a Ceph (S3) object via the BFF, streaming the content as chunks of
+  * base64-encoded data using an async iterable.
+  *
+  * Mirrors the Swift `downloadObject` implementation so the existing client-side
+  * download-assembly logic can be reused unchanged:
+  *   - tRPC iterables use a JSON-based SSE transport, so each yielded value must
+  *     be JSON-serializable. Each Uint8Array chunk is base64-encoded, and the
+  *     content-type + filename are sent only in the first chunk.
+  *   - The server never buffers the whole object in memory; it streams the S3
+  *     `GetObject` body chunk by chunk.
+  *
+  * Progress tracking:
+  *   Per-chunk progress is stored in `downloadProgressMap` and emitted via
+  *   `downloadProgressEmitter`, so a concurrent `watchDownloadProgress`
+  *   subscription can drive a progress bar. The client computes `downloadId`
+  *   as "<bucket>:<objectKey>:<uuid>" and passes it before the mutation starts.
+  *   The id is scoped with the project id to prevent cross-tenant observation.
+  *
+  * Client-side assembly:
+  *   Collect all base64 chunks -> decode each -> concatenate into a single
+  *   Uint8Array -> wrap in a Blob -> trigger <a download>.
+  */
+  downloadObject: cephProtectedProcedure.input(downloadObjectInputSchema2).mutation(async function* ({ ctx, input }) {
+    const s3 = ctx.getCephClient();
+    const { project_id, containerName, objectKey, filename, downloadId } = input;
+    const scopedDownloadId = `${project_id}:${downloadId}`;
+    const emitMappedError = /* @__PURE__ */ __name((error) => {
+      try {
+        mapS3ErrorToTRPCError(error, {
+          operation: "download object",
+          bucket: containerName,
+          key: objectKey
+        });
+      } catch (mappedError) {
+        downloadProgressEmitter2.emit(`progress:${scopedDownloadId}:error`, mappedError);
+        throw mappedError;
+      }
+    }, "emitMappedError");
+    const response = await s3.send(new import_client_s33.GetObjectCommand({
+      Bucket: containerName,
+      Key: objectKey
+    })).catch(emitMappedError);
+    const body = response.Body;
+    if (!body) {
+      emitMappedError(new import_server13.TRPCError({
+        code: "INTERNAL_SERVER_ERROR",
+        message: "S3 response has no body"
+      }));
+    }
+    const rawContentType = response.ContentType ?? "application/octet-stream";
+    const mimeFromKey = resolveMimeFromKey(objectKey);
+    const contentType = mimeFromKey !== "application/octet-stream" ? mimeFromKey : rawContentType;
+    const total = response.ContentLength ?? 0;
+    downloadProgressMap2.set(scopedDownloadId, {
+      downloaded: 0,
+      total,
+      percent: 0
+    });
+    let isFirst = true;
+    let downloaded = 0;
+    try {
+      for await (const value of body) {
+        downloaded += value.byteLength;
+        const progress = downloadProgressMap2.get(scopedDownloadId);
+        progress.downloaded = downloaded;
+        progress.percent = total > 0 ? Math.round(downloaded / total * 100) : 0;
+        downloadProgressEmitter2.emit(`progress:${scopedDownloadId}`, {
+          ...progress
+        });
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        yield {
+          chunk: Buffer.from(value).toString("base64"),
+          downloaded,
+          total,
+          ...isFirst ? {
+            contentType,
+            filename
+          } : {}
+        };
+        isFirst = false;
+      }
+      downloadProgressEmitter2.emit(`progress:${scopedDownloadId}:complete`);
+    } catch (error) {
+      emitMappedError(error);
+    } finally {
+      downloadProgressMap2.delete(scopedDownloadId);
+    }
+  }),
+  /**
+  * Subscribe to real-time download progress for a given `downloadId`.
+  *
+  * Mirrors the Swift `watchDownloadProgress` subscription. The `downloadId` is
+  * computed client-side as "<bucket>:<objectKey>:<uuid>" and passed to
+  * `downloadObject` before the mutation starts, so this subscription can be
+  * opened in advance. Yields `{ downloaded, total, percent }` as bytes flow
+  * through the server; completes when the download finishes or throws on error.
+  */
+  watchDownloadProgress: cephProtectedProcedure.input(watchDownloadProgressInputSchema).subscription(async function* ({ input }) {
+    const { project_id, downloadId } = input;
+    const scopedDownloadId = `${project_id}:${downloadId}`;
+    const current = downloadProgressMap2.get(scopedDownloadId);
+    if (current) {
+      yield {
+        ...current
+      };
+    }
+    const queue = [];
+    let isComplete = false;
+    let isError = false;
+    let caughtError;
+    let waitResolver = null;
+    const onProgress = /* @__PURE__ */ __name((data) => {
+      queue.push(data);
+      waitResolver?.();
+      waitResolver = null;
+    }, "onProgress");
+    const onComplete = /* @__PURE__ */ __name(() => {
+      isComplete = true;
+      waitResolver?.();
+      waitResolver = null;
+    }, "onComplete");
+    const onError = /* @__PURE__ */ __name((err) => {
+      isError = true;
+      caughtError = err instanceof Error ? err : new Error(String(err));
+      waitResolver?.();
+      waitResolver = null;
+    }, "onError");
+    downloadProgressEmitter2.on(`progress:${scopedDownloadId}`, onProgress);
+    downloadProgressEmitter2.on(`progress:${scopedDownloadId}:complete`, onComplete);
+    downloadProgressEmitter2.on(`progress:${scopedDownloadId}:error`, onError);
+    try {
+      while (!isComplete && !isError) {
+        while (queue.length > 0) {
+          yield {
+            ...queue.shift()
+          };
+        }
+        if (!isComplete && !isError) {
+          let timeoutId;
+          const timeout = new Promise((resolve) => {
+            timeoutId = setTimeout(resolve, 3e4);
+          });
+          try {
+            await Promise.race([
+              new Promise((resolve) => {
+                waitResolver = resolve;
+              }),
+              timeout
+            ]);
+          } finally {
+            if (timeoutId) clearTimeout(timeoutId);
+          }
+          if (!isComplete && !isError && queue.length === 0) break;
+        }
+      }
+      while (queue.length > 0) {
+        yield {
+          ...queue.shift()
+        };
+      }
+      if (isError && caughtError) {
+        throw caughtError;
+      }
+    } finally {
+      downloadProgressEmitter2.off(`progress:${scopedDownloadId}`, onProgress);
+      downloadProgressEmitter2.off(`progress:${scopedDownloadId}:complete`, onComplete);
+      downloadProgressEmitter2.off(`progress:${scopedDownloadId}:error`, onError);
+    }
   })
 };
 
@@ -34730,6 +34953,7 @@ var ec2CredentialRouter = {
 
 // src/server/Storage/routers/ceph/versioningRouter.ts
 var import_client_s34 = require("@aws-sdk/client-s3");
+var import_zod17 = require("zod");
 
 // src/server/Storage/types/versioning.ts
 var import_zod16 = require("zod");
@@ -35043,13 +35267,72 @@ var versioningRouter = {
         key: input.key
       });
     }
+  }),
+  /**
+  * Check if folders contain deleted files (files with delete markers).
+  *
+  * For each folder, performs a query without delimiter to check all nested objects.
+  * Returns whether each folder contains at least one file with a delete marker as latest version.
+  *
+  * Note: This can be expensive for many folders (N S3 requests for N folders).
+  * Use sparingly and consider caching.
+  *
+  * @throws TRPCError NOT_FOUND - bucket does not exist
+  * @throws TRPCError FORBIDDEN - no credentials or access denied
+  */
+  checkDeletedContent: cephProtectedProcedure.input(import_zod17.z.object({
+    project_id: import_zod17.z.string(),
+    bucket: import_zod17.z.string().min(1),
+    folders: import_zod17.z.array(import_zod17.z.string()).max(100)
+  })).query(async ({ ctx, input }) => {
+    const s3 = ctx.getCephClient();
+    try {
+      const results = await Promise.all(input.folders.map(async (folderPrefix) => {
+        try {
+          let hasDeleteMarkers = false;
+          let keyMarker;
+          let versionIdMarker;
+          while (!hasDeleteMarkers) {
+            const response = await s3.send(new import_client_s34.ListObjectVersionsCommand({
+              Bucket: input.bucket,
+              Prefix: folderPrefix,
+              MaxKeys: 100,
+              KeyMarker: keyMarker,
+              VersionIdMarker: versionIdMarker
+            }));
+            hasDeleteMarkers = (response.DeleteMarkers?.length ?? 0) > 0;
+            if (!response.IsTruncated || hasDeleteMarkers) {
+              break;
+            }
+            keyMarker = response.NextKeyMarker;
+            versionIdMarker = response.NextVersionIdMarker;
+          }
+          return {
+            prefix: folderPrefix,
+            hasDeletedContent: hasDeleteMarkers
+          };
+        } catch (error) {
+          console.error(`Failed to check deleted content for folder ${folderPrefix}:`, error);
+          return {
+            prefix: folderPrefix,
+            hasDeletedContent: false
+          };
+        }
+      }));
+      return results;
+    } catch (error) {
+      throw mapS3ErrorToTRPCError(error, {
+        operation: "check deleted content",
+        bucket: input.bucket
+      });
+    }
   })
 };
 
 // src/server/Storage/routers/ceph/bucketPolicyRouter.ts
 var import_client_s35 = require("@aws-sdk/client-s3");
 var import_server15 = require("@trpc/server");
-var import_zod17 = require("zod");
+var import_zod18 = require("zod");
 var policySetRateLimits = /* @__PURE__ */ new Map();
 function checkPolicySetRateLimit(bucketName, projectId) {
   const key = `${projectId}:${bucketName}`;
@@ -35213,7 +35496,7 @@ var bucketPolicyRouter = {
           message: "Invalid JSON format"
         });
       }
-      if (error instanceof import_zod17.z.ZodError) {
+      if (error instanceof import_zod18.z.ZodError) {
         const zodError = error;
         const firstError = zodError.issues?.[0];
         if (!firstError) {
@@ -35399,40 +35682,40 @@ var buildObjectStorageRouters = /* @__PURE__ */ __name((policyDir) => ({
 }), "buildObjectStorageRouters");
 
 // src/server/Project/routers/projectRouter.ts
-var import_zod19 = require("zod");
+var import_zod20 = require("zod");
 var import_server16 = require("@trpc/server");
 
 // src/server/Project/types/models.ts
-var import_zod18 = require("zod");
-var baseProjectSchema = import_zod18.z.object({
-  id: import_zod18.z.string(),
-  name: import_zod18.z.string(),
-  enabled: import_zod18.z.boolean(),
-  domain_id: import_zod18.z.string().nullable().optional(),
-  parent_id: import_zod18.z.string().nullable().optional(),
-  is_domain: import_zod18.z.boolean().nullable().optional(),
-  tags: import_zod18.z.array(import_zod18.z.string()).nullable().optional(),
-  options: import_zod18.z.record(import_zod18.z.string(), import_zod18.z.string().or(import_zod18.z.boolean())).nullable().optional(),
-  description: import_zod18.z.string().nullable().optional(),
-  links: import_zod18.z.object({
-    self: import_zod18.z.string().url().nullable().optional()
+var import_zod19 = require("zod");
+var baseProjectSchema = import_zod19.z.object({
+  id: import_zod19.z.string(),
+  name: import_zod19.z.string(),
+  enabled: import_zod19.z.boolean(),
+  domain_id: import_zod19.z.string().nullable().optional(),
+  parent_id: import_zod19.z.string().nullable().optional(),
+  is_domain: import_zod19.z.boolean().nullable().optional(),
+  tags: import_zod19.z.array(import_zod19.z.string()).nullable().optional(),
+  options: import_zod19.z.record(import_zod19.z.string(), import_zod19.z.string().or(import_zod19.z.boolean())).nullable().optional(),
+  description: import_zod19.z.string().nullable().optional(),
+  links: import_zod19.z.object({
+    self: import_zod19.z.string().url().nullable().optional()
   }).optional()
 });
 var projectSchema = baseProjectSchema.extend({
-  domain_name: import_zod18.z.string().optional(),
-  parents: import_zod18.z.array(import_zod18.z.object({
+  domain_name: import_zod19.z.string().optional(),
+  parents: import_zod19.z.array(import_zod19.z.object({
     project: baseProjectSchema
   })).optional()
 });
-var projectResponseSchema = import_zod18.z.object({
+var projectResponseSchema = import_zod19.z.object({
   project: projectSchema
 });
-var projectsResponseSchema = import_zod18.z.object({
-  projects: import_zod18.z.array(projectSchema),
-  links: import_zod18.z.object({
-    self: import_zod18.z.string().url().optional(),
-    previous: import_zod18.z.string().url().nullable().optional(),
-    next: import_zod18.z.string().url().nullable().optional()
+var projectsResponseSchema = import_zod19.z.object({
+  projects: import_zod19.z.array(projectSchema),
+  links: import_zod19.z.object({
+    self: import_zod19.z.string().url().optional(),
+    previous: import_zod19.z.string().url().nullable().optional(),
+    next: import_zod19.z.string().url().nullable().optional()
   }).optional()
 });
 
@@ -35518,10 +35801,10 @@ var projectRouter = {
       return void 0;
     }
     const domainsData = domainsResponse ? await domainsResponse.json().catch(() => null) : null;
-    const domainsResponseSchema = import_zod19.z.object({
-      domains: import_zod19.z.array(import_zod19.z.object({
-        id: import_zod19.z.string(),
-        name: import_zod19.z.string()
+    const domainsResponseSchema = import_zod20.z.object({
+      domains: import_zod20.z.array(import_zod20.z.object({
+        id: import_zod20.z.string(),
+        name: import_zod20.z.string()
       }))
     });
     const parsedDomains = domainsResponseSchema.safeParse(domainsData);
@@ -35541,8 +35824,8 @@ var projectRouter = {
   * filtered by the optional search term. Uses the OpenStack /v3/auth/projects
   * endpoint which works with any valid token.
   */
-  searchProjects: protectedProcedure.input(import_zod19.z.object({
-    search: import_zod19.z.string().optional()
+  searchProjects: protectedProcedure.input(import_zod20.z.object({
+    search: import_zod20.z.string().optional()
   }).optional()).query(async ({ ctx, input }) => {
     if (!ctx.openstack) {
       throw new import_server16.TRPCError({
@@ -35641,16 +35924,16 @@ function validateOpenstackService(service, serviceName) {
 __name(validateOpenstackService, "validateOpenstackService");
 
 // src/server/Network/types/floatingIp.ts
-var import_zod21 = require("zod");
+var import_zod22 = require("zod");
 
 // src/server/Network/types/index.ts
-var import_zod20 = require("zod");
-var ISO8601TimestampSchema = import_zod20.z.string().brand("ISO8601Timestamp");
-var SortDirSchema = import_zod20.z.enum([
+var import_zod21 = require("zod");
+var ISO8601TimestampSchema = import_zod21.z.string().brand("ISO8601Timestamp");
+var SortDirSchema = import_zod21.z.enum([
   "asc",
   "desc"
 ]);
-var NetworkPortStatusSchema = import_zod20.z.enum([
+var NetworkPortStatusSchema = import_zod21.z.enum([
   "ACTIVE",
   "DOWN",
   "BUILD",
@@ -35658,154 +35941,154 @@ var NetworkPortStatusSchema = import_zod20.z.enum([
 ]);
 
 // src/server/Network/types/floatingIp.ts
-var FloatingIpStatusSchema = import_zod21.z.enum([
+var FloatingIpStatusSchema = import_zod22.z.enum([
   "ACTIVE",
   "DOWN",
   "ERROR"
 ]);
-var PortDetailsSchema = import_zod21.z.object({
+var PortDetailsSchema = import_zod22.z.object({
   /** The status of the port */
   status: FloatingIpStatusSchema,
   /** The name of the port */
-  name: import_zod21.z.string(),
+  name: import_zod22.z.string(),
   /** Administrative state of the port (true = UP, false = DOWN) */
-  admin_state_up: import_zod21.z.boolean(),
+  admin_state_up: import_zod22.z.boolean(),
   /** The ID of the network the port is attached to */
-  network_id: import_zod21.z.string(),
+  network_id: import_zod22.z.string(),
   /** The owner of the port device */
-  device_owner: import_zod21.z.string(),
+  device_owner: import_zod22.z.string(),
   /** The MAC address of the port */
-  mac_address: import_zod21.z.string(),
+  mac_address: import_zod22.z.string(),
   /** The ID of the device the port is attached to */
-  device_id: import_zod21.z.string()
+  device_id: import_zod22.z.string()
 });
-var PortForwardingSchema = import_zod21.z.object({
+var PortForwardingSchema = import_zod22.z.object({
   /** Port forwarding protocol  */
-  protocol: import_zod21.z.enum([
+  protocol: import_zod22.z.enum([
     "tcp",
     "udp"
   ]),
   /** The internal fixed IP address associated with the port forwarding */
-  internal_ip_address: import_zod21.z.string(),
+  internal_ip_address: import_zod22.z.string(),
   /** The internal port number or starting port of the range */
-  internal_port: import_zod21.z.number().optional(),
+  internal_port: import_zod22.z.number().optional(),
   /** The internal port range (e.g., "1024:2048") */
-  internal_port_range: import_zod21.z.string().optional(),
+  internal_port_range: import_zod22.z.string().optional(),
   /** The internal port ID for the port forwarding (requires floating-ip-port-forwarding-detail extension) */
-  internal_port_id: import_zod21.z.string().optional(),
+  internal_port_id: import_zod22.z.string().optional(),
   /** The external port number or starting port of the range */
-  external_port: import_zod21.z.number().optional(),
+  external_port: import_zod22.z.number().optional(),
   /** The external port range (e.g., "8000:9000") */
-  external_port_range: import_zod21.z.string().optional(),
+  external_port_range: import_zod22.z.string().optional(),
   /** The ID of the port forwarding resource */
-  id: import_zod21.z.string(),
+  id: import_zod22.z.string(),
   /** Description of the port forwarding rule (requires floating-ip-port-forwarding-description extension) */
-  description: import_zod21.z.string().nullable().optional()
+  description: import_zod22.z.string().nullable().optional()
 });
-var FloatingIpSchema = import_zod21.z.object({
+var FloatingIpSchema = import_zod22.z.object({
   /** The ID of the router for the floating IP (null if not associated) */
-  router_id: import_zod21.z.string().nullable(),
+  router_id: import_zod22.z.string().nullable(),
   /** A human-readable description for the resource */
-  description: import_zod21.z.string().nullable().optional(),
+  description: import_zod22.z.string().nullable().optional(),
   /** Whether this is a distributed floating IP (requires floating-ip-distributed extension) */
-  distributed: import_zod21.z.boolean().optional(),
+  distributed: import_zod22.z.boolean().optional(),
   /** A valid DNS domain (requires dns-integration extension) */
-  dns_domain: import_zod21.z.string().optional(),
+  dns_domain: import_zod22.z.string().optional(),
   /** A valid DNS name (requires dns-integration extension) */
-  dns_name: import_zod21.z.string().optional(),
+  dns_name: import_zod22.z.string().optional(),
   /** Time at which the resource was created (UTC ISO8601 format, requires standard-attr-timestamp extension) */
   created_at: ISO8601TimestampSchema.optional(),
   /** Time at which the resource was last updated (UTC ISO8601 format, requires standard-attr-timestamp extension) */
   updated_at: ISO8601TimestampSchema.optional(),
   /** The revision number of the resource (set by server, for concurrency control) */
-  revision_number: import_zod21.z.number(),
+  revision_number: import_zod22.z.number(),
   /** The ID of the project that owns the floating IP */
-  project_id: import_zod21.z.string(),
+  project_id: import_zod22.z.string(),
   /** The ID of the tenant (deprecated, use project_id) */
-  tenant_id: import_zod21.z.string(),
+  tenant_id: import_zod22.z.string(),
   /** The ID of the network associated with the floating IP */
-  floating_network_id: import_zod21.z.string(),
+  floating_network_id: import_zod22.z.string(),
   /** The fixed IP address associated with the floating IP (null if not associated) */
-  fixed_ip_address: import_zod21.z.string().nullable(),
+  fixed_ip_address: import_zod22.z.string().nullable(),
   /** The floating IP address */
-  floating_ip_address: import_zod21.z.string(),
+  floating_ip_address: import_zod22.z.string(),
   /** The ID of the port associated with the floating IP (null if not associated) */
-  port_id: import_zod21.z.string().nullable(),
+  port_id: import_zod22.z.string().nullable(),
   /** The ID of the floating IP address */
-  id: import_zod21.z.string(),
+  id: import_zod22.z.string(),
   /** The status of the floating IP */
   status: FloatingIpStatusSchema,
   /** The information of the associated port (null if not associated, requires fip-port-details extension) */
   port_details: PortDetailsSchema.nullable().optional(),
   /** The list of tags on the resource (requires standard-attr-tag extension) */
-  tags: import_zod21.z.array(import_zod21.z.string()).optional(),
+  tags: import_zod22.z.array(import_zod22.z.string()).optional(),
   /** The associated port forwarding resources for the floating IP (requires expose-port-forwarding-in-fip extension) */
-  port_forwardings: import_zod21.z.array(PortForwardingSchema).nullish(),
+  port_forwardings: import_zod22.z.array(PortForwardingSchema).nullish(),
   /** The ID of the QoS policy of the network where this floating IP is plugged (requires qos-fip extension) */
-  qos_network_policy_id: import_zod21.z.string().optional(),
+  qos_network_policy_id: import_zod22.z.string().optional(),
   /** The ID of the QoS policy associated with the floating IP (requires qos extension) */
-  qos_policy_id: import_zod21.z.string().optional()
-});
-var FloatingIpIdInputSchema = import_zod21.z.object({
-  project_id: import_zod21.z.string(),
-  floatingip_id: import_zod21.z.string()
-});
-var FloatingIpCreateRequestSchema = import_zod21.z.object({
-  tenant_id: import_zod21.z.string(),
-  project_id: import_zod21.z.string(),
-  floating_network_id: import_zod21.z.string(),
-  fixed_ip_address: import_zod21.z.string().optional(),
-  floating_ip_address: import_zod21.z.string().optional(),
-  port_id: import_zod21.z.string().optional(),
-  subnet_id: import_zod21.z.string().optional(),
-  distributed: import_zod21.z.boolean().optional(),
-  description: import_zod21.z.string().optional(),
-  dns_domain: import_zod21.z.string().optional(),
-  dns_name: import_zod21.z.string().optional(),
-  qos_policy_id: import_zod21.z.string().optional()
-});
-var FloatingIpUpdateRequestSchema = import_zod21.z.object({
-  project_id: import_zod21.z.string(),
-  floatingip_id: import_zod21.z.string(),
-  port_id: import_zod21.z.string().nullable(),
-  fixed_ip_address: import_zod21.z.string().optional(),
-  description: import_zod21.z.string().optional(),
-  distributed: import_zod21.z.boolean().optional()
-});
-var FloatingIpResponseSchema = import_zod21.z.object({
+  qos_policy_id: import_zod22.z.string().optional()
+});
+var FloatingIpIdInputSchema = import_zod22.z.object({
+  project_id: import_zod22.z.string(),
+  floatingip_id: import_zod22.z.string()
+});
+var FloatingIpCreateRequestSchema = import_zod22.z.object({
+  tenant_id: import_zod22.z.string(),
+  project_id: import_zod22.z.string(),
+  floating_network_id: import_zod22.z.string(),
+  fixed_ip_address: import_zod22.z.string().optional(),
+  floating_ip_address: import_zod22.z.string().optional(),
+  port_id: import_zod22.z.string().optional(),
+  subnet_id: import_zod22.z.string().optional(),
+  distributed: import_zod22.z.boolean().optional(),
+  description: import_zod22.z.string().optional(),
+  dns_domain: import_zod22.z.string().optional(),
+  dns_name: import_zod22.z.string().optional(),
+  qos_policy_id: import_zod22.z.string().optional()
+});
+var FloatingIpUpdateRequestSchema = import_zod22.z.object({
+  project_id: import_zod22.z.string(),
+  floatingip_id: import_zod22.z.string(),
+  port_id: import_zod22.z.string().nullable(),
+  fixed_ip_address: import_zod22.z.string().optional(),
+  description: import_zod22.z.string().optional(),
+  distributed: import_zod22.z.boolean().optional()
+});
+var FloatingIpResponseSchema = import_zod22.z.object({
   floatingip: FloatingIpSchema
 });
-var FloatingIpListResponseSchema = import_zod21.z.object({
+var FloatingIpListResponseSchema = import_zod22.z.object({
   /** A list of floating IP objects */
-  floatingips: import_zod21.z.array(FloatingIpSchema)
+  floatingips: import_zod22.z.array(FloatingIpSchema)
 });
-var FloatingIpQueryParametersSchema = import_zod21.z.object({
+var FloatingIpQueryParametersSchema = import_zod22.z.object({
   /** Project ID for rescoping (required for projectScopedProcedure) */
-  project_id: import_zod21.z.string(),
+  project_id: import_zod22.z.string(),
   /** Filter by the ID of the floating IP */
-  id: import_zod21.z.string().optional(),
+  id: import_zod22.z.string().optional(),
   /** Filter by the ID of the router for the floating IP */
-  router_id: import_zod21.z.string().nullable().optional(),
+  router_id: import_zod22.z.string().nullable().optional(),
   /** Filter by the status of the floating IP */
   status: FloatingIpStatusSchema.optional(),
   /** Filter by the ID of the project that owns the resource */
-  tenant_id: import_zod21.z.string().optional(),
+  tenant_id: import_zod22.z.string().optional(),
   /** Filter by the revision number of the resource */
-  revision_number: import_zod21.z.number().optional(),
+  revision_number: import_zod22.z.number().optional(),
   /** Filter by the human-readable description of the resource */
-  description: import_zod21.z.string().nullable().optional(),
+  description: import_zod22.z.string().nullable().optional(),
   /** Filter by the ID of the network associated with the floating IP */
-  floating_network_id: import_zod21.z.string().optional(),
+  floating_network_id: import_zod22.z.string().optional(),
   /** Filter by the fixed IP address associated with the floating IP */
-  fixed_ip_address: import_zod21.z.string().optional(),
+  fixed_ip_address: import_zod22.z.string().optional(),
   /** Filter by the floating IP address */
-  floating_ip_address: import_zod21.z.string().optional(),
+  floating_ip_address: import_zod22.z.string().optional(),
   /** Filter by the ID of a port associated with the floating IP */
-  port_id: import_zod21.z.string().nullable().optional(),
+  port_id: import_zod22.z.string().nullable().optional(),
   /** Sort direction (asc or desc) */
   sort_dir: SortDirSchema.optional(),
   /** Sort key - valid keys: fixed_ip_address, floating_ip_address, floating_network_id, id, router_id, status, tenant_id, project_id */
-  sort_key: import_zod21.z.enum([
+  sort_key: import_zod22.z.enum([
     "fixed_ip_address",
     "floating_ip_address",
     "floating_network_id",
@@ -35816,73 +36099,73 @@ var FloatingIpQueryParametersSchema = import_zod21.z.object({
     "project_id"
   ]).optional(),
   /** Filter by tags (comma-separated, resources must match all tags) -  requires standard-attr-tag extension */
-  tags: import_zod21.z.array(import_zod21.z.string()).optional(),
+  tags: import_zod22.z.array(import_zod22.z.string()).optional(),
   /** Filter by tags with OR logic (comma-separated, resources match any tag) */
-  "tags-any": import_zod21.z.string().optional(),
+  "tags-any": import_zod22.z.string().optional(),
   /** Exclude resources with these tags (comma-separated, resources must match all excluded tags) */
-  "not-tags": import_zod21.z.string().optional(),
+  "not-tags": import_zod22.z.string().optional(),
   /** Exclude resources with these tags using OR logic (comma-separated, resources match any excluded tag) */
-  "not-tags-any": import_zod21.z.string().optional(),
+  "not-tags-any": import_zod22.z.string().optional(),
   /** Specific fields to return (can be repeated) */
-  fields: import_zod21.z.union([
-    import_zod21.z.string(),
-    import_zod21.z.array(import_zod21.z.string())
+  fields: import_zod22.z.union([
+    import_zod22.z.string(),
+    import_zod22.z.array(import_zod22.z.string())
   ]).optional(),
   /** Pagination limit */
-  limit: import_zod21.z.number().optional(),
+  limit: import_zod22.z.number().optional(),
   /** Pagination marker (ID of the last item in the previous list) */
-  marker: import_zod21.z.string().optional(),
+  marker: import_zod22.z.string().optional(),
   /** Pagination direction (false = ascending, true = descending) */
-  page_reverse: import_zod21.z.boolean().optional(),
+  page_reverse: import_zod22.z.boolean().optional(),
   // BFF-side search (filtered in BFF layer, not sent to OpenStack)
-  searchTerm: import_zod21.z.string().optional()
-});
-var ExternalNetworksQuerySchema = import_zod21.z.object({
-  project_id: import_zod21.z.string(),
-  "router:external": import_zod21.z.literal(true).default(true)
-});
-var ExternalNetworkSchema = import_zod21.z.object({
-  id: import_zod21.z.string(),
-  name: import_zod21.z.string(),
-  project_id: import_zod21.z.string(),
-  "router:external": import_zod21.z.boolean().optional(),
-  shared: import_zod21.z.boolean(),
+  searchTerm: import_zod22.z.string().optional()
+});
+var ExternalNetworksQuerySchema = import_zod22.z.object({
+  project_id: import_zod22.z.string(),
+  "router:external": import_zod22.z.literal(true).default(true)
+});
+var ExternalNetworkSchema = import_zod22.z.object({
+  id: import_zod22.z.string(),
+  name: import_zod22.z.string(),
+  project_id: import_zod22.z.string(),
+  "router:external": import_zod22.z.boolean().optional(),
+  shared: import_zod22.z.boolean(),
   status: NetworkPortStatusSchema,
   updated_at: ISO8601TimestampSchema.optional(),
-  is_default: import_zod21.z.boolean().optional()
+  is_default: import_zod22.z.boolean().optional()
 });
-var ExternalNetworksResponseSchema = import_zod21.z.object({
-  networks: import_zod21.z.array(ExternalNetworkSchema)
+var ExternalNetworksResponseSchema = import_zod22.z.object({
+  networks: import_zod22.z.array(ExternalNetworkSchema)
 });
-var DnsDomainSchema = import_zod21.z.object({
-  id: import_zod21.z.string(),
-  name: import_zod21.z.string()
+var DnsDomainSchema = import_zod22.z.object({
+  id: import_zod22.z.string(),
+  name: import_zod22.z.string()
 });
-var DnsDomainResponseSchema = import_zod21.z.object({
-  zones: import_zod21.z.array(DnsDomainSchema)
+var DnsDomainResponseSchema = import_zod22.z.object({
+  zones: import_zod22.z.array(DnsDomainSchema)
 });
-var AvailablePortsQuerySchema = import_zod21.z.object({
-  project_id: import_zod21.z.string(),
+var AvailablePortsQuerySchema = import_zod22.z.object({
+  project_id: import_zod22.z.string(),
   /** Only ACTIVE ports are eligible for floating IP association */
-  status: import_zod21.z.literal("ACTIVE").default("ACTIVE"),
+  status: import_zod22.z.literal("ACTIVE").default("ACTIVE"),
   /** Only administratively UP ports are eligible for floating IP association */
-  admin_state_up: import_zod21.z.literal(true).default(true)
+  admin_state_up: import_zod22.z.literal(true).default(true)
 });
-var AvailablePortSchema = import_zod21.z.object({
+var AvailablePortSchema = import_zod22.z.object({
   /** The ID of the port */
-  id: import_zod21.z.string(),
+  id: import_zod22.z.string(),
   /** Human-readable name of the port */
-  name: import_zod21.z.string().nullable().optional(),
+  name: import_zod22.z.string().nullable().optional(),
   /** List of fixed IPs assigned to the port, each entry pairs an IP address with its subnet. */
-  fixed_ips: import_zod21.z.array(import_zod21.z.object({
+  fixed_ips: import_zod22.z.array(import_zod22.z.object({
     /** The fixed IP address assigned to the port */
-    ip_address: import_zod21.z.string(),
+    ip_address: import_zod22.z.string(),
     /** The ID of the subnet the IP belongs to */
-    subnet_id: import_zod21.z.string().optional()
+    subnet_id: import_zod22.z.string().optional()
   })).optional()
 });
-var AvailablePortsResponseSchema = import_zod21.z.object({
-  ports: import_zod21.z.array(AvailablePortSchema)
+var AvailablePortsResponseSchema = import_zod22.z.object({
+  ports: import_zod22.z.array(AvailablePortSchema)
 });
 
 // src/server/Network/helpers/errorHandling.ts
@@ -36129,110 +36412,110 @@ var floatingIpRouter = {
 };
 
 // src/server/Network/types/securityGroup.ts
-var import_zod22 = require("zod");
-var securityGroupRuleSchema = import_zod22.z.object({
-  id: import_zod22.z.string(),
-  direction: import_zod22.z.enum([
+var import_zod23 = require("zod");
+var securityGroupRuleSchema = import_zod23.z.object({
+  id: import_zod23.z.string(),
+  direction: import_zod23.z.enum([
     "ingress",
     "egress"
   ]).optional(),
-  ethertype: import_zod22.z.enum([
+  ethertype: import_zod23.z.enum([
     "IPv4",
     "IPv6"
   ]).optional(),
-  description: import_zod22.z.string().nullable().optional(),
-  security_group_id: import_zod22.z.string().optional(),
-  protocol: import_zod22.z.string().nullable().optional(),
-  port_range_min: import_zod22.z.number().nullable().optional(),
-  port_range_max: import_zod22.z.number().nullable().optional(),
-  remote_ip_prefix: import_zod22.z.string().nullable().optional(),
-  remote_group_id: import_zod22.z.string().nullable().optional(),
-  remote_address_group_id: import_zod22.z.string().nullable().optional(),
-  tenant_id: import_zod22.z.string().nullable().optional(),
-  project_id: import_zod22.z.string().nullable().optional(),
-  revision_number: import_zod22.z.number().optional(),
-  tags: import_zod22.z.array(import_zod22.z.string()).optional(),
-  created_at: import_zod22.z.string().optional(),
-  updated_at: import_zod22.z.string().nullable().optional()
-});
-var securityGroupSchema = import_zod22.z.object({
-  id: import_zod22.z.string(),
-  name: import_zod22.z.string().nullable().optional(),
-  description: import_zod22.z.string().nullable().optional(),
-  tenant_id: import_zod22.z.string().nullable().optional(),
-  project_id: import_zod22.z.string().nullable().optional(),
-  stateful: import_zod22.z.boolean().optional(),
-  shared: import_zod22.z.boolean().optional(),
-  tags: import_zod22.z.array(import_zod22.z.string()).optional(),
-  security_group_rules: import_zod22.z.array(securityGroupRuleSchema).optional(),
-  revision_number: import_zod22.z.number().optional(),
-  created_at: import_zod22.z.string().optional(),
-  updated_at: import_zod22.z.string().nullable().optional()
-});
-var securityGroupsResponseSchema = import_zod22.z.object({
-  security_groups: import_zod22.z.array(securityGroupSchema)
+  description: import_zod23.z.string().nullable().optional(),
+  security_group_id: import_zod23.z.string().optional(),
+  protocol: import_zod23.z.string().nullable().optional(),
+  port_range_min: import_zod23.z.number().nullable().optional(),
+  port_range_max: import_zod23.z.number().nullable().optional(),
+  remote_ip_prefix: import_zod23.z.string().nullable().optional(),
+  remote_group_id: import_zod23.z.string().nullable().optional(),
+  remote_address_group_id: import_zod23.z.string().nullable().optional(),
+  tenant_id: import_zod23.z.string().nullable().optional(),
+  project_id: import_zod23.z.string().nullable().optional(),
+  revision_number: import_zod23.z.number().optional(),
+  tags: import_zod23.z.array(import_zod23.z.string()).optional(),
+  created_at: import_zod23.z.string().optional(),
+  updated_at: import_zod23.z.string().nullable().optional()
 });
-var securityGroupResponseSchema = import_zod22.z.object({
+var securityGroupSchema = import_zod23.z.object({
+  id: import_zod23.z.string(),
+  name: import_zod23.z.string().nullable().optional(),
+  description: import_zod23.z.string().nullable().optional(),
+  tenant_id: import_zod23.z.string().nullable().optional(),
+  project_id: import_zod23.z.string().nullable().optional(),
+  stateful: import_zod23.z.boolean().optional(),
+  shared: import_zod23.z.boolean().optional(),
+  tags: import_zod23.z.array(import_zod23.z.string()).optional(),
+  security_group_rules: import_zod23.z.array(securityGroupRuleSchema).optional(),
+  revision_number: import_zod23.z.number().optional(),
+  created_at: import_zod23.z.string().optional(),
+  updated_at: import_zod23.z.string().nullable().optional()
+});
+var securityGroupsResponseSchema = import_zod23.z.object({
+  security_groups: import_zod23.z.array(securityGroupSchema)
+});
+var securityGroupResponseSchema = import_zod23.z.object({
   security_group: securityGroupSchema
 });
-var securityGroupRuleResponseSchema = import_zod22.z.object({
+var securityGroupRuleResponseSchema = import_zod23.z.object({
   security_group_rule: securityGroupRuleSchema
 });
 var listSecurityGroupsInputSchema = projectScopedInputSchema.extend({
   // Sorting
-  sort_key: import_zod22.z.string().optional(),
+  sort_key: import_zod23.z.string().optional(),
   sort_dir: SortDirSchema.optional(),
   // Basic filtering
-  name: import_zod22.z.string().optional(),
-  description: import_zod22.z.string().optional(),
-  tenant_id: import_zod22.z.string().optional(),
-  shared: import_zod22.z.boolean().optional(),
+  name: import_zod23.z.string().optional(),
+  description: import_zod23.z.string().optional(),
+  tenant_id: import_zod23.z.string().optional(),
+  shared: import_zod23.z.boolean().optional(),
   // Tag-based filtering (string values follow Neutron semantics)
-  tags: import_zod22.z.string().optional(),
-  tags_any: import_zod22.z.string().optional(),
-  not_tags: import_zod22.z.string().optional(),
-  not_tags_any: import_zod22.z.string().optional(),
+  tags: import_zod23.z.string().optional(),
+  tags_any: import_zod23.z.string().optional(),
+  not_tags: import_zod23.z.string().optional(),
+  not_tags_any: import_zod23.z.string().optional(),
   // BFF-side search (filtered in BFF layer, not sent to OpenStack)
-  searchTerm: import_zod22.z.string().optional()
+  searchTerm: import_zod23.z.string().optional()
 });
 var getSecurityGroupByIdInputSchema = projectScopedInputSchema.extend({
-  securityGroupId: import_zod22.z.string()
+  securityGroupId: import_zod23.z.string()
 });
 var createSecurityGroupInputSchema = projectScopedInputSchema.extend({
-  name: import_zod22.z.string().min(1, "Name is required"),
-  description: import_zod22.z.string().optional(),
-  stateful: import_zod22.z.boolean().optional()
+  name: import_zod23.z.string().min(1, "Name is required"),
+  description: import_zod23.z.string().optional(),
+  stateful: import_zod23.z.boolean().optional()
 });
 var deleteSecurityGroupInputSchema = projectScopedInputSchema.extend({
-  securityGroupId: import_zod22.z.string()
+  securityGroupId: import_zod23.z.string()
 });
 var updateSecurityGroupInputSchema = projectScopedInputSchema.extend({
-  securityGroupId: import_zod22.z.string(),
-  name: import_zod22.z.string().min(1, "Name is required").optional(),
-  description: import_zod22.z.string().optional(),
-  stateful: import_zod22.z.boolean().optional()
+  securityGroupId: import_zod23.z.string(),
+  name: import_zod23.z.string().min(1, "Name is required").optional(),
+  description: import_zod23.z.string().optional(),
+  stateful: import_zod23.z.boolean().optional()
 });
 var deleteSecurityGroupRuleInputSchema = projectScopedInputSchema.extend({
-  ruleId: import_zod22.z.string()
+  ruleId: import_zod23.z.string()
 });
 var createSecurityGroupRuleInputSchema = projectScopedInputSchema.extend({
-  security_group_id: import_zod22.z.string(),
-  direction: import_zod22.z.enum([
+  security_group_id: import_zod23.z.string(),
+  direction: import_zod23.z.enum([
     "ingress",
     "egress"
   ]),
-  ethertype: import_zod22.z.enum([
+  ethertype: import_zod23.z.enum([
     "IPv4",
     "IPv6"
   ]).default("IPv4"),
-  description: import_zod22.z.string().optional(),
-  protocol: import_zod22.z.string().nullable().optional(),
-  port_range_min: import_zod22.z.number().int().max(65535).nullable().optional(),
-  port_range_max: import_zod22.z.number().int().max(65535).nullable().optional(),
+  description: import_zod23.z.string().optional(),
+  protocol: import_zod23.z.string().nullable().optional(),
+  port_range_min: import_zod23.z.number().int().max(65535).nullable().optional(),
+  port_range_max: import_zod23.z.number().int().max(65535).nullable().optional(),
   // Transform empty strings to undefined for proper validation
-  remote_ip_prefix: import_zod22.z.string().nullable().optional().transform((val) => val === "" ? void 0 : val),
-  remote_group_id: import_zod22.z.string().nullable().optional().transform((val) => val === "" ? void 0 : val),
-  remote_address_group_id: import_zod22.z.string().nullable().optional().transform((val) => val === "" ? void 0 : val)
+  remote_ip_prefix: import_zod23.z.string().nullable().optional().transform((val) => val === "" ? void 0 : val),
+  remote_group_id: import_zod23.z.string().nullable().optional().transform((val) => val === "" ? void 0 : val),
+  remote_address_group_id: import_zod23.z.string().nullable().optional().transform((val) => val === "" ? void 0 : val)
 });
 
 // src/server/Network/helpers/securityGroupHelpers.ts
@@ -36750,42 +37033,42 @@ var securityGroupRuleRouter = {
 };
 
 // src/server/Network/types/rbacPolicy.ts
-var import_zod23 = require("zod");
-var rbacPolicySchema = import_zod23.z.object({
-  id: import_zod23.z.string(),
-  object_type: import_zod23.z.enum([
+var import_zod24 = require("zod");
+var rbacPolicySchema = import_zod24.z.object({
+  id: import_zod24.z.string(),
+  object_type: import_zod24.z.enum([
     "qos_policy",
     "network",
     "security_group"
   ]),
-  object_id: import_zod23.z.string(),
-  action: import_zod23.z.enum([
+  object_id: import_zod24.z.string(),
+  action: import_zod24.z.enum([
     "access_as_shared",
     "access_as_external"
   ]),
-  target_tenant: import_zod23.z.string(),
-  tenant_id: import_zod23.z.string().nullable().optional(),
-  project_id: import_zod23.z.string().nullable().optional()
+  target_tenant: import_zod24.z.string(),
+  tenant_id: import_zod24.z.string().nullable().optional(),
+  project_id: import_zod24.z.string().nullable().optional()
 });
-var rbacPoliciesResponseSchema = import_zod23.z.object({
-  rbac_policies: import_zod23.z.array(rbacPolicySchema)
+var rbacPoliciesResponseSchema = import_zod24.z.object({
+  rbac_policies: import_zod24.z.array(rbacPolicySchema)
 });
-var rbacPolicyResponseSchema = import_zod23.z.object({
+var rbacPolicyResponseSchema = import_zod24.z.object({
   rbac_policy: rbacPolicySchema
 });
 var listRBACPoliciesForSecurityGroupInputSchema = projectScopedInputSchema.extend({
-  securityGroupId: import_zod23.z.string()
+  securityGroupId: import_zod24.z.string()
 });
 var createRBACPolicyInputSchema = projectScopedInputSchema.extend({
-  securityGroupId: import_zod23.z.string(),
-  targetTenant: import_zod23.z.string().trim().min(1, "Target project ID is required")
+  securityGroupId: import_zod24.z.string(),
+  targetTenant: import_zod24.z.string().trim().min(1, "Target project ID is required")
 });
 var updateRBACPolicyInputSchema = projectScopedInputSchema.extend({
-  policyId: import_zod23.z.string(),
-  targetTenant: import_zod23.z.string().trim().min(1, "Target project ID is required")
+  policyId: import_zod24.z.string(),
+  targetTenant: import_zod24.z.string().trim().min(1, "Target project ID is required")
 });
 var deleteRBACPolicyInputSchema = projectScopedInputSchema.extend({
-  policyId: import_zod23.z.string()
+  policyId: import_zod24.z.string()
 });
 
 // src/server/Network/helpers/rbacPolicyHelpers.ts
@@ -37241,128 +37524,128 @@ var buildNetworkRouters = /* @__PURE__ */ __name((policyDir) => ({
 }), "buildNetworkRouters");
 
 // src/server/Services/types/pca.ts
-var import_zod24 = require("zod");
-var CertificateValiditySchema = import_zod24.z.object({
-  not_after: import_zod24.z.number().int(),
-  not_before: import_zod24.z.number().int().optional()
+var import_zod25 = require("zod");
+var CertificateValiditySchema = import_zod25.z.object({
+  not_after: import_zod25.z.number().int(),
+  not_before: import_zod25.z.number().int().optional()
 });
-var CertificateAuthorityCertificateSchema = import_zod24.z.object({
+var CertificateAuthorityCertificateSchema = import_zod25.z.object({
   /** PEM encoded certificate data. */
-  pem: import_zod24.z.string(),
+  pem: import_zod25.z.string(),
   validity: CertificateValiditySchema
 });
-var CertificateAuthorityCertificateChainSchema = import_zod24.z.object({
-  certificates: import_zod24.z.array(import_zod24.z.object({
-    pem: import_zod24.z.string()
+var CertificateAuthorityCertificateChainSchema = import_zod25.z.object({
+  certificates: import_zod25.z.array(import_zod25.z.object({
+    pem: import_zod25.z.string()
   })),
   /** Concatenated PEM certificates of the chain. */
-  pem: import_zod24.z.string()
+  pem: import_zod25.z.string()
 });
-var CertificateAuthorityAdditionalAttributeSchema = import_zod24.z.object({
+var CertificateAuthorityAdditionalAttributeSchema = import_zod25.z.object({
   /** ASN.1 Object Identifier of the attribute */
-  key: import_zod24.z.array(import_zod24.z.number().int()),
-  value: import_zod24.z.string()
+  key: import_zod25.z.array(import_zod25.z.number().int()),
+  value: import_zod25.z.string()
 });
-var CertificateAuthoritySubjectSchema = import_zod24.z.object({
-  additional_attribute: import_zod24.z.array(CertificateAuthorityAdditionalAttributeSchema).optional(),
+var CertificateAuthoritySubjectSchema = import_zod25.z.object({
+  additional_attribute: import_zod25.z.array(CertificateAuthorityAdditionalAttributeSchema).optional(),
   /** Typically domain name */
-  common_name: import_zod24.z.string(),
+  common_name: import_zod25.z.string(),
   /** Country codes (ISO 3166-1 alpha-2). */
-  country: import_zod24.z.array(import_zod24.z.string()).optional(),
+  country: import_zod25.z.array(import_zod25.z.string()).optional(),
   /** Locality/city names. */
-  locality: import_zod24.z.array(import_zod24.z.string()).optional(),
+  locality: import_zod25.z.array(import_zod25.z.string()).optional(),
   /** Organization names. */
-  organization: import_zod24.z.array(import_zod24.z.string()).optional(),
+  organization: import_zod25.z.array(import_zod25.z.string()).optional(),
   /** Organizational unit names. */
-  organizational_unit: import_zod24.z.array(import_zod24.z.string()).optional(),
+  organizational_unit: import_zod25.z.array(import_zod25.z.string()).optional(),
   /** Postal/ZIP codes. */
-  postal_code: import_zod24.z.array(import_zod24.z.string()).optional(),
+  postal_code: import_zod25.z.array(import_zod25.z.string()).optional(),
   /** State or province names. */
-  province: import_zod24.z.array(import_zod24.z.string()).optional(),
-  serial_number: import_zod24.z.string().optional(),
-  street_address: import_zod24.z.array(import_zod24.z.string()).optional()
+  province: import_zod25.z.array(import_zod25.z.string()).optional(),
+  serial_number: import_zod25.z.string().optional(),
+  street_address: import_zod25.z.array(import_zod25.z.string()).optional()
 });
-var CertificateAuthorityStateSchema = import_zod24.z.enum([
+var CertificateAuthorityStateSchema = import_zod25.z.enum([
   "CREATING",
   "AWAITING_CERTIFICATE",
   "READY",
   "FAILED",
   "UNEXPECTED"
 ]);
-var CertificateAuthoritySchema = import_zod24.z.object({
+var CertificateAuthoritySchema = import_zod25.z.object({
   certificate: CertificateAuthorityCertificateSchema.optional(),
   /** Details of Certificate Authority certificate's issuers chain. */
   certificate_chain: CertificateAuthorityCertificateChainSchema.optional(),
-  configuration: import_zod24.z.object({
+  configuration: import_zod25.z.object({
     /** X.509 subject of Certificate Authority. Required on create operation. */
     subject: CertificateAuthoritySubjectSchema
   }).optional(),
-  csr: import_zod24.z.string().optional(),
-  id: import_zod24.z.string(),
+  csr: import_zod25.z.string().optional(),
+  id: import_zod25.z.string(),
   /**
   * Required on import certificate operation.
   * Certificate Authority certificate chain, in PEM format. Consists of concatenated string
   * of Certificate Authority certificate, followed by its intermediate issuing CAs certificates
   * and root issuing CA certificate last.
   */
-  imported_certificate_chain: import_zod24.z.string().optional(),
+  imported_certificate_chain: import_zod25.z.string().optional(),
   /** Identifier of OpenStack project that Certificate Authority belongs. */
-  project_id: import_zod24.z.string(),
+  project_id: import_zod25.z.string(),
   /** Current operational state of Certificate Authority. */
   state: CertificateAuthorityStateSchema
 });
-var LinkSchema = import_zod24.z.object({
-  href: import_zod24.z.string(),
-  rel: import_zod24.z.string()
+var LinkSchema = import_zod25.z.object({
+  href: import_zod25.z.string(),
+  rel: import_zod25.z.string()
 });
-var CertificateAuthoritiesListSchema = import_zod24.z.object({
-  certificate_authorities: import_zod24.z.array(CertificateAuthoritySchema),
-  links: import_zod24.z.array(LinkSchema),
-  next_page_marker: import_zod24.z.string().optional()
+var CertificateAuthoritiesListSchema = import_zod25.z.object({
+  certificate_authorities: import_zod25.z.array(CertificateAuthoritySchema),
+  links: import_zod25.z.array(LinkSchema),
+  next_page_marker: import_zod25.z.string().optional()
 });
 var CertificateAuthoritiesListInputSchema = projectScopedInputSchema.extend({
-  limit: import_zod24.z.number().int().min(1).max(1e3).optional(),
-  next_page_marker: import_zod24.z.string().trim().min(1).optional()
+  limit: import_zod25.z.number().int().min(1).max(1e3).optional(),
+  next_page_marker: import_zod25.z.string().trim().min(1).optional()
 });
-var CertificateAuthorityCreateSchema = import_zod24.z.object({
-  configuration: import_zod24.z.object({
+var CertificateAuthorityCreateSchema = import_zod25.z.object({
+  configuration: import_zod25.z.object({
     subject: CertificateAuthoritySubjectSchema
   })
 });
 var CertificateAuthorityIdInputSchema = projectScopedInputSchema.extend({
-  certificate_authority_id: import_zod24.z.string().min(1)
+  certificate_authority_id: import_zod25.z.string().min(1)
 });
 var CertificateAuthorityCertificatesListInputSchema = CertificateAuthorityIdInputSchema.extend({
-  limit: import_zod24.z.number().int().min(1).max(1e3).optional(),
-  next_page_marker: import_zod24.z.string().trim().min(1).optional()
+  limit: import_zod25.z.number().int().min(1).max(1e3).optional(),
+  next_page_marker: import_zod25.z.string().trim().min(1).optional()
 });
 var CertificateAuthorityImportInputSchema = CertificateAuthorityIdInputSchema.extend({
-  imported_certificate_chain: import_zod24.z.string().min(1)
+  imported_certificate_chain: import_zod25.z.string().min(1)
 });
 var CertificateIdInputSchema = CertificateAuthorityIdInputSchema.extend({
-  certificate_id: import_zod24.z.string().min(1)
+  certificate_id: import_zod25.z.string().min(1)
 });
-var CertificateConfigurationSchema = import_zod24.z.object({
+var CertificateConfigurationSchema = import_zod25.z.object({
   validity: CertificateValiditySchema
 });
 var CreateCertificateInputSchema = projectScopedInputSchema.extend({
-  certificate_authority_id: import_zod24.z.string().min(1),
-  csr: import_zod24.z.string().min(1),
+  certificate_authority_id: import_zod25.z.string().min(1),
+  csr: import_zod25.z.string().min(1),
   configuration: CertificateConfigurationSchema
 });
-var CertificateSchema = import_zod24.z.object({
+var CertificateSchema = import_zod25.z.object({
   certificate: CertificateAuthorityCertificateSchema.optional(),
-  certificate_authority_id: import_zod24.z.string(),
+  certificate_authority_id: import_zod25.z.string(),
   certificate_chain: CertificateAuthorityCertificateChainSchema.optional(),
   configuration: CertificateConfigurationSchema.optional(),
-  csr: import_zod24.z.string().optional(),
-  id: import_zod24.z.string(),
-  project_id: import_zod24.z.string()
+  csr: import_zod25.z.string().optional(),
+  id: import_zod25.z.string(),
+  project_id: import_zod25.z.string()
 });
-var CertificatesListSchema = import_zod24.z.object({
-  certificates: import_zod24.z.array(CertificateSchema),
-  links: import_zod24.z.array(LinkSchema),
-  next_page_marker: import_zod24.z.string().optional()
+var CertificatesListSchema = import_zod25.z.object({
+  certificates: import_zod25.z.array(CertificateSchema),
+  links: import_zod25.z.array(LinkSchema),
+  next_page_marker: import_zod25.z.string().optional()
 });
 
 // src/server/Services/routers/pcaRouter.ts
@@ -37781,7 +38064,7 @@ __name(createContext, "createContext");
 // src/server/server.ts
 var import_path2 = __toESM(require("path"));
 var import_node_stream3 = require("stream");
-var import_zod25 = require("zod");
+var import_zod26 = require("zod");
 
 // src/server/aurora-fastify-plugins/csrfProtection.ts
 var import_csrf_protection = __toESM(require("@fastify/csrf-protection"));
@@ -37989,7 +38272,7 @@ async function createServer(config) {
       router: appRouter,
       createContext: /* @__PURE__ */ __name((opts) => createContext(opts, contextConfig), "createContext"),
       onError: /* @__PURE__ */ __name((err) => {
-        if (err.error.cause instanceof import_zod25.ZodError) err.error.message = err.error.cause.issues.map((e) => e.message).join(",");
+        if (err.error.cause instanceof import_zod26.ZodError) err.error.message = err.error.cause.issues.map((e) => e.message).join(",");
       }, "onError")
     }
   });