@cobaltcore-dev/aurora 0.2.1 → 0.2.2

package/dist/server/index.js

@@ -27677,7 +27677,7 @@ module.exports = __toCommonJS(server_exports);
 var import_fastify = __toESM(require("fastify"));
 var import_static = __toESM(require("@fastify/static"));
 var import_vite = __toESM(require("@fastify/vite"));
-var import_cookie = __toESM(require("@fastify/cookie"));
+var import_cookie2 = __toESM(require("@fastify/cookie"));
 var import_helmet = __toESM(require("@fastify/helmet"));
 var import_rate_limit = __toESM(require("@fastify/rate-limit"));
 var import_multipart = __toESM(require("@fastify/multipart"));
@@ -33251,9 +33251,12 @@ var S3_ERROR_MAP = {
   NoSuchBucket: "NOT_FOUND",
   NoSuchKey: "NOT_FOUND",
   NoSuchUpload: "NOT_FOUND",
+  NoSuchVersion: "NOT_FOUND",
   BucketAlreadyExists: "CONFLICT",
   BucketAlreadyOwnedByYou: "CONFLICT",
   BucketNotEmpty: "PRECONDITION_FAILED",
+  InvalidBucketState: "BAD_REQUEST",
+  VersioningNotEnabled: "PRECONDITION_FAILED",
   AccessDenied: "FORBIDDEN",
   AllAccessDisabled: "FORBIDDEN",
   InvalidAccessKeyId: "UNAUTHORIZED",
@@ -34046,6 +34049,324 @@ var ec2CredentialRouter = {
   })
 };
 
