@bluedynamics/cdk8s-plone 0.0.80 → 0.1.0

package/lib/httpcache.d.ts

@@ -1,30 +1,85 @@
 import { Construct } from 'constructs';
 import { Plone } from './plone';
+/**
+ * Configuration options for PloneHttpcache (Varnish caching layer).
+ */
 export interface PloneHttpcacheOptions {
     /**
-     * plone chart
-     * @default - none
+     * The Plone construct to attach the HTTP cache to.
+     * The cache will automatically connect to the backend and frontend services.
      */
     readonly plone: Plone;
-    /** varnishVcl
-     * @default - file in config folder
+    /**
+     * Varnish VCL configuration as a string.
+     * If provided, this takes precedence over varnishVclFile.
+     * @default - loaded from varnishVclFile or default config file
      */
     readonly varnishVcl?: string;
-    /** varnishVclFile
-     * @default - undefined
+    /**
+     * Path to a Varnish VCL configuration file.
+     * If not provided, uses the default VCL file included in the library.
+     * @default - uses default config/varnish.tpl.vcl
      */
     readonly varnishVclFile?: string | undefined;
-    /** existingSecret - Read admin credentials from user provided secret
-     * @default - undefined
-    */
+    /**
+     * Name of an existing Kubernetes secret containing Varnish admin credentials.
+     * The secret should be created separately in the same namespace.
+     * @default - undefined (no existing secret)
+     */
     readonly existingSecret?: string;
+    /**
+     * CPU limit for Varnish pods.
+     * @default '500m'
+     */
     readonly limitCpu?: string;
+    /**
+     * Memory limit for Varnish pods.
+     * @default '500Mi'
+     */
     readonly limitMemory?: string;
+    /**
+     * CPU request for Varnish pods.
+     * @default '100m'
+     */
     readonly requestCpu?: string;
+    /**
+     * Memory request for Varnish pods.
+     * @default '100Mi'
+     */
     readonly requestMemory?: string;
+    /**
+     * Enable Prometheus ServiceMonitor for metrics collection.
+     * Requires Prometheus Operator to be installed in the cluster.
+     * @default false
+     */
     readonly servicemonitor?: boolean;
+    /**
+     * Number of Varnish pod replicas to run.
+     * @default 2
+     */
+    readonly replicas?: number;
 }
+/**
+ * PloneHttpcache construct for deploying Varnish HTTP caching layer.
+ *
+ * Uses the mittwald/kube-httpcache Helm chart to deploy Varnish as a
+ * caching proxy in front of Plone backend and/or frontend services.
+ *
+ * The cache automatically connects to the Plone services and provides
+ * HTTP cache invalidation capabilities.
+ *
+ * @example
+ * const plone = new Plone(chart, 'plone');
+ * const cache = new PloneHttpcache(chart, 'cache', {
+ *   plone: plone,
+ *   existingSecret: 'varnish-secret',
+ * });
+ */
 export declare class PloneHttpcache extends Construct {
+    /**
+     * Name of the Varnish service created by the Helm chart.
+     * Use this to reference the cache service from ingress or other constructs.
+     */
     readonly httpcacheServiceName: string;
     constructor(scope: Construct, id: string, options: PloneHttpcacheOptions);
 }

package/lib/httpcache.js

@@ -7,6 +7,22 @@ const fs = require("fs");
 const path = require("path");
 const cdk8s_1 = require("cdk8s");
 const constructs_1 = require("constructs");
