@vibesdotdev/integrations-digitalocean 0.0.0-stage → 1.0.0-rc.2

package/dist/infra/doks/service-release-schemas.d.ts

@@ -0,0 +1,1037 @@
+/**
+ * DigitalOcean Kubernetes service-release schemas. The infra/service-release
+ * kind keeps `config` open; this package validates the DigitalOcean-owned part
+ * once, when it resolves a release or target.
+ */
+import * as z from 'zod/v4';
+export declare const DigitalOceanKubernetesServiceReleaseTargetSchema: z.ZodObject<{
+    adapter: z.ZodLiteral<"digitalocean-kubernetes">;
+    cluster: z.ZodUnion<readonly [z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        name: z.ZodString;
+    }, z.core.$strip>]>;
+}, z.core.$strip>;
+export declare const DigitalOceanKubernetesServiceReleaseConfigSchema: z.ZodObject<{
+    adapter: z.ZodLiteral<"digitalocean-kubernetes">;
+    cluster: z.ZodUnion<readonly [z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        name: z.ZodString;
+    }, z.core.$strip>]>;
+    imageRegistry: z.ZodOptional<z.ZodObject<{
+        provider: z.ZodLiteral<"digitalocean-container-registry">;
+        name: z.ZodString;
+    }, z.core.$strip>>;
+    loadBalancerAnnotations: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+/** The kind's descriptor plus the DigitalOcean-owned config fields and the registry-bound image rule. */
+export declare const DigitalOceanServiceReleaseDescriptorSchema: z.ZodPipe<z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    hardware: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    priority: z.ZodOptional<z.ZodNumber>;
+    capabilityId: z.ZodOptional<z.ZodString>;
+    requiredContext: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    optionalContext: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    retention: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        maxAgeDays: z.ZodOptional<z.ZodNumber>;
+        maxEntries: z.ZodOptional<z.ZodNumber>;
+        maxBytes: z.ZodOptional<z.ZodNumber>;
+        cascadeFrom: z.ZodOptional<z.ZodString>;
+        ageField: z.ZodOptional<z.ZodString>;
+        reason: z.ZodString;
+        enforcedBy: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>;
+    id: z.ZodString;
+    kind: z.ZodLiteral<"infra/service-release">;
+    namespace: z.ZodString;
+    gateway: z.ZodObject<{
+        name: z.ZodString;
+        image: z.ZodString;
+        revision: z.ZodString;
+        replicas: z.ZodNumber;
+        port: z.ZodDefault<z.ZodLiteral<22>>;
+        listenPort: z.ZodDefault<z.ZodNumber>;
+        hostname: z.ZodString;
+        hostKeyAuthority: z.ZodObject<{
+            publicKey: z.ZodString;
+            fingerprint: z.ZodString;
+            source: z.ZodObject<{
+                repository: z.ZodString;
+                path: z.ZodString;
+            }, z.core.$strip>;
+            secretRef: z.ZodObject<{
+                name: z.ZodString;
+                privateKeyKey: z.ZodString;
+                publicKeyKey: z.ZodString;
+                mountPath: z.ZodString;
+            }, z.core.$strip>;
+            provisioning: z.ZodObject<{
+                owner: z.ZodLiteral<"secret-management">;
+                mode: z.ZodLiteral<"external-preprovisioned">;
+            }, z.core.$strip>;
+            rotation: z.ZodObject<{
+                generation: z.ZodNumber;
+                strategy: z.ZodLiteral<"preprovisioned-atomic">;
+                previousFingerprint: z.ZodOptional<z.ZodString>;
+                knownHostsOverlapUntil: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        env: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            source: z.ZodLiteral<"literal">;
+            name: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            source: z.ZodLiteral<"secret">;
+            name: z.ZodString;
+            secretRef: z.ZodObject<{
+                name: z.ZodString;
+                key: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strip>], "source">>>;
+        secretMounts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            secretName: z.ZodString;
+            mountPath: z.ZodString;
+            keys: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            readOnly: z.ZodDefault<z.ZodLiteral<true>>;
+        }, z.core.$strip>>>;
+        resources: z.ZodObject<{
+            requests: z.ZodObject<{
+                cpu: z.ZodString;
+                memory: z.ZodString;
+            }, z.core.$strip>;
+            limits: z.ZodObject<{
+                cpu: z.ZodString;
+                memory: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        maxUnavailable: z.ZodDefault<z.ZodLiteral<0>>;
+        maxSurge: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    controlPlaneRouter: z.ZodObject<{
+        image: z.ZodString;
+        revision: z.ZodString;
+        publicPort: z.ZodLiteral<443>;
+        listenPort: z.ZodDefault<z.ZodNumber>;
+        tlsSecretRef: z.ZodObject<{
+            name: z.ZodString;
+            certificateKey: z.ZodDefault<z.ZodString>;
+            privateKeyKey: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>;
+        smartGit: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodLiteral<true>;
+            authorizationOwner: z.ZodLiteral<"stateful">;
+            pathContract: z.ZodLiteral<"owner/repo.git">;
+        }, z.core.$strip>>;
+        allowedPathPrefixes: z.ZodArray<z.ZodString>;
+        proxyRepoBrowse: z.ZodDefault<z.ZodBoolean>;
+        proxyMergeControl: z.ZodDefault<z.ZodBoolean>;
+        fallbackRedirect: z.ZodOptional<z.ZodURL>;
+        resources: z.ZodObject<{
+            requests: z.ZodObject<{
+                cpu: z.ZodString;
+                memory: z.ZodString;
+            }, z.core.$strip>;
+            limits: z.ZodObject<{
+                cpu: z.ZodString;
+                memory: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    stateful: z.ZodObject<{
+        name: z.ZodString;
+        exposure: z.ZodDefault<z.ZodLiteral<"internal">>;
+        adminExposure: z.ZodDefault<z.ZodLiteral<"internal">>;
+        image: z.ZodString;
+        revision: z.ZodString;
+        replicas: z.ZodLiteral<1>;
+        port: z.ZodNumber;
+        storage: z.ZodObject<{
+            mountPath: z.ZodString;
+            size: z.ZodString;
+            accessMode: z.ZodLiteral<"ReadWriteOnce">;
+            storageClassName: z.ZodOptional<z.ZodString>;
+            schemaVersion: z.ZodNumber;
+            releaseCompatibility: z.ZodObject<{
+                readFrom: z.ZodNumber;
+                readThrough: z.ZodNumber;
+                writeVersion: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        backup: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            mode: z.ZodLiteral<"restic-s3">;
+            toolImage: z.ZodString;
+            repository: z.ZodString;
+            credentials: z.ZodObject<{
+                accessKeyId: z.ZodObject<{
+                    store: z.ZodOptional<z.ZodString>;
+                    key: z.ZodString;
+                    env: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+                secretAccessKey: z.ZodObject<{
+                    store: z.ZodOptional<z.ZodString>;
+                    key: z.ZodString;
+                    env: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+                encryptionKey: z.ZodObject<{
+                    store: z.ZodOptional<z.ZodString>;
+                    key: z.ZodString;
+                    env: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+            schedule: z.ZodString;
+            retention: z.ZodObject<{
+                keepDaily: z.ZodNumber;
+                keepWeekly: z.ZodNumber;
+                keepMonthly: z.ZodNumber;
+            }, z.core.$strip>;
+            restoreVerify: z.ZodObject<{
+                schedule: z.ZodString;
+                scratchSize: z.ZodString;
+                timeoutSeconds: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            mode: z.ZodLiteral<"csi-volume-snapshot">;
+            toolImage: z.ZodString;
+            snapshotClassName: z.ZodString;
+            deletionPolicy: z.ZodLiteral<"Delete">;
+            schedule: z.ZodString;
+            retention: z.ZodObject<{
+                verifiedGenerations: z.ZodNumber;
+            }, z.core.$strip>;
+            restoreVerify: z.ZodObject<{
+                schedule: z.ZodString;
+                scratchSize: z.ZodString;
+                timeoutSeconds: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>], "mode">;
+        repositoryMigration: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodLiteral<"mirror-ssh">;
+            migrationId: z.ZodString;
+            source: z.ZodObject<{
+                origin: z.ZodURL;
+                inventoryUrl: z.ZodURL;
+                sshLeaseUrl: z.ZodURL;
+                inventoryAuthoritySecretRef: z.ZodObject<{
+                    name: z.ZodString;
+                    key: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+            expected: z.ZodObject<{
+                repositoryCount: z.ZodNumber;
+                owners: z.ZodArray<z.ZodObject<{
+                    ownerType: z.ZodEnum<{
+                        user: "user";
+                        organization: "organization";
+                    }>;
+                    ownerId: z.ZodString;
+                    repositoryCount: z.ZodNumber;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+            receipt: z.ZodObject<{
+                configMapName: z.ZodString;
+            }, z.core.$strip>;
+            convergence: z.ZodObject<{
+                stablePasses: z.ZodLiteral<2>;
+            }, z.core.$strip>;
+            rollback: z.ZodObject<{
+                mode: z.ZodLiteral<"source-authoritative-until-public-cutover">;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+        env: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            source: z.ZodLiteral<"literal">;
+            name: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            source: z.ZodLiteral<"secret">;
+            name: z.ZodString;
+            secretRef: z.ZodObject<{
+                name: z.ZodString;
+                key: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strip>], "source">>>;
+        secretMounts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            secretName: z.ZodString;
+            mountPath: z.ZodString;
+            keys: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            readOnly: z.ZodDefault<z.ZodLiteral<true>>;
+        }, z.core.$strip>>>;
+        resources: z.ZodObject<{
+            requests: z.ZodObject<{
+                cpu: z.ZodString;
+                memory: z.ZodString;
+            }, z.core.$strip>;
+            limits: z.ZodObject<{
+                cpu: z.ZodString;
+                memory: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    secretBindings: z.ZodArray<z.ZodObject<{
+        source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"secret-store">;
+            key: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"repository-file">;
+            path: z.ZodString;
+        }, z.core.$strip>], "kind">;
+        target: z.ZodObject<{
+            name: z.ZodString;
+            key: z.ZodString;
+        }, z.core.$strip>;
+        description: z.ZodString;
+    }, z.core.$strip>>;
+    networkPolicy: z.ZodObject<{
+        defaultDenyIngress: z.ZodLiteral<true>;
+        allowGatewayToStateful: z.ZodLiteral<true>;
+        egress: z.ZodObject<{
+            defaultDeny: z.ZodLiteral<true>;
+            platformAuthCidrs: z.ZodArray<z.ZodString>;
+            objectBackupCidrs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            objectBackupHostnames: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    config: z.ZodObject<{
+        adapter: z.ZodString;
+        dnsOwnerRef: z.ZodString;
+        namespaceQuota: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+            hard: z.ZodObject<{
+                "limits.cpu": z.ZodString;
+                "limits.memory": z.ZodString;
+                persistentvolumeclaims: z.ZodString;
+                pods: z.ZodString;
+                "requests.cpu": z.ZodString;
+                "requests.memory": z.ZodString;
+                "requests.storage": z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+        backupStorage: z.ZodOptional<z.ZodObject<{
+            adapter: z.ZodLiteral<"s3-compatible">;
+            authority: z.ZodObject<{
+                provider: z.ZodString;
+                name: z.ZodString;
+                requiredControlPlaneScopes: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>;
+            bucket: z.ZodString;
+            region: z.ZodString;
+            endpoint: z.ZodURL;
+            forcePathStyle: z.ZodLiteral<true>;
+            versioning: z.ZodLiteral<"Enabled">;
+            publicAccess: z.ZodLiteral<"private">;
+        }, z.core.$strip>>;
+        certificate: z.ZodOptional<z.ZodObject<{
+            manager: z.ZodLiteral<"cert-manager">;
+            issuerRef: z.ZodObject<{
+                kind: z.ZodUnion<readonly [z.ZodLiteral<"ClusterIssuer">, z.ZodLiteral<"Issuer">]>;
+                name: z.ZodString;
+            }, z.core.$strip>;
+            provisioning: z.ZodOptional<z.ZodObject<{
+                owner: z.ZodLiteral<"service-release">;
+                mode: z.ZodLiteral<"namespace-acme-dns01">;
+                server: z.ZodURL;
+                email: z.ZodEmail;
+                privateKeySecretRef: z.ZodObject<{
+                    name: z.ZodString;
+                }, z.core.$strip>;
+                solver: z.ZodObject<{
+                    provider: z.ZodString;
+                    dnsZones: z.ZodArray<z.ZodString>;
+                    apiToken: z.ZodObject<{
+                        environment: z.ZodLiteral<"local">;
+                        sourceKeys: z.ZodArray<z.ZodString>;
+                        target: z.ZodObject<{
+                            name: z.ZodString;
+                            key: z.ZodString;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+            duration: z.ZodDefault<z.ZodLiteral<"2160h">>;
+            renewBefore: z.ZodDefault<z.ZodLiteral<"360h">>;
+            privateKey: z.ZodDefault<z.ZodObject<{
+                algorithm: z.ZodDefault<z.ZodLiteral<"ECDSA">>;
+                size: z.ZodDefault<z.ZodLiteral<256>>;
+                rotationPolicy: z.ZodDefault<z.ZodLiteral<"Always">>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$loose>;
+}, z.core.$strip>, z.ZodTransform<{
+    config: {
+        adapter: "digitalocean-kubernetes";
+        cluster: {
+            id: string;
+        } | {
+            name: string;
+        };
+        loadBalancerAnnotations: Record<string, string>;
+        imageRegistry?: {
+            provider: "digitalocean-container-registry";
+            name: string;
+        } | undefined;
+        dnsOwnerRef: string;
+        namespaceQuota?: {
+            name: string;
+            hard: {
+                'limits.cpu': string;
+                'limits.memory': string;
+                persistentvolumeclaims: string;
+                pods: string;
+                'requests.cpu': string;
+                'requests.memory': string;
+                'requests.storage': string;
+            };
+        } | undefined;
+        backupStorage?: {
+            adapter: "s3-compatible";
+            authority: {
+                provider: string;
+                name: string;
+                requiredControlPlaneScopes: string[];
+            };
+            bucket: string;
+            region: string;
+            endpoint: string;
+            forcePathStyle: true;
+            versioning: "Enabled";
+            publicAccess: "private";
+        } | undefined;
+        certificate?: {
+            manager: "cert-manager";
+            issuerRef: {
+                kind: "ClusterIssuer" | "Issuer";
+                name: string;
+            };
+            duration: "2160h";
+            renewBefore: "360h";
+            privateKey: {
+                algorithm: "ECDSA";
+                size: 256;
+                rotationPolicy: "Always";
+            };
+            provisioning?: {
+                owner: "service-release";
+                mode: "namespace-acme-dns01";
+                server: string;
+                email: string;
+                privateKeySecretRef: {
+                    name: string;
+                };
+                solver: {
+                    provider: string;
+                    dnsZones: string[];
+                    apiToken: {
+                        environment: "local";
+                        sourceKeys: string[];
+                        target: {
+                            name: string;
+                            key: string;
+                        };
+                    };
+                };
+            } | undefined;
+        } | undefined;
+    };
+    id: string;
+    kind: "infra/service-release";
+    namespace: string;
+    gateway: {
+        name: string;
+        image: string;
+        revision: string;
+        replicas: number;
+        port: 22;
+        listenPort: number;
+        hostname: string;
+        hostKeyAuthority: {
+            publicKey: string;
+            fingerprint: string;
+            source: {
+                repository: string;
+                path: string;
+            };
+            secretRef: {
+                name: string;
+                privateKeyKey: string;
+                publicKeyKey: string;
+                mountPath: string;
+            };
+            provisioning: {
+                owner: "secret-management";
+                mode: "external-preprovisioned";
+            };
+            rotation: {
+                generation: number;
+                strategy: "preprovisioned-atomic";
+                previousFingerprint?: string | undefined;
+                knownHostsOverlapUntil?: string | undefined;
+            };
+        };
+        env: ({
+            source: "literal";
+            name: string;
+            value: string;
+        } | {
+            source: "secret";
+            name: string;
+            secretRef: {
+                name: string;
+                key: string;
+            };
+        })[];
+        secretMounts: {
+            secretName: string;
+            mountPath: string;
+            readOnly: true;
+            keys?: string[] | undefined;
+        }[];
+        resources: {
+            requests: {
+                cpu: string;
+                memory: string;
+            };
+            limits: {
+                cpu: string;
+                memory: string;
+            };
+        };
+        maxUnavailable: 0;
+        maxSurge: number;
+    };
+    controlPlaneRouter: {
+        image: string;
+        revision: string;
+        publicPort: 443;
+        listenPort: number;
+        tlsSecretRef: {
+            name: string;
+            certificateKey: string;
+            privateKeyKey: string;
+        };
+        smartGit: {
+            enabled: true;
+            authorizationOwner: "stateful";
+            pathContract: "owner/repo.git";
+        };
+        allowedPathPrefixes: string[];
+        proxyRepoBrowse: boolean;
+        proxyMergeControl: boolean;
+        resources: {
+            requests: {
+                cpu: string;
+                memory: string;
+            };
+            limits: {
+                cpu: string;
+                memory: string;
+            };
+        };
+        fallbackRedirect?: string | undefined;
+    };
+    stateful: {
+        name: string;
+        exposure: "internal";
+        adminExposure: "internal";
+        image: string;
+        revision: string;
+        replicas: 1;
+        port: number;
+        storage: {
+            mountPath: string;
+            size: string;
+            accessMode: "ReadWriteOnce";
+            schemaVersion: number;
+            releaseCompatibility: {
+                readFrom: number;
+                readThrough: number;
+                writeVersion: number;
+            };
+            storageClassName?: string | undefined;
+        };
+        backup: {
+            mode: "restic-s3";
+            toolImage: string;
+            repository: string;
+            credentials: {
+                accessKeyId: {
+                    key: string;
+                    store?: string | undefined;
+                    env?: string | undefined;
+                };
+                secretAccessKey: {
+                    key: string;
+                    store?: string | undefined;
+                    env?: string | undefined;
+                };
+                encryptionKey: {
+                    key: string;
+                    store?: string | undefined;
+                    env?: string | undefined;
+                };
+            };
+            schedule: string;
+            retention: {
+                keepDaily: number;
+                keepWeekly: number;
+                keepMonthly: number;
+            };
+            restoreVerify: {
+                schedule: string;
+                scratchSize: string;
+                timeoutSeconds: number;
+            };
+        } | {
+            mode: "csi-volume-snapshot";
+            toolImage: string;
+            snapshotClassName: string;
+            deletionPolicy: "Delete";
+            schedule: string;
+            retention: {
+                verifiedGenerations: number;
+            };
+            restoreVerify: {
+                schedule: string;
+                scratchSize: string;
+                timeoutSeconds: number;
+            };
+        };
+        env: ({
+            source: "literal";
+            name: string;
+            value: string;
+        } | {
+            source: "secret";
+            name: string;
+            secretRef: {
+                name: string;
+                key: string;
+            };
+        })[];
+        secretMounts: {
+            secretName: string;
+            mountPath: string;
+            readOnly: true;
+            keys?: string[] | undefined;
+        }[];
+        resources: {
+            requests: {
+                cpu: string;
+                memory: string;
+            };
+            limits: {
+                cpu: string;
+                memory: string;
+            };
+        };
+        repositoryMigration?: {
+            mode: "mirror-ssh";
+            migrationId: string;
+            source: {
+                origin: string;
+                inventoryUrl: string;
+                sshLeaseUrl: string;
+                inventoryAuthoritySecretRef: {
+                    name: string;
+                    key: string;
+                };
+            };
+            expected: {
+                repositoryCount: number;
+                owners: {
+                    ownerType: "user" | "organization";
+                    ownerId: string;
+                    repositoryCount: number;
+                }[];
+            };
+            receipt: {
+                configMapName: string;
+            };
+            convergence: {
+                stablePasses: 2;
+            };
+            rollback: {
+                mode: "source-authoritative-until-public-cutover";
+            };
+        } | undefined;
+    };
+    secretBindings: {
+        source: {
+            kind: "secret-store";
+            key: string;
+        } | {
+            kind: "repository-file";
+            path: string;
+        };
+        target: {
+            name: string;
+            key: string;
+        };
+        description: string;
+    }[];
+    networkPolicy: {
+        defaultDenyIngress: true;
+        allowGatewayToStateful: true;
+        egress: {
+            defaultDeny: true;
+            platformAuthCidrs: string[];
+            objectBackupCidrs?: string[] | undefined;
+            objectBackupHostnames?: string[] | undefined;
+        };
+    };
+    name?: string | undefined;
+    description?: string | undefined;
+    tags?: string[] | undefined;
+    hardware?: string[] | undefined;
+    enabled?: boolean | undefined;
+    priority?: number | undefined;
+    capabilityId?: string | undefined;
+    requiredContext?: string[] | undefined;
+    optionalContext?: string[] | undefined;
+    retention?: string | {
+        reason: string;
+        maxAgeDays?: number | undefined;
+        maxEntries?: number | undefined;
+        maxBytes?: number | undefined;
+        cascadeFrom?: string | undefined;
+        ageField?: string | undefined;
+        enforcedBy?: string | undefined;
+    } | undefined;
+}, {
+    id: string;
+    kind: "infra/service-release";
+    namespace: string;
+    gateway: {
+        name: string;
+        image: string;
+        revision: string;
+        replicas: number;
+        port: 22;
+        listenPort: number;
+        hostname: string;
+        hostKeyAuthority: {
+            publicKey: string;
+            fingerprint: string;
+            source: {
+                repository: string;
+                path: string;
+            };
+            secretRef: {
+                name: string;
+                privateKeyKey: string;
+                publicKeyKey: string;
+                mountPath: string;
+            };
+            provisioning: {
+                owner: "secret-management";
+                mode: "external-preprovisioned";
+            };
+            rotation: {
+                generation: number;
+                strategy: "preprovisioned-atomic";
+                previousFingerprint?: string | undefined;
+                knownHostsOverlapUntil?: string | undefined;
+            };
+        };
+        env: ({
+            source: "literal";
+            name: string;
+            value: string;
+        } | {
+            source: "secret";
+            name: string;
+            secretRef: {
+                name: string;
+                key: string;
+            };
+        })[];
+        secretMounts: {
+            secretName: string;
+            mountPath: string;
+            readOnly: true;
+            keys?: string[] | undefined;
+        }[];
+        resources: {
+            requests: {
+                cpu: string;
+                memory: string;
+            };
+            limits: {
+                cpu: string;
+                memory: string;
+            };
+        };
+        maxUnavailable: 0;
+        maxSurge: number;
+    };
+    controlPlaneRouter: {
+        image: string;
+        revision: string;
+        publicPort: 443;
+        listenPort: number;
+        tlsSecretRef: {
+            name: string;
+            certificateKey: string;
+            privateKeyKey: string;
+        };
+        smartGit: {
+            enabled: true;
+            authorizationOwner: "stateful";
+            pathContract: "owner/repo.git";
+        };
+        allowedPathPrefixes: string[];
+        proxyRepoBrowse: boolean;
+        proxyMergeControl: boolean;
+        resources: {
+            requests: {
+                cpu: string;
+                memory: string;
+            };
+            limits: {
+                cpu: string;
+                memory: string;
+            };
+        };
+        fallbackRedirect?: string | undefined;
+    };
+    stateful: {
+        name: string;
+        exposure: "internal";
+        adminExposure: "internal";
+        image: string;
+        revision: string;
+        replicas: 1;
+        port: number;
+        storage: {
+            mountPath: string;
+            size: string;
+            accessMode: "ReadWriteOnce";
+            schemaVersion: number;
+            releaseCompatibility: {
+                readFrom: number;
+                readThrough: number;
+                writeVersion: number;
+            };
+            storageClassName?: string | undefined;
+        };
+        backup: {
+            mode: "restic-s3";
+            toolImage: string;
+            repository: string;
+            credentials: {
+                accessKeyId: {
+                    key: string;
+                    store?: string | undefined;
+                    env?: string | undefined;
+                };
+                secretAccessKey: {
+                    key: string;
+                    store?: string | undefined;
+                    env?: string | undefined;
+                };
+                encryptionKey: {
+                    key: string;
+                    store?: string | undefined;
+                    env?: string | undefined;
+                };
+            };
+            schedule: string;
+            retention: {
+                keepDaily: number;
+                keepWeekly: number;
+                keepMonthly: number;
+            };
+            restoreVerify: {
+                schedule: string;
+                scratchSize: string;
+                timeoutSeconds: number;
+            };
+        } | {
+            mode: "csi-volume-snapshot";
+            toolImage: string;
+            snapshotClassName: string;
+            deletionPolicy: "Delete";
+            schedule: string;
+            retention: {
+                verifiedGenerations: number;
+            };
+            restoreVerify: {
+                schedule: string;
+                scratchSize: string;
+                timeoutSeconds: number;
+            };
+        };
+        env: ({
+            source: "literal";
+            name: string;
+            value: string;
+        } | {
+            source: "secret";
+            name: string;
+            secretRef: {
+                name: string;
+                key: string;
+            };
+        })[];
+        secretMounts: {
+            secretName: string;
+            mountPath: string;
+            readOnly: true;
+            keys?: string[] | undefined;
+        }[];
+        resources: {
+            requests: {
+                cpu: string;
+                memory: string;
+            };
+            limits: {
+                cpu: string;
+                memory: string;
+            };
+        };
+        repositoryMigration?: {
+            mode: "mirror-ssh";
+            migrationId: string;
+            source: {
+                origin: string;
+                inventoryUrl: string;
+                sshLeaseUrl: string;
+                inventoryAuthoritySecretRef: {
+                    name: string;
+                    key: string;
+                };
+            };
+            expected: {
+                repositoryCount: number;
+                owners: {
+                    ownerType: "user" | "organization";
+                    ownerId: string;
+                    repositoryCount: number;
+                }[];
+            };
+            receipt: {
+                configMapName: string;
+            };
+            convergence: {
+                stablePasses: 2;
+            };
+            rollback: {
+                mode: "source-authoritative-until-public-cutover";
+            };
+        } | undefined;
+    };
+    secretBindings: {
+        source: {
+            kind: "secret-store";
+            key: string;
+        } | {
+            kind: "repository-file";
+            path: string;
+        };
+        target: {
+            name: string;
+            key: string;
+        };
+        description: string;
+    }[];
+    networkPolicy: {
+        defaultDenyIngress: true;
+        allowGatewayToStateful: true;
+        egress: {
+            defaultDeny: true;
+            platformAuthCidrs: string[];
+            objectBackupCidrs?: string[] | undefined;
+            objectBackupHostnames?: string[] | undefined;
+        };
+    };
+    config: {
+        [x: string]: unknown;
+        adapter: string;
+        dnsOwnerRef: string;
+        namespaceQuota?: {
+            name: string;
+            hard: {
+                'limits.cpu': string;
+                'limits.memory': string;
+                persistentvolumeclaims: string;
+                pods: string;
+                'requests.cpu': string;
+                'requests.memory': string;
+                'requests.storage': string;
+            };
+        } | undefined;
+        backupStorage?: {
+            adapter: "s3-compatible";
+            authority: {
+                provider: string;
+                name: string;
+                requiredControlPlaneScopes: string[];
+            };
+            bucket: string;
+            region: string;
+            endpoint: string;
+            forcePathStyle: true;
+            versioning: "Enabled";
+            publicAccess: "private";
+        } | undefined;
+        certificate?: {
+            manager: "cert-manager";
+            issuerRef: {
+                kind: "ClusterIssuer" | "Issuer";
+                name: string;
+            };
+            duration: "2160h";
+            renewBefore: "360h";
+            privateKey: {
+                algorithm: "ECDSA";
+                size: 256;
+                rotationPolicy: "Always";
+            };
+            provisioning?: {
+                owner: "service-release";
+                mode: "namespace-acme-dns01";
+                server: string;
+                email: string;
+                privateKeySecretRef: {
+                    name: string;
+                };
+                solver: {
+                    provider: string;
+                    dnsZones: string[];
+                    apiToken: {
+                        environment: "local";
+                        sourceKeys: string[];
+                        target: {
+                            name: string;
+                            key: string;
+                        };
+                    };
+                };
+            } | undefined;
+        } | undefined;
+    };
+    name?: string | undefined;
+    description?: string | undefined;
+    tags?: string[] | undefined;
+    hardware?: string[] | undefined;
+    enabled?: boolean | undefined;
+    priority?: number | undefined;
+    capabilityId?: string | undefined;
+    requiredContext?: string[] | undefined;
+    optionalContext?: string[] | undefined;
+    retention?: string | {
+        reason: string;
+        maxAgeDays?: number | undefined;
+        maxEntries?: number | undefined;
+        maxBytes?: number | undefined;
+        cascadeFrom?: string | undefined;
+        ageField?: string | undefined;
+        enforcedBy?: string | undefined;
+    } | undefined;
+}>>;
+export type DigitalOceanKubernetesServiceReleaseTarget = z.infer<typeof DigitalOceanKubernetesServiceReleaseTargetSchema>;
+export type DigitalOceanKubernetesServiceReleaseConfig = z.infer<typeof DigitalOceanKubernetesServiceReleaseConfigSchema>;
+export type DigitalOceanServiceReleaseDescriptor = z.infer<typeof DigitalOceanServiceReleaseDescriptorSchema>;
+//# sourceMappingURL=service-release-schemas.d.ts.map