+// src/server/Storage/routers/ceph/versioningRouter.ts
+var import_client_s34 = require("@aws-sdk/client-s3");
+
+// src/server/Storage/types/versioning.ts
+var import_zod16 = require("zod");
+var versioningStatusSchema = import_zod16.z.object({
+  status: import_zod16.z.enum([
+    "Enabled",
+    "Suspended",
+    "Unversioned"
+  ]),
+  mfaDelete: import_zod16.z.enum([
+    "Enabled",
+    "Disabled"
+  ]).optional()
+});
+var setVersioningInputSchema = projectScopedInputSchema.extend({
+  bucket: import_zod16.z.string().min(1),
+  status: import_zod16.z.enum([
+    "Enabled",
+    "Suspended"
+  ])
+});
+var getVersioningStatusInputSchema = projectScopedInputSchema.extend({
+  bucket: import_zod16.z.string().min(1)
+});
+var objectVersionSchema = import_zod16.z.object({
+  key: import_zod16.z.string(),
+  versionId: import_zod16.z.string(),
+  isLatest: import_zod16.z.boolean(),
+  lastModified: import_zod16.z.string(),
+  size: import_zod16.z.number(),
+  storageClass: import_zod16.z.string().optional(),
+  owner: import_zod16.z.object({
+    displayName: import_zod16.z.string().optional(),
+    id: import_zod16.z.string().optional()
+  }).optional(),
+  etag: import_zod16.z.string().optional(),
+  isDeleteMarker: import_zod16.z.boolean().default(false)
+});
+var listVersionsInputSchema = projectScopedInputSchema.extend({
+  bucket: import_zod16.z.string().min(1),
+  prefix: import_zod16.z.string().optional(),
+  keyMarker: import_zod16.z.string().optional(),
+  versionIdMarker: import_zod16.z.string().optional(),
+  maxKeys: import_zod16.z.number().int().positive().max(1e3).optional()
+});
+var listVersionsOutputSchema = import_zod16.z.object({
+  versions: import_zod16.z.array(objectVersionSchema),
+  deleteMarkers: import_zod16.z.array(objectVersionSchema),
+  isTruncated: import_zod16.z.boolean(),
+  nextKeyMarker: import_zod16.z.string().optional(),
+  nextVersionIdMarker: import_zod16.z.string().optional(),
+  prefix: import_zod16.z.string().optional(),
+  maxKeys: import_zod16.z.number().optional()
+});
+var deleteVersionInputSchema = projectScopedInputSchema.extend({
+  bucket: import_zod16.z.string().min(1),
+  key: import_zod16.z.string().min(1),
+  versionId: import_zod16.z.string().min(1)
+});
+var restoreVersionInputSchema = projectScopedInputSchema.extend({
+  bucket: import_zod16.z.string().min(1),
+  key: import_zod16.z.string().min(1),
+  versionId: import_zod16.z.string().min(1)
+});
+var restoreVersionOutputSchema = import_zod16.z.object({
+  success: import_zod16.z.boolean(),
+  versionId: import_zod16.z.string()
+});
+var listObjectVersionsInputSchema = projectScopedInputSchema.extend({
+  bucket: import_zod16.z.string().min(1),
+  key: import_zod16.z.string().min(1)
+});
+
+// src/server/Storage/routers/ceph/versioningRouter.ts
+var versioningRouter = {
+  /**
+  * Get versioning status for a bucket.
+  *
+  * Returns whether versioning is Enabled, Suspended, or Unversioned.
+  *
+  * @throws TRPCError NOT_FOUND - bucket does not exist
+  * @throws TRPCError FORBIDDEN - no credentials or access denied
+  */
+  getStatus: cephProtectedProcedure.input(getVersioningStatusInputSchema).query(async ({ ctx, input }) => {
+    const s3 = ctx.getCephClient();
+    try {
+      const response = await s3.send(new import_client_s34.GetBucketVersioningCommand({
+        Bucket: input.bucket
+      }));
+      const status = response.Status || "Unversioned";
+      return {
+        status,
+        mfaDelete: response.MFADelete
+      };
+    } catch (error) {
+      throw mapS3ErrorToTRPCError(error, {
+        operation: "get versioning status",
+        bucket: input.bucket
+      });
+    }
+  }),
+  /**
+  * Enable or suspend versioning on a bucket.
+  *
+  * Important: Once enabled, versioning cannot be fully disabled (only suspended).
+  * Suspending versioning preserves existing versions but stops creating new ones.
+  *
+  * @throws TRPCError NOT_FOUND - bucket does not exist
+  * @throws TRPCError FORBIDDEN - no credentials or access denied
+  * @throws TRPCError BAD_REQUEST - invalid request
+  */
+  setStatus: cephProtectedProcedure.input(setVersioningInputSchema).mutation(async ({ ctx, input }) => {
+    const s3 = ctx.getCephClient();
+    try {
+      await s3.send(new import_client_s34.PutBucketVersioningCommand({
+        Bucket: input.bucket,
+        VersioningConfiguration: {
+          Status: input.status
+        }
+      }));
+      return {
+        success: true
+      };
+    } catch (error) {
+      throw mapS3ErrorToTRPCError(error, {
+        operation: "set versioning status",
+        bucket: input.bucket
+      });
+    }
+  }),
+  /**
+  * List all versions in a bucket (paginated).
+  *
+  * Returns both regular versions and delete markers. Use pagination markers
+  * for buckets with many versions.
+  *
+  * Pagination:
+  * - First request: don't provide keyMarker or versionIdMarker
+  * - Subsequent requests: use nextKeyMarker and nextVersionIdMarker from previous response
+  *
+  * @throws TRPCError NOT_FOUND - bucket does not exist
+  * @throws TRPCError FORBIDDEN - no credentials or access denied
+  */
+  listVersions: cephProtectedProcedure.input(listVersionsInputSchema).query(async ({ ctx, input }) => {
+    const s3 = ctx.getCephClient();
+    try {
+      const response = await s3.send(new import_client_s34.ListObjectVersionsCommand({
+        Bucket: input.bucket,
+        Prefix: input.prefix,
+        KeyMarker: input.keyMarker,
+        VersionIdMarker: input.versionIdMarker,
+        MaxKeys: input.maxKeys ?? 100
+      }));
+      const versions = (response.Versions ?? []).map((v) => ({
+        key: v.Key,
+        versionId: v.VersionId,
+        isLatest: v.IsLatest ?? false,
+        lastModified: v.LastModified.toISOString(),
+        size: v.Size ?? 0,
+        storageClass: v.StorageClass,
+        owner: v.Owner ? {
+          displayName: v.Owner.DisplayName,
+          id: v.Owner.ID
+        } : void 0,
+        etag: v.ETag,
+        isDeleteMarker: false
+      }));
+      const deleteMarkers = (response.DeleteMarkers ?? []).map((dm) => ({
+        key: dm.Key,
+        versionId: dm.VersionId,
+        isLatest: dm.IsLatest ?? false,
+        lastModified: dm.LastModified.toISOString(),
+        size: 0,
+        owner: dm.Owner ? {
+          displayName: dm.Owner.DisplayName,
+          id: dm.Owner.ID
+        } : void 0,
+        isDeleteMarker: true
+      }));
+      return {
+        versions,
+        deleteMarkers,
+        isTruncated: response.IsTruncated ?? false,
+        nextKeyMarker: response.NextKeyMarker,
+        nextVersionIdMarker: response.NextVersionIdMarker,
+        prefix: response.Prefix,
+        maxKeys: response.MaxKeys
+      };
+    } catch (error) {
+      throw mapS3ErrorToTRPCError(error, {
+        operation: "list versions",
+        bucket: input.bucket
+      });
+    }
+  }),
+  /**
+  * List versions for a specific object.
+  *
+  * Returns all versions (including delete markers) for a single object key,
+  * sorted by date descending (newest first).
+  *
+  * @throws TRPCError NOT_FOUND - bucket does not exist
+  * @throws TRPCError FORBIDDEN - no credentials or access denied
+  */
+  listObjectVersions: cephProtectedProcedure.input(listObjectVersionsInputSchema).query(async ({ ctx, input }) => {
+    const s3 = ctx.getCephClient();
+    try {
+      const response = await s3.send(new import_client_s34.ListObjectVersionsCommand({
+        Bucket: input.bucket,
+        Prefix: input.key
+      }));
+      const versions = (response.Versions ?? []).map((v) => ({
+        key: v.Key,
+        versionId: v.VersionId,
+        isLatest: v.IsLatest ?? false,
+        lastModified: v.LastModified.toISOString(),
+        size: v.Size ?? 0,
+        storageClass: v.StorageClass,
+        owner: v.Owner ? {
+          displayName: v.Owner.DisplayName,
+          id: v.Owner.ID
+        } : void 0,
+        etag: v.ETag,
+        isDeleteMarker: false
+      }));
+      const deleteMarkers = (response.DeleteMarkers ?? []).map((dm) => ({
+        key: dm.Key,
+        versionId: dm.VersionId,
+        isLatest: dm.IsLatest ?? false,
+        lastModified: dm.LastModified.toISOString(),
+        size: 0,
+        owner: dm.Owner ? {
+          displayName: dm.Owner.DisplayName,
+          id: dm.Owner.ID
+        } : void 0,
+        isDeleteMarker: true
+      }));
+      const allVersions = [
+        ...versions,
+        ...deleteMarkers
+      ].filter((v) => v.key === input.key);
+      return allVersions.sort((a, b) => new Date(b.lastModified).getTime() - new Date(a.lastModified).getTime());
+    } catch (error) {
+      throw mapS3ErrorToTRPCError(error, {
+        operation: "list object versions",
+        bucket: input.bucket,
+        key: input.key
+      });
+    }
+  }),
+  /**
+  * Permanently delete a specific version.
+  *
+  * WARNING: This operation is irreversible. The version will be permanently removed.
+  *
+  * Use cases:
+  * - Removing a delete marker to "undelete" an object
+  * - Permanently removing old versions to save space
+  * - Compliance requirements (data retention policies)
+  *
+  * @throws TRPCError NOT_FOUND - version does not exist
+  * @throws TRPCError FORBIDDEN - no credentials or access denied
+  */
+  deleteVersion: cephProtectedProcedure.input(deleteVersionInputSchema).mutation(async ({ ctx, input }) => {
+    const s3 = ctx.getCephClient();
+    try {
+      await s3.send(new import_client_s34.DeleteObjectCommand({
+        Bucket: input.bucket,
+        Key: input.key,
+        VersionId: input.versionId
+      }));
+      return {
+        success: true
+      };
+    } catch (error) {
+      throw mapS3ErrorToTRPCError(error, {
+        operation: "delete version",
+        bucket: input.bucket,
+        key: input.key
+      });
+    }
+  }),
+  /**
+  * Restore an old version (makes it the new latest version).
+  *
+  * How it works:
+  * 1. Copies the old version to the same key
+  * 2. Creates a new latest version with the old version's content
+  * 3. All versions are preserved (including the old and new versions)
+  *
+  * @returns The new version ID created by the restore operation
+  * @throws TRPCError NOT_FOUND - version does not exist
+  * @throws TRPCError FORBIDDEN - no credentials or access denied
+  */
+  restoreVersion: cephProtectedProcedure.input(restoreVersionInputSchema).mutation(async ({ ctx, input }) => {
+    const s3 = ctx.getCephClient();
+    try {
+      const response = await s3.send(new import_client_s34.CopyObjectCommand({
+        Bucket: input.bucket,
+        Key: input.key,
+        CopySource: `${input.bucket}/${encodeURIComponent(input.key)}?versionId=${encodeURIComponent(input.versionId)}`
+      }));
+      return {
+        success: true,
+        versionId: response.VersionId ?? "null"
+      };
+    } catch (error) {
+      throw mapS3ErrorToTRPCError(error, {
+        operation: "restore version",
+        bucket: input.bucket,
+        key: input.key
+      });
+    }
+  })
+};
+
 // src/server/Storage/routers/index.ts
 var objectStorageRouters = {
   storage: {
@@ -34061,45 +34382,48 @@ var objectStorageRouters = {
       }),
       objects: auroraRouter({
         ...objectRouter
+      }),
+      versioning: auroraRouter({
+        ...versioningRouter
       })
     })
   }
 };
 
 // src/server/Project/routers/projectRouter.ts
-var import_zod17 = require("zod");
+var import_zod18 = require("zod");
 var import_server15 = require("@trpc/server");
 
 // src/server/Project/types/models.ts