+/**
+ * PloneHttpcache construct for deploying Varnish HTTP caching layer.
+ *
+ * Uses the mittwald/kube-httpcache Helm chart to deploy Varnish as a
+ * caching proxy in front of Plone backend and/or frontend services.
+ *
+ * The cache automatically connects to the Plone services and provides
+ * HTTP cache invalidation capabilities.
+ *
+ * @example
+ * const plone = new Plone(chart, 'plone');
+ * const cache = new PloneHttpcache(chart, 'cache', {
+ *   plone: plone,
+ *   existingSecret: 'varnish-secret',
+ * });
+ */
 class PloneHttpcache extends constructs_1.Construct {
     constructor(scope, id, options) {
         super(scope, id);
@@ -29,7 +45,7 @@ class PloneHttpcache extends constructs_1.Construct {
             repo: 'https://helm.mittwald.de',
             chart: 'kube-httpcache',
             values: {
-                replicaCount: 2,
+                replicaCount: options.replicas ?? 2,
                 cache: {
                     // need to looks at the frontendWatch, do we need it?
                     frontendWatch: false,
@@ -94,5 +110,5 @@ class PloneHttpcache extends constructs_1.Construct {
 }
 exports.PloneHttpcache = PloneHttpcache;
 _a = JSII_RTTI_SYMBOL_1;
-PloneHttpcache[_a] = { fqn: "@bluedynamics/cdk8s-plone.PloneHttpcache", version: "0.0.80" };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"httpcache.js","sourceRoot":"","sources":["../src/httpcache.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs';\nimport * as path from 'path';\nimport { Helm } from 'cdk8s';\nimport { Construct } from 'constructs';\nimport { Plone } from './plone';\n\nexport interface PloneHttpcacheOptions {\n  /**\n   * plone chart\n   * @default - none\n   */\n  readonly plone: Plone;\n\n  /** varnishVcl\n   * @default - file in config folder\n   */\n  readonly varnishVcl?: string;\n\n  /** varnishVclFile\n   * @default - undefined\n   */\n  readonly varnishVclFile?: string | undefined;\n\n  /** existingSecret - Read admin credentials from user provided secret\n   * @default - undefined\n  */\n  readonly existingSecret?: string;\n\n\n  // resources\n  readonly limitCpu?: string;\n  readonly limitMemory?: string;\n  readonly requestCpu?: string;\n  readonly requestMemory?: string;\n  // metrics\n  readonly servicemonitor?: boolean;\n}\n\nexport class PloneHttpcache extends Construct {\n\n  public readonly httpcacheServiceName: string;\n\n  constructor(scope: Construct, id: string, options: PloneHttpcacheOptions) {\n    super(scope, id);\n    let varnishVcl: string;\n    if (!options.varnishVcl) {\n      let vclPath: string;\n      if (!options.varnishVclFile) {\n        vclPath = path.join(__dirname, 'config', 'varnish.tpl.vcl');\n      } else {\n        vclPath = options.varnishVclFile;\n      }\n      varnishVcl = fs.readFileSync(vclPath, 'utf8');\n    } else {\n      varnishVcl = options.varnishVcl;\n    }\n    const httpcache = new Helm(this, 'httpcache', {\n      // see https://github.com/mittwald/kube-httpcache/chart\n      repo: 'https://helm.mittwald.de',\n      chart: 'kube-httpcache',\n      values: {\n        replicaCount: 2,\n        cache: {\n          // need to looks at the frontendWatch, do we need it?\n          frontendWatch: false,\n          backendWatch: false,\n          existingSecret: options.existingSecret ?? undefined,\n        },\n        vclTemplate: varnishVcl,\n        extraEnvVars: [\n          { name: 'BACKEND_SERVICE_NAME', value: options.plone.backendServiceName },\n          { name: 'BACKEND_SERVICE_PORT', value: '8080' },\n          { name: 'BACKEND_SITE_ID', value: options.plone.siteId },\n          { name: 'FRONTEND_SERVICE_NAME', value: options.plone.frontendServiceName },\n          { name: 'FRONTEND_SERVICE_PORT', value: '3000' },\n        ],\n        // see https://github.com/mittwald/kube-httpcache/issues/253\n        nodeSelector: {\n          'kubernetes.io/arch': 'amd64',\n        },\n        resources: {\n          limits: {\n            cpu: options.limitCpu || '500m',\n            memory: options.limitMemory || '500Mi',\n          },\n          requests: {\n            cpu: options.requestCpu || '100m',\n            memory: options.requestMemory || '100Mi',\n          },\n        },\n        rbac: {\n          enabled: false,\n        },\n        exporter: {\n          enabled: true,\n          resources: {\n            limits: {\n              cpu: '100m',\n              memory: '100Mi',\n            },\n            requests: {\n              cpu: '10m',\n              memory: '50Mi',\n            },\n          },\n        },\n        serviceMonitor: {\n          enabled: options.servicemonitor || false,\n          scrapeSignaller: options.servicemonitor || false,\n        },\n      },\n    });\n    const httpcacheService = httpcache.apiObjects.find((construct) => {\n      if ((construct.kind === 'Service') && (construct.metadata.name?.endsWith('kube-httpcache'))) {\n        return construct.name;\n      }\n      return undefined;\n    });\n    if (httpcacheService === undefined) {\n      throw new Error('Could not find httpcache service');\n    }\n    this.httpcacheServiceName = httpcacheService.name;\n  }\n}"]}
+PloneHttpcache[_a] = { fqn: "@bluedynamics/cdk8s-plone.PloneHttpcache", version: "0.1.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"httpcache.js","sourceRoot":"","sources":["../src/httpcache.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs';\nimport * as path from 'path';\nimport { Helm } from 'cdk8s';\nimport { Construct } from 'constructs';\nimport { Plone } from './plone';\n\n/**\n * Configuration options for PloneHttpcache (Varnish caching layer).\n */\nexport interface PloneHttpcacheOptions {\n  /**\n   * The Plone construct to attach the HTTP cache to.\n   * The cache will automatically connect to the backend and frontend services.\n   */\n  readonly plone: Plone;\n\n  /**\n   * Varnish VCL configuration as a string.\n   * If provided, this takes precedence over varnishVclFile.\n   * @default - loaded from varnishVclFile or default config file\n   */\n  readonly varnishVcl?: string;\n\n  /**\n   * Path to a Varnish VCL configuration file.\n   * If not provided, uses the default VCL file included in the library.\n   * @default - uses default config/varnish.tpl.vcl\n   */\n  readonly varnishVclFile?: string | undefined;\n\n  /**\n   * Name of an existing Kubernetes secret containing Varnish admin credentials.\n   * The secret should be created separately in the same namespace.\n   * @default - undefined (no existing secret)\n   */\n  readonly existingSecret?: string;\n\n  /**\n   * CPU limit for Varnish pods.\n   * @default '500m'\n   */\n  readonly limitCpu?: string;\n\n  /**\n   * Memory limit for Varnish pods.\n   * @default '500Mi'\n   */\n  readonly limitMemory?: string;\n\n  /**\n   * CPU request for Varnish pods.\n   * @default '100m'\n   */\n  readonly requestCpu?: string;\n\n  /**\n   * Memory request for Varnish pods.\n   * @default '100Mi'\n   */\n  readonly requestMemory?: string;\n\n  /**\n   * Enable Prometheus ServiceMonitor for metrics collection.\n   * Requires Prometheus Operator to be installed in the cluster.\n   * @default false\n   */\n  readonly servicemonitor?: boolean;\n\n  /**\n   * Number of Varnish pod replicas to run.\n   * @default 2\n   */\n  readonly replicas?: number;\n}\n\n/**\n * PloneHttpcache construct for deploying Varnish HTTP caching layer.\n *\n * Uses the mittwald/kube-httpcache Helm chart to deploy Varnish as a\n * caching proxy in front of Plone backend and/or frontend services.\n *\n * The cache automatically connects to the Plone services and provides\n * HTTP cache invalidation capabilities.\n *\n * @example\n * const plone = new Plone(chart, 'plone');\n * const cache = new PloneHttpcache(chart, 'cache', {\n *   plone: plone,\n *   existingSecret: 'varnish-secret',\n * });\n */\nexport class PloneHttpcache extends Construct {\n  /**\n   * Name of the Varnish service created by the Helm chart.\n   * Use this to reference the cache service from ingress or other constructs.\n   */\n  public readonly httpcacheServiceName: string;\n\n  constructor(scope: Construct, id: string, options: PloneHttpcacheOptions) {\n    super(scope, id);\n    let varnishVcl: string;\n    if (!options.varnishVcl) {\n      let vclPath: string;\n      if (!options.varnishVclFile) {\n        vclPath = path.join(__dirname, 'config', 'varnish.tpl.vcl');\n      } else {\n        vclPath = options.varnishVclFile;\n      }\n      varnishVcl = fs.readFileSync(vclPath, 'utf8');\n    } else {\n      varnishVcl = options.varnishVcl;\n    }\n    const httpcache = new Helm(this, 'httpcache', {\n      // see https://github.com/mittwald/kube-httpcache/chart\n      repo: 'https://helm.mittwald.de',\n      chart: 'kube-httpcache',\n      values: {\n        replicaCount: options.replicas ?? 2,\n        cache: {\n          // need to looks at the frontendWatch, do we need it?\n          frontendWatch: false,\n          backendWatch: false,\n          existingSecret: options.existingSecret ?? undefined,\n        },\n        vclTemplate: varnishVcl,\n        extraEnvVars: [\n          { name: 'BACKEND_SERVICE_NAME', value: options.plone.backendServiceName },\n          { name: 'BACKEND_SERVICE_PORT', value: '8080' },\n          { name: 'BACKEND_SITE_ID', value: options.plone.siteId },\n          { name: 'FRONTEND_SERVICE_NAME', value: options.plone.frontendServiceName },\n          { name: 'FRONTEND_SERVICE_PORT', value: '3000' },\n        ],\n        // see https://github.com/mittwald/kube-httpcache/issues/253\n        nodeSelector: {\n          'kubernetes.io/arch': 'amd64',\n        },\n        resources: {\n          limits: {\n            cpu: options.limitCpu || '500m',\n            memory: options.limitMemory || '500Mi',\n          },\n          requests: {\n            cpu: options.requestCpu || '100m',\n            memory: options.requestMemory || '100Mi',\n          },\n        },\n        rbac: {\n          enabled: false,\n        },\n        exporter: {\n          enabled: true,\n          resources: {\n            limits: {\n              cpu: '100m',\n              memory: '100Mi',\n            },\n            requests: {\n              cpu: '10m',\n              memory: '50Mi',\n            },\n          },\n        },\n        serviceMonitor: {\n          enabled: options.servicemonitor || false,\n          scrapeSignaller: options.servicemonitor || false,\n        },\n      },\n    });\n    const httpcacheService = httpcache.apiObjects.find((construct) => {\n      if ((construct.kind === 'Service') && (construct.metadata.name?.endsWith('kube-httpcache'))) {\n        return construct.name;\n      }\n      return undefined;\n    });\n    if (httpcacheService === undefined) {\n      throw new Error('Could not find httpcache service');\n    }\n    this.httpcacheServiceName = httpcacheService.name;\n  }\n}"]}

package/lib/pdb.d.ts

@@ -1,24 +1,39 @@
 import { Construct } from 'constructs';
+/**
+ * Configuration options for PodDisruptionBudget.
+ */
 export interface PlonePDBOptions {
     /**
-     * maxUnavailable specification
-     * @default - none
+     * Maximum number or percentage of pods that can be unavailable during voluntary disruptions.
+     * Can be an absolute number (e.g., 1) or a percentage (e.g., '50%').
+     * Cannot be used together with minAvailable.
+     * @example 1 or '25%'
+     * @default - not set (defaults to minAvailable=1 if neither is specified)
      */
     readonly maxUnavailable?: number | string;
     /**
-     * minAvailable specification.
-     * default only set if maxUnavailable is not set.
-     * @default 1
+     * Minimum number or percentage of pods that must remain available during voluntary disruptions.
+     * Can be an absolute number (e.g., 1) or a percentage (e.g., '50%').
+     * Cannot be used together with maxUnavailable.
+     * @example 2 or '50%'
+     * @default 1 (if maxUnavailable is not set)
      */
     readonly minAvailable?: number | string;
     /**
-     * Extra labels to associate with resources.
-     * @default - none
+     * Additional Kubernetes labels for the PodDisruptionBudget.
+     * @default - standard Plone labels only
      */
     readonly labels?: {
         [name: string]: string;
     };
 }
+/**
+ * PlonePDB creates a Kubernetes PodDisruptionBudget for high availability.
+ *
+ * This is an internal construct used by PloneDeployment.
+ * It ensures a minimum number of pods remain available during voluntary
+ * disruptions like node drains or cluster upgrades.
+ */
 export declare class PlonePDB extends Construct {
     constructor(scope: Construct, id: string, selectorLabel: {
         [name: string]: string;

package/lib/pdb.js

@@ -3,6 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PlonePDB = void 0;
 const constructs_1 = require("constructs");
 const k8s = require("./imports/k8s");
+/**
+ * PlonePDB creates a Kubernetes PodDisruptionBudget for high availability.
+ *
+ * This is an internal construct used by PloneDeployment.
+ * It ensures a minimum number of pods remain available during voluntary
+ * disruptions like node drains or cluster upgrades.
+ */
 class PlonePDB extends constructs_1.Construct {
     constructor(scope, id, selectorLabel, options) {
         super(scope, id);
@@ -52,4 +59,4 @@ class PlonePDB extends constructs_1.Construct {
     }
 }
 exports.PlonePDB = PlonePDB;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/plone.d.ts

@@ -1,45 +1,258 @@
 import * as kplus from 'cdk8s-plus-30';
 import { Construct } from 'constructs';
+/**
+ * Base options for Plone backend or frontend configuration.
+ * These options control container image, replica count, resource limits,
+ * environment variables, and health probes.
+ */
 export interface PloneBaseOptions {
+    /**
+     * Container image to use for the deployment.
+     * @example 'plone/plone-backend:6.0.10' or 'plone/plone-frontend:16.0.0'
+     * @default - 'plone/plone-backend:latest' for backend, 'plone/plone-frontend:latest' for frontend
+     */
     readonly image?: string;
+    /**
+     * Image pull policy for the container.
+     * @default 'IfNotPresent'
+     */
     readonly imagePullPolicy?: string;
+    /**
+     * Number of pod replicas to run.
+     * @default 2
+     */
     readonly replicas?: number;
+    /**
+     * Maximum number of pods that can be unavailable during updates.
+     * Can be an absolute number (e.g., 1) or a percentage (e.g., '50%').
+     * Used in PodDisruptionBudget if specified.
+     * @default - undefined (not set)
+     */
     readonly maxUnavailable?: number | string;
+    /**
+     * Minimum number of pods that must be available during updates.
+     * Can be an absolute number (e.g., 1) or a percentage (e.g., '50%').
+     * Used in PodDisruptionBudget if specified.
+     * @default - undefined (not set)
+     */
     readonly minAvailable?: number | string;
+    /**
+     * CPU limit for the container.
+     * @example '500m' or '1' or '2000m'
+     * @default '500m' for both backend and frontend
+     */
     readonly limitCpu?: string;
+    /**
+     * Memory limit for the container.
+     * @example '512Mi' or '1Gi'
+     * @default '512Mi' for backend, '1Gi' for frontend
+     */
     readonly limitMemory?: string;
+    /**
+     * CPU request for the container.
+     * @example '200m' or '0.5'
+     * @default '200m'
+     */
     readonly requestCpu?: string;
+    /**
+     * Memory request for the container.
+     * @example '256Mi' or '512Mi'
+     * @default '256Mi'
+     */
     readonly requestMemory?: string;
+    /**
+     * Environment variables to set in the container.
+     * Use cdk8s-plus-30 Env class to define variables and sources.
+     * @default - undefined (no additional environment variables)
+     */
     readonly environment?: kplus.Env;
+    /**
+     * Enable readiness probe for the container.
+     * Readiness probes determine when a container is ready to accept traffic.
+     * @default true
+     */
     readonly readinessEnabled?: boolean;
+    /**
+     * Number of seconds after container start before readiness probe is initiated.
+     * @default 10
+     */
     readonly readinessInitialDelaySeconds?: number;
-    readonly readinessIimeoutSeconds?: number;
+    /**
+     * Number of seconds after which the readiness probe times out.
+     * @default 15
+     */
+    readonly readinessTimeoutSeconds?: number;
+    /**
+     * How often (in seconds) to perform the readiness probe.
+     * @default 10
+     */
     readonly readinessPeriodSeconds?: number;
+    /**
+     * Minimum consecutive successes for the readiness probe to be considered successful.
+     * @default 1
+     */
     readonly readinessSuccessThreshold?: number;
+    /**
+     * Minimum consecutive failures for the readiness probe to be considered failed.
+     * @default 3
+     */
     readonly readinessFailureThreshold?: number;
+    /**
+     * Enable liveness probe for the container.
+     * Liveness probes determine when to restart a container.
+     * Recommended: true for frontend, false for backend (Zope has its own recovery).
+     * @default false
+     */
     readonly livenessEnabled?: boolean;
+    /**
+     * Number of seconds after container start before liveness probe is initiated.
+     * @default 30
+     */
     readonly livenessInitialDelaySeconds?: number;
-    readonly livenessIimeoutSeconds?: number;
+    /**
+     * Number of seconds after which the liveness probe times out.
+     * @default 5
+     */
+    readonly livenessTimeoutSeconds?: number;
+    /**
+     * How often (in seconds) to perform the liveness probe.
+     * @default 10
+     */
     readonly livenessPeriodSeconds?: number;
+    /**
+     * Minimum consecutive successes for the liveness probe to be considered successful.
+     * @default 1
+     */
     readonly livenessSuccessThreshold?: number;
+    /**
+     * Minimum consecutive failures for the liveness probe to be considered failed.
+     * @default 3
+     */
     readonly livenessFailureThreshold?: number;
+    /**
+     * Annotations to add to the Deployment metadata.
+     * @example { 'deployment.kubernetes.io/revision': '1' }
+     * @default - no additional annotations
+     */
+    readonly annotations?: {
+        [name: string]: string;
+    };
+    /**
+     * Annotations to add to the Pod template metadata.
+     * Common for Prometheus, Istio, backup policies, etc.
+     * @example { 'prometheus.io/scrape': 'true', 'prometheus.io/port': '8080' }
+     * @default - no additional annotations
+     */
+    readonly podAnnotations?: {
+        [name: string]: string;
+    };
+    /**
+     * Annotations to add to the Service metadata.
+     * Common for external-dns, load balancers, service mesh, etc.
+     * @example { 'external-dns.alpha.kubernetes.io/hostname': 'plone.example.com' }
+     * @default - no additional annotations
+     */
+    readonly serviceAnnotations?: {
+        [name: string]: string;
+    };
 }
+/**
+ * Plone deployment variants.
+ */
 export declare enum PloneVariant {
+    /**
+     * Volto variant: ReactJS frontend (Volto) with REST API backend.
+     * Deploys both frontend and backend services.
+     */
     VOLTO = "volto",
+    /**
+     * Classic UI variant: Traditional Plone with server-side rendering.
+     * Deploys only the backend service.
+     */
     CLASSICUI = "classicui"
 }
+/**
+ * Main configuration options for Plone deployment.
+ */
 export interface PloneOptions {
+    /**
+     * Version string for labeling the deployment.
+     * This is used in Kubernetes labels and doesn't affect the actual image versions.
+     * @default 'undefined'
+     */
     readonly version?: string;
+    /**
+     * Plone site ID in the ZODB.
+     * This is used to construct the internal API path for Volto frontend.
+     * @default 'Plone'
+     */
     readonly siteId?: string;
+    /**
+     * Plone deployment variant to use.
+     * @default PloneVariant.VOLTO
+     */
     readonly variant?: PloneVariant;
+    /**
+     * Backend (Plone API) configuration.
+     * @default {} (uses default values from PloneBaseOptions)
+     */
     readonly backend?: PloneBaseOptions;
+    /**
+     * Frontend (Volto) configuration.
+     * Only used when variant is PloneVariant.VOLTO.
+     * @default {} (uses default values from PloneBaseOptions)
+     */
     readonly frontend?: PloneBaseOptions;
+    /**
+     * Names of Kubernetes secrets to use for pulling private container images.
+     * These secrets must exist in the same namespace as the deployment.
+     * @example ['my-registry-secret']
+     * @default [] (no image pull secrets)
+     */
     readonly imagePullSecrets?: string[];
 }
+/**
+ * Plone construct for deploying Plone CMS to Kubernetes.
+ *
+ * This construct creates all necessary Kubernetes resources for running Plone:
+ * - Deployment(s) for backend (and optionally frontend)
+ * - Service(s) for network access
+ * - Optional PodDisruptionBudget for high availability
+ *
+ * Supports two deployment variants:
+ * - VOLTO: Modern React frontend with REST API backend (default)
+ * - CLASSICUI: Traditional server-side rendered Plone
+ *
+ * @example
+ * new Plone(chart, 'my-plone', {
+ *   variant: PloneVariant.VOLTO,
+ *   backend: {
+ *     image: 'plone/plone-backend:6.0.10',
+ *     replicas: 3,
+ *   },
+ *   frontend: {
+ *     image: 'plone/plone-frontend:16.0.0',
+ *   },
+ * });
+ */
 export declare class Plone extends Construct {
+    /**
+     * Name of the backend Kubernetes service.
+     * Use this to reference the backend service from other constructs.
+     */
     readonly backendServiceName: string;
+    /**
+     * Name of the frontend Kubernetes service.
+     * Only set when variant is VOLTO, otherwise undefined.
+     */
     readonly frontendServiceName: string | undefined;
+    /**
+     * The deployment variant being used (VOLTO or CLASSICUI).
+     */
     readonly variant: PloneVariant;
+    /**
+     * The Plone site ID in ZODB.
+     */
     readonly siteId: string;
     constructor(scope: Construct, id: string, options?: PloneOptions);
 }