-var import_zod16 = require("zod");
-var baseProjectSchema = import_zod16.z.object({
-  id: import_zod16.z.string(),
-  name: import_zod16.z.string(),
-  enabled: import_zod16.z.boolean(),
-  domain_id: import_zod16.z.string().nullable().optional(),
-  parent_id: import_zod16.z.string().nullable().optional(),
-  is_domain: import_zod16.z.boolean().nullable().optional(),
-  tags: import_zod16.z.array(import_zod16.z.string()).nullable().optional(),
-  options: import_zod16.z.record(import_zod16.z.string(), import_zod16.z.string().or(import_zod16.z.boolean())).nullable().optional(),
-  description: import_zod16.z.string().nullable().optional(),
-  links: import_zod16.z.object({
-    self: import_zod16.z.string().url().nullable().optional()
+var import_zod17 = require("zod");
+var baseProjectSchema = import_zod17.z.object({
+  id: import_zod17.z.string(),
+  name: import_zod17.z.string(),
+  enabled: import_zod17.z.boolean(),
+  domain_id: import_zod17.z.string().nullable().optional(),
+  parent_id: import_zod17.z.string().nullable().optional(),
+  is_domain: import_zod17.z.boolean().nullable().optional(),
+  tags: import_zod17.z.array(import_zod17.z.string()).nullable().optional(),
+  options: import_zod17.z.record(import_zod17.z.string(), import_zod17.z.string().or(import_zod17.z.boolean())).nullable().optional(),
+  description: import_zod17.z.string().nullable().optional(),
+  links: import_zod17.z.object({
+    self: import_zod17.z.string().url().nullable().optional()
   }).optional()
 });
 var projectSchema = baseProjectSchema.extend({
-  parents: import_zod16.z.array(import_zod16.z.object({
+  parents: import_zod17.z.array(import_zod17.z.object({
     project: baseProjectSchema
   })).optional()
 });
-var projectResponseSchema = import_zod16.z.object({
+var projectResponseSchema = import_zod17.z.object({
   project: projectSchema
 });
-var projectsResponseSchema = import_zod16.z.object({
-  projects: import_zod16.z.array(projectSchema),
-  links: import_zod16.z.object({
-    self: import_zod16.z.string().url().optional(),
-    previous: import_zod16.z.string().url().nullable().optional(),
-    next: import_zod16.z.string().url().nullable().optional()
+var projectsResponseSchema = import_zod17.z.object({
+  projects: import_zod17.z.array(projectSchema),
+  links: import_zod17.z.object({
+    self: import_zod17.z.string().url().optional(),
+    previous: import_zod17.z.string().url().nullable().optional(),
+    next: import_zod17.z.string().url().nullable().optional()
   }).optional()
 });
 
@@ -34190,8 +34514,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_zod17.z.object({
-    search: import_zod17.z.string().optional()
+  searchProjects: protectedProcedure.input(import_zod18.z.object({
+    search: import_zod18.z.string().optional()
   }).optional()).query(async ({ ctx, input }) => {
     if (!ctx.openstack) {
       throw new import_server15.TRPCError({
@@ -34244,8 +34568,8 @@ var projectRouter = {
   * If in the future we need to access project-specific resources (compute, network, etc.),
   * we should create a separate procedure using projectScopedProcedure.
   */
-  getProjectById: protectedProcedure.input(import_zod17.z.object({
-    id: import_zod17.z.string()
+  getProjectById: protectedProcedure.input(import_zod18.z.object({
+    id: import_zod18.z.string()
   })).query(async ({ input, ctx }) => {
     const identityService = ctx.openstack?.service("identity");
     if (!ctx.openstack || !identityService) {
@@ -34330,16 +34654,16 @@ function validateOpenstackService(service, serviceName) {
 __name(validateOpenstackService, "validateOpenstackService");
 
 // src/server/Network/types/floatingIp.ts
-var import_zod19 = require("zod");
+var import_zod20 = require("zod");
 
 // src/server/Network/types/index.ts
-var import_zod18 = require("zod");
-var ISO8601TimestampSchema = import_zod18.z.string().brand("ISO8601Timestamp");
-var SortDirSchema = import_zod18.z.enum([
+var import_zod19 = require("zod");
+var ISO8601TimestampSchema = import_zod19.z.string().brand("ISO8601Timestamp");
+var SortDirSchema = import_zod19.z.enum([
   "asc",
   "desc"
 ]);
-var NetworkPortStatusSchema = import_zod18.z.enum([
+var NetworkPortStatusSchema = import_zod19.z.enum([
   "ACTIVE",
   "DOWN",
   "BUILD",
@@ -34347,154 +34671,154 @@ var NetworkPortStatusSchema = import_zod18.z.enum([
 ]);
 
 // src/server/Network/types/floatingIp.ts
-var FloatingIpStatusSchema = import_zod19.z.enum([
+var FloatingIpStatusSchema = import_zod20.z.enum([
   "ACTIVE",
   "DOWN",
   "ERROR"
 ]);
-var PortDetailsSchema = import_zod19.z.object({
+var PortDetailsSchema = import_zod20.z.object({
   /** The status of the port */
   status: FloatingIpStatusSchema,
   /** The name of the port */
-  name: import_zod19.z.string(),
+  name: import_zod20.z.string(),
   /** Administrative state of the port (true = UP, false = DOWN) */
-  admin_state_up: import_zod19.z.boolean(),
+  admin_state_up: import_zod20.z.boolean(),
   /** The ID of the network the port is attached to */
-  network_id: import_zod19.z.string(),
+  network_id: import_zod20.z.string(),
   /** The owner of the port device */
-  device_owner: import_zod19.z.string(),
+  device_owner: import_zod20.z.string(),
   /** The MAC address of the port */
-  mac_address: import_zod19.z.string(),
+  mac_address: import_zod20.z.string(),
   /** The ID of the device the port is attached to */
-  device_id: import_zod19.z.string()
+  device_id: import_zod20.z.string()
 });
-var PortForwardingSchema = import_zod19.z.object({
+var PortForwardingSchema = import_zod20.z.object({
   /** Port forwarding protocol  */
-  protocol: import_zod19.z.enum([
+  protocol: import_zod20.z.enum([
     "tcp",
     "udp"
   ]),
   /** The internal fixed IP address associated with the port forwarding */
-  internal_ip_address: import_zod19.z.string(),
+  internal_ip_address: import_zod20.z.string(),
   /** The internal port number or starting port of the range */
-  internal_port: import_zod19.z.number().optional(),
+  internal_port: import_zod20.z.number().optional(),
   /** The internal port range (e.g., "1024:2048") */
-  internal_port_range: import_zod19.z.string().optional(),
+  internal_port_range: import_zod20.z.string().optional(),
   /** The internal port ID for the port forwarding (requires floating-ip-port-forwarding-detail extension) */
-  internal_port_id: import_zod19.z.string().optional(),
+  internal_port_id: import_zod20.z.string().optional(),
   /** The external port number or starting port of the range */
-  external_port: import_zod19.z.number().optional(),
+  external_port: import_zod20.z.number().optional(),
   /** The external port range (e.g., "8000:9000") */
-  external_port_range: import_zod19.z.string().optional(),
+  external_port_range: import_zod20.z.string().optional(),
   /** The ID of the port forwarding resource */
-  id: import_zod19.z.string(),
+  id: import_zod20.z.string(),
   /** Description of the port forwarding rule (requires floating-ip-port-forwarding-description extension) */
-  description: import_zod19.z.string().nullable().optional()
+  description: import_zod20.z.string().nullable().optional()
 });
-var FloatingIpSchema = import_zod19.z.object({
+var FloatingIpSchema = import_zod20.z.object({
   /** The ID of the router for the floating IP (null if not associated) */
-  router_id: import_zod19.z.string().nullable(),
+  router_id: import_zod20.z.string().nullable(),
   /** A human-readable description for the resource */
-  description: import_zod19.z.string().nullable().optional(),
+  description: import_zod20.z.string().nullable().optional(),
   /** Whether this is a distributed floating IP (requires floating-ip-distributed extension) */
-  distributed: import_zod19.z.boolean().optional(),
+  distributed: import_zod20.z.boolean().optional(),
   /** A valid DNS domain (requires dns-integration extension) */
-  dns_domain: import_zod19.z.string().optional(),
+  dns_domain: import_zod20.z.string().optional(),
   /** A valid DNS name (requires dns-integration extension) */
-  dns_name: import_zod19.z.string().optional(),
+  dns_name: import_zod20.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_zod19.z.number(),
+  revision_number: import_zod20.z.number(),
   /** The ID of the project that owns the floating IP */
-  project_id: import_zod19.z.string(),
+  project_id: import_zod20.z.string(),
   /** The ID of the tenant (deprecated, use project_id) */
-  tenant_id: import_zod19.z.string(),
+  tenant_id: import_zod20.z.string(),
   /** The ID of the network associated with the floating IP */
-  floating_network_id: import_zod19.z.string(),
+  floating_network_id: import_zod20.z.string(),
   /** The fixed IP address associated with the floating IP (null if not associated) */
-  fixed_ip_address: import_zod19.z.string().nullable(),
+  fixed_ip_address: import_zod20.z.string().nullable(),
   /** The floating IP address */
-  floating_ip_address: import_zod19.z.string(),
+  floating_ip_address: import_zod20.z.string(),
   /** The ID of the port associated with the floating IP (null if not associated) */
-  port_id: import_zod19.z.string().nullable(),
+  port_id: import_zod20.z.string().nullable(),
   /** The ID of the floating IP address */
-  id: import_zod19.z.string(),
+  id: import_zod20.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_zod19.z.array(import_zod19.z.string()).optional(),
+  tags: import_zod20.z.array(import_zod20.z.string()).optional(),
   /** The associated port forwarding resources for the floating IP (requires expose-port-forwarding-in-fip extension) */
-  port_forwardings: import_zod19.z.array(PortForwardingSchema).nullish(),
+  port_forwardings: import_zod20.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_zod19.z.string().optional(),
+  qos_network_policy_id: import_zod20.z.string().optional(),
   /** The ID of the QoS policy associated with the floating IP (requires qos extension) */
-  qos_policy_id: import_zod19.z.string().optional()
-});
-var FloatingIpIdInputSchema = import_zod19.z.object({
-  project_id: import_zod19.z.string(),
-  floatingip_id: import_zod19.z.string()
-});
-var FloatingIpCreateRequestSchema = import_zod19.z.object({
-  tenant_id: import_zod19.z.string(),
-  project_id: import_zod19.z.string(),
-  floating_network_id: import_zod19.z.string(),
-  fixed_ip_address: import_zod19.z.string().optional(),
-  floating_ip_address: import_zod19.z.string().optional(),
-  port_id: import_zod19.z.string().optional(),
-  subnet_id: import_zod19.z.string().optional(),
-  distributed: import_zod19.z.boolean().optional(),
-  description: import_zod19.z.string().optional(),
-  dns_domain: import_zod19.z.string().optional(),
-  dns_name: import_zod19.z.string().optional(),
-  qos_policy_id: import_zod19.z.string().optional()
-});
-var FloatingIpUpdateRequestSchema = import_zod19.z.object({
-  project_id: import_zod19.z.string(),
-  floatingip_id: import_zod19.z.string(),
-  port_id: import_zod19.z.string().nullable(),
-  fixed_ip_address: import_zod19.z.string().optional(),
-  description: import_zod19.z.string().optional(),
-  distributed: import_zod19.z.boolean().optional()
-});
-var FloatingIpResponseSchema = import_zod19.z.object({
+  qos_policy_id: import_zod20.z.string().optional()
+});
+var FloatingIpIdInputSchema = import_zod20.z.object({
+  project_id: import_zod20.z.string(),
+  floatingip_id: import_zod20.z.string()
+});
+var FloatingIpCreateRequestSchema = import_zod20.z.object({
+  tenant_id: import_zod20.z.string(),
+  project_id: import_zod20.z.string(),
+  floating_network_id: import_zod20.z.string(),
+  fixed_ip_address: import_zod20.z.string().optional(),
+  floating_ip_address: import_zod20.z.string().optional(),
+  port_id: import_zod20.z.string().optional(),
+  subnet_id: import_zod20.z.string().optional(),
+  distributed: import_zod20.z.boolean().optional(),
+  description: import_zod20.z.string().optional(),
+  dns_domain: import_zod20.z.string().optional(),
+  dns_name: import_zod20.z.string().optional(),
+  qos_policy_id: import_zod20.z.string().optional()
+});
+var FloatingIpUpdateRequestSchema = import_zod20.z.object({
+  project_id: import_zod20.z.string(),
+  floatingip_id: import_zod20.z.string(),
+  port_id: import_zod20.z.string().nullable(),
+  fixed_ip_address: import_zod20.z.string().optional(),
+  description: import_zod20.z.string().optional(),
+  distributed: import_zod20.z.boolean().optional()
+});
+var FloatingIpResponseSchema = import_zod20.z.object({
   floatingip: FloatingIpSchema
 });
-var FloatingIpListResponseSchema = import_zod19.z.object({
+var FloatingIpListResponseSchema = import_zod20.z.object({
   /** A list of floating IP objects */
-  floatingips: import_zod19.z.array(FloatingIpSchema)
+  floatingips: import_zod20.z.array(FloatingIpSchema)
 });
-var FloatingIpQueryParametersSchema = import_zod19.z.object({
+var FloatingIpQueryParametersSchema = import_zod20.z.object({
   /** Project ID for rescoping (required for projectScopedProcedure) */
-  project_id: import_zod19.z.string(),
+  project_id: import_zod20.z.string(),
   /** Filter by the ID of the floating IP */
-  id: import_zod19.z.string().optional(),
+  id: import_zod20.z.string().optional(),
   /** Filter by the ID of the router for the floating IP */
-  router_id: import_zod19.z.string().nullable().optional(),
+  router_id: import_zod20.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_zod19.z.string().optional(),
+  tenant_id: import_zod20.z.string().optional(),
   /** Filter by the revision number of the resource */
-  revision_number: import_zod19.z.number().optional(),
+  revision_number: import_zod20.z.number().optional(),
   /** Filter by the human-readable description of the resource */
-  description: import_zod19.z.string().nullable().optional(),
+  description: import_zod20.z.string().nullable().optional(),
   /** Filter by the ID of the network associated with the floating IP */
-  floating_network_id: import_zod19.z.string().optional(),
+  floating_network_id: import_zod20.z.string().optional(),
   /** Filter by the fixed IP address associated with the floating IP */
-  fixed_ip_address: import_zod19.z.string().optional(),
+  fixed_ip_address: import_zod20.z.string().optional(),
   /** Filter by the floating IP address */
-  floating_ip_address: import_zod19.z.string().optional(),
+  floating_ip_address: import_zod20.z.string().optional(),
   /** Filter by the ID of a port associated with the floating IP */
-  port_id: import_zod19.z.string().nullable().optional(),
+  port_id: import_zod20.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_zod19.z.enum([
+  sort_key: import_zod20.z.enum([
     "fixed_ip_address",
     "floating_ip_address",
     "floating_network_id",
@@ -34505,73 +34829,73 @@ var FloatingIpQueryParametersSchema = import_zod19.z.object({
     "project_id"
   ]).optional(),
   /** Filter by tags (comma-separated, resources must match all tags) -  requires standard-attr-tag extension */
-  tags: import_zod19.z.array(import_zod19.z.string()).optional(),
+  tags: import_zod20.z.array(import_zod20.z.string()).optional(),
   /** Filter by tags with OR logic (comma-separated, resources match any tag) */
-  "tags-any": import_zod19.z.string().optional(),
+  "tags-any": import_zod20.z.string().optional(),
   /** Exclude resources with these tags (comma-separated, resources must match all excluded tags) */
-  "not-tags": import_zod19.z.string().optional(),
+  "not-tags": import_zod20.z.string().optional(),
   /** Exclude resources with these tags using OR logic (comma-separated, resources match any excluded tag) */
-  "not-tags-any": import_zod19.z.string().optional(),
+  "not-tags-any": import_zod20.z.string().optional(),
   /** Specific fields to return (can be repeated) */
-  fields: import_zod19.z.union([
-    import_zod19.z.string(),
-    import_zod19.z.array(import_zod19.z.string())
+  fields: import_zod20.z.union([
+    import_zod20.z.string(),
+    import_zod20.z.array(import_zod20.z.string())
   ]).optional(),
   /** Pagination limit */
-  limit: import_zod19.z.number().optional(),
+  limit: import_zod20.z.number().optional(),
   /** Pagination marker (ID of the last item in the previous list) */
-  marker: import_zod19.z.string().optional(),
+  marker: import_zod20.z.string().optional(),
   /** Pagination direction (false = ascending, true = descending) */
-  page_reverse: import_zod19.z.boolean().optional(),
+  page_reverse: import_zod20.z.boolean().optional(),
   // BFF-side search (filtered in BFF layer, not sent to OpenStack)
-  searchTerm: import_zod19.z.string().optional()
-});
-var ExternalNetworksQuerySchema = import_zod19.z.object({
-  project_id: import_zod19.z.string(),
-  "router:external": import_zod19.z.literal(true).default(true)
-});
-var ExternalNetworkSchema = import_zod19.z.object({
-  id: import_zod19.z.string(),
-  name: import_zod19.z.string(),
-  project_id: import_zod19.z.string(),
-  "router:external": import_zod19.z.boolean().optional(),
-  shared: import_zod19.z.boolean(),
+  searchTerm: import_zod20.z.string().optional()
+});
+var ExternalNetworksQuerySchema = import_zod20.z.object({
+  project_id: import_zod20.z.string(),
+  "router:external": import_zod20.z.literal(true).default(true)
+});
+var ExternalNetworkSchema = import_zod20.z.object({
+  id: import_zod20.z.string(),
+  name: import_zod20.z.string(),
+  project_id: import_zod20.z.string(),
+  "router:external": import_zod20.z.boolean().optional(),
+  shared: import_zod20.z.boolean(),
   status: NetworkPortStatusSchema,
   updated_at: ISO8601TimestampSchema.optional(),
-  is_default: import_zod19.z.boolean().optional()
+  is_default: import_zod20.z.boolean().optional()
 });
-var ExternalNetworksResponseSchema = import_zod19.z.object({
-  networks: import_zod19.z.array(ExternalNetworkSchema)
+var ExternalNetworksResponseSchema = import_zod20.z.object({
+  networks: import_zod20.z.array(ExternalNetworkSchema)
 });
-var DnsDomainSchema = import_zod19.z.object({
-  id: import_zod19.z.string(),
-  name: import_zod19.z.string()
+var DnsDomainSchema = import_zod20.z.object({
+  id: import_zod20.z.string(),
+  name: import_zod20.z.string()
 });
-var DnsDomainResponseSchema = import_zod19.z.object({
-  zones: import_zod19.z.array(DnsDomainSchema)
+var DnsDomainResponseSchema = import_zod20.z.object({
+  zones: import_zod20.z.array(DnsDomainSchema)
 });
-var AvailablePortsQuerySchema = import_zod19.z.object({
-  project_id: import_zod19.z.string(),
+var AvailablePortsQuerySchema = import_zod20.z.object({
+  project_id: import_zod20.z.string(),
   /** Only ACTIVE ports are eligible for floating IP association */
-  status: import_zod19.z.literal("ACTIVE").default("ACTIVE"),
+  status: import_zod20.z.literal("ACTIVE").default("ACTIVE"),
   /** Only administratively UP ports are eligible for floating IP association */
-  admin_state_up: import_zod19.z.literal(true).default(true)
+  admin_state_up: import_zod20.z.literal(true).default(true)
 });
-var AvailablePortSchema = import_zod19.z.object({
+var AvailablePortSchema = import_zod20.z.object({
   /** The ID of the port */
-  id: import_zod19.z.string(),
+  id: import_zod20.z.string(),
   /** Human-readable name of the port */
-  name: import_zod19.z.string().nullable().optional(),
+  name: import_zod20.z.string().nullable().optional(),
   /** List of fixed IPs assigned to the port, each entry pairs an IP address with its subnet. */
-  fixed_ips: import_zod19.z.array(import_zod19.z.object({
+  fixed_ips: import_zod20.z.array(import_zod20.z.object({
     /** The fixed IP address assigned to the port */
-    ip_address: import_zod19.z.string(),
+    ip_address: import_zod20.z.string(),
     /** The ID of the subnet the IP belongs to */
-    subnet_id: import_zod19.z.string().optional()
+    subnet_id: import_zod20.z.string().optional()
   })).optional()
 });
-var AvailablePortsResponseSchema = import_zod19.z.object({
-  ports: import_zod19.z.array(AvailablePortSchema)
+var AvailablePortsResponseSchema = import_zod20.z.object({
+  ports: import_zod20.z.array(AvailablePortSchema)
 });
 
 // src/server/Network/helpers/errorHandling.ts
@@ -34818,110 +35142,110 @@ var floatingIpRouter = {
 };
 
 // src/server/Network/types/securityGroup.ts
-var import_zod20 = require("zod");
-var securityGroupRuleSchema = import_zod20.z.object({
-  id: import_zod20.z.string(),
-  direction: import_zod20.z.enum([
+var import_zod21 = require("zod");
+var securityGroupRuleSchema = import_zod21.z.object({
+  id: import_zod21.z.string(),
+  direction: import_zod21.z.enum([
     "ingress",
     "egress"
   ]).optional(),
-  ethertype: import_zod20.z.enum([
+  ethertype: import_zod21.z.enum([
     "IPv4",
     "IPv6"
   ]).optional(),
-  description: import_zod20.z.string().nullable().optional(),
-  security_group_id: import_zod20.z.string().optional(),
-  protocol: import_zod20.z.string().nullable().optional(),
-  port_range_min: import_zod20.z.number().nullable().optional(),
-  port_range_max: import_zod20.z.number().nullable().optional(),
-  remote_ip_prefix: import_zod20.z.string().nullable().optional(),
-  remote_group_id: import_zod20.z.string().nullable().optional(),
-  remote_address_group_id: import_zod20.z.string().nullable().optional(),
-  tenant_id: import_zod20.z.string().nullable().optional(),
-  project_id: import_zod20.z.string().nullable().optional(),
-  revision_number: import_zod20.z.number().optional(),
-  tags: import_zod20.z.array(import_zod20.z.string()).optional(),
-  created_at: import_zod20.z.string().optional(),
-  updated_at: import_zod20.z.string().nullable().optional()
-});
-var securityGroupSchema = import_zod20.z.object({
-  id: import_zod20.z.string(),
-  name: import_zod20.z.string().nullable().optional(),
-  description: import_zod20.z.string().nullable().optional(),
-  tenant_id: import_zod20.z.string().nullable().optional(),
-  project_id: import_zod20.z.string().nullable().optional(),
-  stateful: import_zod20.z.boolean().optional(),
-  shared: import_zod20.z.boolean().optional(),
-  tags: import_zod20.z.array(import_zod20.z.string()).optional(),
-  security_group_rules: import_zod20.z.array(securityGroupRuleSchema).optional(),
-  revision_number: import_zod20.z.number().optional(),
-  created_at: import_zod20.z.string().optional(),
-  updated_at: import_zod20.z.string().nullable().optional()
-});
-var securityGroupsResponseSchema = import_zod20.z.object({
-  security_groups: import_zod20.z.array(securityGroupSchema)
+  description: import_zod21.z.string().nullable().optional(),
+  security_group_id: import_zod21.z.string().optional(),
+  protocol: import_zod21.z.string().nullable().optional(),
+  port_range_min: import_zod21.z.number().nullable().optional(),
+  port_range_max: import_zod21.z.number().nullable().optional(),
+  remote_ip_prefix: import_zod21.z.string().nullable().optional(),
+  remote_group_id: import_zod21.z.string().nullable().optional(),
+  remote_address_group_id: import_zod21.z.string().nullable().optional(),
+  tenant_id: import_zod21.z.string().nullable().optional(),
+  project_id: import_zod21.z.string().nullable().optional(),
+  revision_number: import_zod21.z.number().optional(),
+  tags: import_zod21.z.array(import_zod21.z.string()).optional(),
+  created_at: import_zod21.z.string().optional(),
+  updated_at: import_zod21.z.string().nullable().optional()
 });
-var securityGroupResponseSchema = import_zod20.z.object({
+var securityGroupSchema = import_zod21.z.object({
+  id: import_zod21.z.string(),
+  name: import_zod21.z.string().nullable().optional(),
+  description: import_zod21.z.string().nullable().optional(),
+  tenant_id: import_zod21.z.string().nullable().optional(),
+  project_id: import_zod21.z.string().nullable().optional(),
+  stateful: import_zod21.z.boolean().optional(),
+  shared: import_zod21.z.boolean().optional(),
+  tags: import_zod21.z.array(import_zod21.z.string()).optional(),
+  security_group_rules: import_zod21.z.array(securityGroupRuleSchema).optional(),
+  revision_number: import_zod21.z.number().optional(),
+  created_at: import_zod21.z.string().optional(),
+  updated_at: import_zod21.z.string().nullable().optional()
+});
+var securityGroupsResponseSchema = import_zod21.z.object({
+  security_groups: import_zod21.z.array(securityGroupSchema)
+});
+var securityGroupResponseSchema = import_zod21.z.object({
   security_group: securityGroupSchema
 });
-var securityGroupRuleResponseSchema = import_zod20.z.object({
+var securityGroupRuleResponseSchema = import_zod21.z.object({
   security_group_rule: securityGroupRuleSchema
 });
 var listSecurityGroupsInputSchema = projectScopedInputSchema.extend({
   // Sorting
-  sort_key: import_zod20.z.string().optional(),
+  sort_key: import_zod21.z.string().optional(),
   sort_dir: SortDirSchema.optional(),
   // Basic filtering
-  name: import_zod20.z.string().optional(),
-  description: import_zod20.z.string().optional(),
-  tenant_id: import_zod20.z.string().optional(),
-  shared: import_zod20.z.boolean().optional(),
+  name: import_zod21.z.string().optional(),
+  description: import_zod21.z.string().optional(),
+  tenant_id: import_zod21.z.string().optional(),
+  shared: import_zod21.z.boolean().optional(),
   // Tag-based filtering (string values follow Neutron semantics)
-  tags: import_zod20.z.string().optional(),
-  tags_any: import_zod20.z.string().optional(),
-  not_tags: import_zod20.z.string().optional(),
-  not_tags_any: import_zod20.z.string().optional(),
+  tags: import_zod21.z.string().optional(),
+  tags_any: import_zod21.z.string().optional(),
+  not_tags: import_zod21.z.string().optional(),
+  not_tags_any: import_zod21.z.string().optional(),
   // BFF-side search (filtered in BFF layer, not sent to OpenStack)
-  searchTerm: import_zod20.z.string().optional()
+  searchTerm: import_zod21.z.string().optional()
 });
 var getSecurityGroupByIdInputSchema = projectScopedInputSchema.extend({
-  securityGroupId: import_zod20.z.string()
+  securityGroupId: import_zod21.z.string()
 });
 var createSecurityGroupInputSchema = projectScopedInputSchema.extend({
-  name: import_zod20.z.string().min(1, "Name is required"),
-  description: import_zod20.z.string().optional(),
-  stateful: import_zod20.z.boolean().optional()
+  name: import_zod21.z.string().min(1, "Name is required"),
+  description: import_zod21.z.string().optional(),
+  stateful: import_zod21.z.boolean().optional()
 });
 var deleteSecurityGroupInputSchema = projectScopedInputSchema.extend({
-  securityGroupId: import_zod20.z.string()
+  securityGroupId: import_zod21.z.string()
 });
 var updateSecurityGroupInputSchema = projectScopedInputSchema.extend({
-  securityGroupId: import_zod20.z.string(),
-  name: import_zod20.z.string().min(1, "Name is required").optional(),
-  description: import_zod20.z.string().optional(),
-  stateful: import_zod20.z.boolean().optional()
+  securityGroupId: import_zod21.z.string(),
+  name: import_zod21.z.string().min(1, "Name is required").optional(),
+  description: import_zod21.z.string().optional(),
+  stateful: import_zod21.z.boolean().optional()
 });
 var deleteSecurityGroupRuleInputSchema = projectScopedInputSchema.extend({
-  ruleId: import_zod20.z.string()
+  ruleId: import_zod21.z.string()
 });
 var createSecurityGroupRuleInputSchema = projectScopedInputSchema.extend({
-  security_group_id: import_zod20.z.string(),
-  direction: import_zod20.z.enum([
+  security_group_id: import_zod21.z.string(),
+  direction: import_zod21.z.enum([
     "ingress",
     "egress"
   ]),
-  ethertype: import_zod20.z.enum([
+  ethertype: import_zod21.z.enum([
     "IPv4",
     "IPv6"
   ]).default("IPv4"),
-  description: import_zod20.z.string().optional(),
-  protocol: import_zod20.z.string().nullable().optional(),
-  port_range_min: import_zod20.z.number().int().max(65535).nullable().optional(),
-  port_range_max: import_zod20.z.number().int().max(65535).nullable().optional(),
+  description: import_zod21.z.string().optional(),
+  protocol: import_zod21.z.string().nullable().optional(),
+  port_range_min: import_zod21.z.number().int().max(65535).nullable().optional(),
+  port_range_max: import_zod21.z.number().int().max(65535).nullable().optional(),
   // Transform empty strings to undefined for proper validation
-  remote_ip_prefix: import_zod20.z.string().nullable().optional().transform((val) => val === "" ? void 0 : val),
-  remote_group_id: import_zod20.z.string().nullable().optional().transform((val) => val === "" ? void 0 : val),
-  remote_address_group_id: import_zod20.z.string().nullable().optional().transform((val) => val === "" ? void 0 : val)
+  remote_ip_prefix: import_zod21.z.string().nullable().optional().transform((val) => val === "" ? void 0 : val),
+  remote_group_id: import_zod21.z.string().nullable().optional().transform((val) => val === "" ? void 0 : val),
+  remote_address_group_id: import_zod21.z.string().nullable().optional().transform((val) => val === "" ? void 0 : val)
 });
 
 // src/server/Network/helpers/securityGroupHelpers.ts
@@ -35439,42 +35763,42 @@ var securityGroupRuleRouter = {
 };
 
 // src/server/Network/types/rbacPolicy.ts
-var import_zod21 = require("zod");
-var rbacPolicySchema = import_zod21.z.object({
-  id: import_zod21.z.string(),
-  object_type: import_zod21.z.enum([
+var import_zod22 = require("zod");
+var rbacPolicySchema = import_zod22.z.object({
+  id: import_zod22.z.string(),
+  object_type: import_zod22.z.enum([
     "qos_policy",
     "network",
     "security_group"
   ]),
-  object_id: import_zod21.z.string(),
-  action: import_zod21.z.enum([
+  object_id: import_zod22.z.string(),
+  action: import_zod22.z.enum([
     "access_as_shared",
     "access_as_external"
   ]),
-  target_tenant: import_zod21.z.string(),
-  tenant_id: import_zod21.z.string().nullable().optional(),
-  project_id: import_zod21.z.string().nullable().optional()
+  target_tenant: import_zod22.z.string(),
+  tenant_id: import_zod22.z.string().nullable().optional(),
+  project_id: import_zod22.z.string().nullable().optional()
 });
-var rbacPoliciesResponseSchema = import_zod21.z.object({
-  rbac_policies: import_zod21.z.array(rbacPolicySchema)
+var rbacPoliciesResponseSchema = import_zod22.z.object({
+  rbac_policies: import_zod22.z.array(rbacPolicySchema)
 });
-var rbacPolicyResponseSchema = import_zod21.z.object({
+var rbacPolicyResponseSchema = import_zod22.z.object({
   rbac_policy: rbacPolicySchema
 });
 var listRBACPoliciesForSecurityGroupInputSchema = projectScopedInputSchema.extend({
-  securityGroupId: import_zod21.z.string()
+  securityGroupId: import_zod22.z.string()
 });
 var createRBACPolicyInputSchema = projectScopedInputSchema.extend({
-  securityGroupId: import_zod21.z.string(),
-  targetTenant: import_zod21.z.string().trim().min(1, "Target project ID is required")
+  securityGroupId: import_zod22.z.string(),
+  targetTenant: import_zod22.z.string().trim().min(1, "Target project ID is required")
 });
 var updateRBACPolicyInputSchema = projectScopedInputSchema.extend({
-  policyId: import_zod21.z.string(),
-  targetTenant: import_zod21.z.string().trim().min(1, "Target project ID is required")
+  policyId: import_zod22.z.string(),
+  targetTenant: import_zod22.z.string().trim().min(1, "Target project ID is required")
 });
 var deleteRBACPolicyInputSchema = projectScopedInputSchema.extend({
-  policyId: import_zod21.z.string()
+  policyId: import_zod22.z.string()
 });
 
 // src/server/Network/helpers/rbacPolicyHelpers.ts
@@ -35711,122 +36035,117 @@ var networkRouters = {
 };
 
 // src/server/Services/types/pca.ts
-var import_zod22 = require("zod");
-var CertificateValiditySchema = import_zod22.z.object({
-  not_after: import_zod22.z.number().int(),
-  not_before: import_zod22.z.number().int()
+var import_zod23 = require("zod");
+var CertificateValiditySchema = import_zod23.z.object({
+  not_after: import_zod23.z.number().int(),
+  not_before: import_zod23.z.number().int().optional()
 });
-var CertificateAuthorityCertificateSchema = import_zod22.z.object({
+var CertificateAuthorityCertificateSchema = import_zod23.z.object({
   /** PEM encoded certificate data. */
-  pem: import_zod22.z.string(),
+  pem: import_zod23.z.string(),
   validity: CertificateValiditySchema
 });
-var CertificateAuthorityCertificateChainSchema = import_zod22.z.object({
-  certificates: import_zod22.z.array(import_zod22.z.object({
-    pem: import_zod22.z.string()
+var CertificateAuthorityCertificateChainSchema = import_zod23.z.object({
+  certificates: import_zod23.z.array(import_zod23.z.object({
+    pem: import_zod23.z.string()
   })),
   /** Concatenated PEM certificates of the chain. */
-  pem: import_zod22.z.string()
+  pem: import_zod23.z.string()
 });
-var CertificateAuthorityAdditionalAttributeSchema = import_zod22.z.object({
+var CertificateAuthorityAdditionalAttributeSchema = import_zod23.z.object({
   /** ASN.1 Object Identifier of the attribute */
-  key: import_zod22.z.array(import_zod22.z.number().int()),
-  value: import_zod22.z.string()
+  key: import_zod23.z.array(import_zod23.z.number().int()),
+  value: import_zod23.z.string()
 });
-var CertificateAuthoritySubjectSchema = import_zod22.z.object({
-  additional_attribute: import_zod22.z.array(CertificateAuthorityAdditionalAttributeSchema).optional(),
+var CertificateAuthoritySubjectSchema = import_zod23.z.object({
+  additional_attribute: import_zod23.z.array(CertificateAuthorityAdditionalAttributeSchema).optional(),
   /** Typically domain name */
-  common_name: import_zod22.z.string(),
+  common_name: import_zod23.z.string(),
   /** Country codes (ISO 3166-1 alpha-2). */
-  country: import_zod22.z.array(import_zod22.z.string()).optional(),
+  country: import_zod23.z.array(import_zod23.z.string()).optional(),
   /** Locality/city names. */
-  locality: import_zod22.z.array(import_zod22.z.string()).optional(),
+  locality: import_zod23.z.array(import_zod23.z.string()).optional(),
   /** Organization names. */
-  organization: import_zod22.z.array(import_zod22.z.string()).optional(),
+  organization: import_zod23.z.array(import_zod23.z.string()).optional(),
   /** Organizational unit names. */
-  organizational_unit: import_zod22.z.array(import_zod22.z.string()).optional(),
+  organizational_unit: import_zod23.z.array(import_zod23.z.string()).optional(),
   /** Postal/ZIP codes. */
-  postal_code: import_zod22.z.array(import_zod22.z.string()).optional(),
+  postal_code: import_zod23.z.array(import_zod23.z.string()).optional(),
   /** State or province names. */
-  province: import_zod22.z.array(import_zod22.z.string()).optional(),
-  serial_number: import_zod22.z.string().optional(),
-  street_address: import_zod22.z.array(import_zod22.z.string()).optional()
+  province: import_zod23.z.array(import_zod23.z.string()).optional(),
+  serial_number: import_zod23.z.string().optional(),
+  street_address: import_zod23.z.array(import_zod23.z.string()).optional()
 });
-var CertificateAuthorityStateSchema = import_zod22.z.enum([
+var CertificateAuthorityStateSchema = import_zod23.z.enum([
   "CREATING",
   "AWAITING_CERTIFICATE",
   "READY",
   "FAILED",
   "UNEXPECTED"
 ]);
-var CertificateAuthoritySchema = import_zod22.z.object({
+var CertificateAuthoritySchema = import_zod23.z.object({
   certificate: CertificateAuthorityCertificateSchema.optional(),
   /** Details of Certificate Authority certificate's issuers chain. */
   certificate_chain: CertificateAuthorityCertificateChainSchema.optional(),
-  configuration: import_zod22.z.object({
+  configuration: import_zod23.z.object({
     /** X.509 subject of Certificate Authority. Required on create operation. */
     subject: CertificateAuthoritySubjectSchema
   }).optional(),
-  csr: import_zod22.z.string().optional(),
-  id: import_zod22.z.string(),
+  csr: import_zod23.z.string().optional(),
+  id: import_zod23.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_zod22.z.string().optional(),
+  imported_certificate_chain: import_zod23.z.string().optional(),
   /** Identifier of OpenStack project that Certificate Authority belongs. */
-  project_id: import_zod22.z.string(),
+  project_id: import_zod23.z.string(),
   /** Current operational state of Certificate Authority. */
   state: CertificateAuthorityStateSchema
 });
-var CertificateAuthorityResponseSchema = import_zod22.z.object({
+var CertificateAuthorityResponseSchema = import_zod23.z.object({
   certificate_authority: CertificateAuthoritySchema
 });
-var CertificateAuthoritiesListSchema = import_zod22.z.object({
-  certificate_authorities: import_zod22.z.array(CertificateAuthoritySchema)
+var CertificateAuthoritiesListSchema = import_zod23.z.object({
+  certificate_authorities: import_zod23.z.array(CertificateAuthoritySchema)
 });
-var CertificateAuthorityCreateSchema = import_zod22.z.object({
-  configuration: import_zod22.z.object({
+var CertificateAuthorityCreateSchema = import_zod23.z.object({
+  configuration: import_zod23.z.object({
     subject: CertificateAuthoritySubjectSchema
   })
 });
-var CertificateAuthorityIdInputSchema = import_zod22.z.object({
-  project_id: import_zod22.z.string(),
-  certificate_authority_id: import_zod22.z.string().min(1)
+var CertificateAuthorityIdInputSchema = import_zod23.z.object({
+  project_id: import_zod23.z.string(),
+  certificate_authority_id: import_zod23.z.string().min(1)
 });
 var CertificateAuthorityImportInputSchema = CertificateAuthorityIdInputSchema.extend({
-  imported_certificate_chain: import_zod22.z.string().min(1)
+  imported_certificate_chain: import_zod23.z.string().min(1)
 });
 var CertificateIdInputSchema = CertificateAuthorityIdInputSchema.extend({
-  certificate_id: import_zod22.z.string().min(1)
+  certificate_id: import_zod23.z.string().min(1)
 });
-var CertificateConfigurationSchema = import_zod22.z.object({
+var CertificateConfigurationSchema = import_zod23.z.object({
   validity: CertificateValiditySchema
 });
-var CreateCertificateInputSchema = import_zod22.z.object({
-  project_id: import_zod22.z.string(),
-  certificate_authority_id: import_zod22.z.string().min(1),
-  certificate: import_zod22.z.object({
-    configuration: CertificateConfigurationSchema,
-    csr: import_zod22.z.string()
-  })
+var CreateCertificateInputSchema = import_zod23.z.object({
+  project_id: import_zod23.z.string(),
+  certificate_authority_id: import_zod23.z.string().min(1),
+  csr: import_zod23.z.string().min(1),
+  configuration: CertificateConfigurationSchema
 });
-var CertificateSchema = import_zod22.z.object({
+var CertificateSchema = import_zod23.z.object({
   certificate: CertificateAuthorityCertificateSchema.optional(),
-  certificate_authority_id: import_zod22.z.string(),
+  certificate_authority_id: import_zod23.z.string(),
   certificate_chain: CertificateAuthorityCertificateChainSchema.optional(),
   configuration: CertificateConfigurationSchema.optional(),
-  csr: import_zod22.z.string().optional(),
-  id: import_zod22.z.string(),
-  project_id: import_zod22.z.string()
+  csr: import_zod23.z.string().optional(),
+  id: import_zod23.z.string(),
+  project_id: import_zod23.z.string()
 });
-var CertificateResponseSchema = import_zod22.z.object({
-  certificate: CertificateSchema
-});
-var CertificatesListSchema = import_zod22.z.object({
-  certificates: import_zod22.z.array(CertificateSchema)
+var CertificatesListSchema = import_zod23.z.object({
+  certificates: import_zod23.z.array(CertificateSchema)
 });
 
 // src/server/Services/routers/pcaRouter.ts
@@ -35905,14 +36224,12 @@ var pcaRouter = {
   }),
   createCertificate: projectScopedProcedure.input(CreateCertificateInputSchema).mutation(async ({ input, ctx }) => {
     return withErrorHandling3(async () => {
-      const pca = ctx.openstack?.service("clavis");
-      validateOpenstackService(pca, "clavis");
+      const pca = ctx.openstack?.service("pca");
+      validateOpenstackService(pca, "pca");
       const url = `${PCA_BASE_URL}/${input.certificate_authority_id}/certificates`;
-      const response = await pca.post(url, {
-        body: JSON.stringify(input.certificate)
-      });
+      const response = await pca.post(url, omit(input, "project_id", "certificate_authority_id"));
       const data = await response.json();
-      return parseOrThrow(CertificateResponseSchema, data, "pcaRouter.createCertificate").certificate;
+      return parseOrThrow(CertificateSchema, data, "pcaRouter.createCertificate");
     }, "create certificate for certificate authority");
   }),
   getByIdCertificate: projectScopedProcedure.input(CertificateIdInputSchema).query(async ({ input, ctx }) => {
@@ -35941,6 +36258,7 @@ var appRouter = mergeRouters(auroraRouter(authRouters), auroraRouter(computeRout
 var import_signal_openstack = __toESM(require_esm2());
 
 // src/server/sessionCookie.ts
+var import_cookie = require("@fastify/cookie");
 var DEFAULT_COOKIE_NAME = "dashboard-session-auth";
 function extractCookieDomain(hostname, crossDomainCookie) {
   if (!crossDomainCookie) return void 0;
@@ -36246,7 +36564,7 @@ __name(createContext, "createContext");
 // src/server/server.ts
 var import_path2 = __toESM(require("path"));
 var import_node_stream3 = require("stream");
-var import_zod23 = require("zod");
+var import_zod24 = require("zod");
 
 // src/server/aurora-fastify-plugins/csrfProtection.ts
 var import_csrf_protection = __toESM(require("@fastify/csrf-protection"));
@@ -36340,7 +36658,7 @@ async function createServer(config) {
       maxParamLength: 5e3
     }
   });
-  server.register(import_cookie.default, {
+  server.register(import_cookie2.default, {
     secret: void 0
   });
   await server.register(import_rate_limit.default, {
@@ -36453,7 +36771,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_zod23.ZodError) err.error.message = err.error.cause.issues.map((e) => e.message).join(",");
+        if (err.error.cause instanceof import_zod24.ZodError) err.error.message = err.error.cause.issues.map((e) => e.message).join(",");
       }, "onError")
     }
   });