typekro 0.3.0 → 0.4.0

package/dist/factories/cert-manager/types.d.ts

@@ -0,0 +1,1015 @@
+export interface ResourceRequirements {
+    limits?: {
+        cpu?: string;
+        memory?: string;
+        [key: string]: string | undefined;
+    };
+    requests?: {
+        cpu?: string;
+        memory?: string;
+        [key: string]: string | undefined;
+    };
+}
+export interface Toleration {
+    key?: string;
+    operator?: 'Exists' | 'Equal';
+    value?: string;
+    effect?: 'NoSchedule' | 'PreferNoSchedule' | 'NoExecute';
+    tolerationSeconds?: number;
+}
+export interface NodeAffinity {
+    requiredDuringSchedulingIgnoredDuringExecution?: {
+        nodeSelectorTerms: {
+            matchExpressions?: {
+                key: string;
+                operator: 'In' | 'NotIn' | 'Exists' | 'DoesNotExist' | 'Gt' | 'Lt';
+                values?: string[];
+            }[];
+            matchFields?: {
+                key: string;
+                operator: 'In' | 'NotIn' | 'Exists' | 'DoesNotExist' | 'Gt' | 'Lt';
+                values?: string[];
+            }[];
+        }[];
+    };
+    preferredDuringSchedulingIgnoredDuringExecution?: {
+        weight: number;
+        preference: {
+            matchExpressions?: {
+                key: string;
+                operator: 'In' | 'NotIn' | 'Exists' | 'DoesNotExist' | 'Gt' | 'Lt';
+                values?: string[];
+            }[];
+            matchFields?: {
+                key: string;
+                operator: 'In' | 'NotIn' | 'Exists' | 'DoesNotExist' | 'Gt' | 'Lt';
+                values?: string[];
+            }[];
+        };
+    }[];
+}
+export interface PodAffinity {
+    requiredDuringSchedulingIgnoredDuringExecution?: {
+        labelSelector?: {
+            matchExpressions?: {
+                key: string;
+                operator: 'In' | 'NotIn' | 'Exists' | 'DoesNotExist';
+                values?: string[];
+            }[];
+            matchLabels?: Record<string, string>;
+        };
+        namespaces?: string[];
+        topologyKey: string;
+    }[];
+    preferredDuringSchedulingIgnoredDuringExecution?: {
+        weight: number;
+        podAffinityTerm: {
+            labelSelector?: {
+                matchExpressions?: {
+                    key: string;
+                    operator: 'In' | 'NotIn' | 'Exists' | 'DoesNotExist';
+                    values?: string[];
+                }[];
+                matchLabels?: Record<string, string>;
+            };
+            namespaces?: string[];
+            topologyKey: string;
+        };
+    }[];
+}
+export interface PodAntiAffinity {
+    requiredDuringSchedulingIgnoredDuringExecution?: {
+        labelSelector?: {
+            matchExpressions?: {
+                key: string;
+                operator: 'In' | 'NotIn' | 'Exists' | 'DoesNotExist';
+                values?: string[];
+            }[];
+            matchLabels?: Record<string, string>;
+        };
+        namespaces?: string[];
+        topologyKey: string;
+    }[];
+    preferredDuringSchedulingIgnoredDuringExecution?: {
+        weight: number;
+        podAffinityTerm: {
+            labelSelector?: {
+                matchExpressions?: {
+                    key: string;
+                    operator: 'In' | 'NotIn' | 'Exists' | 'DoesNotExist';
+                    values?: string[];
+                }[];
+                matchLabels?: Record<string, string>;
+            };
+            namespaces?: string[];
+            topologyKey: string;
+        };
+    }[];
+}
+export interface Affinity {
+    nodeAffinity?: NodeAffinity;
+    podAffinity?: PodAffinity;
+    podAntiAffinity?: PodAntiAffinity;
+}
+export interface SecurityContext {
+    runAsUser?: number;
+    runAsGroup?: number;
+    runAsNonRoot?: boolean;
+    fsGroup?: number;
+    seLinuxOptions?: {
+        level?: string;
+        role?: string;
+        type?: string;
+        user?: string;
+    };
+    windowsOptions?: {
+        gmsaCredentialSpec?: string;
+        gmsaCredentialSpecName?: string;
+        hostProcess?: boolean;
+        runAsUserName?: string;
+    };
+    fsGroupChangePolicy?: 'Always' | 'OnRootMismatch';
+    supplementalGroups?: number[];
+}
+export interface EnvVar {
+    name: string;
+    value?: string;
+    valueFrom?: {
+        fieldRef?: {
+            apiVersion?: string;
+            fieldPath: string;
+        };
+        resourceFieldRef?: {
+            containerName?: string;
+            resource: string;
+            divisor?: string;
+        };
+        configMapKeyRef?: {
+            name?: string;
+            key: string;
+            optional?: boolean;
+        };
+        secretKeyRef?: {
+            name?: string;
+            key: string;
+            optional?: boolean;
+        };
+    };
+}
+export interface Volume {
+    name: string;
+    hostPath?: {
+        path: string;
+        type?: string;
+    };
+    emptyDir?: {
+        medium?: string;
+        sizeLimit?: string;
+    };
+    secret?: {
+        secretName?: string;
+        items?: {
+            key: string;
+            path: string;
+            mode?: number;
+        }[];
+        defaultMode?: number;
+        optional?: boolean;
+    };
+    configMap?: {
+        name?: string;
+        items?: {
+            key: string;
+            path: string;
+            mode?: number;
+        }[];
+        defaultMode?: number;
+        optional?: boolean;
+    };
+    persistentVolumeClaim?: {
+        claimName: string;
+        readOnly?: boolean;
+    };
+}
+export interface VolumeMount {
+    name: string;
+    mountPath: string;
+    subPath?: string;
+    readOnly?: boolean;
+    mountPropagation?: 'None' | 'HostToContainer' | 'Bidirectional';
+}
+export interface LabelSelector {
+    matchExpressions?: {
+        key: string;
+        operator: 'In' | 'NotIn' | 'Exists' | 'DoesNotExist';
+        values?: string[];
+    }[];
+    matchLabels?: Record<string, string>;
+}
+export interface CertManagerBootstrapConfig {
+    name: string;
+    namespace?: string;
+    version?: string;
+    global?: {
+        leaderElection?: {
+            namespace?: string;
+        };
+        logLevel?: number;
+        podSecurityPolicy?: {
+            enabled?: boolean;
+            useAppArmor?: boolean;
+        };
+    };
+    installCRDs?: boolean;
+    replicaCount?: number;
+    strategy?: {
+        type?: 'Recreate' | 'RollingUpdate';
+        rollingUpdate?: {
+            maxSurge?: number | string;
+            maxUnavailable?: number | string;
+        };
+    };
+    controller?: {
+        image?: {
+            repository?: string;
+            tag?: string;
+            pullPolicy?: 'Always' | 'IfNotPresent' | 'Never';
+        };
+        resources?: ResourceRequirements;
+        nodeSelector?: Record<string, string>;
+        tolerations?: Toleration[];
+        affinity?: Affinity;
+        securityContext?: SecurityContext;
+        containerSecurityContext?: SecurityContext;
+        volumes?: Volume[];
+        volumeMounts?: VolumeMount[];
+        extraArgs?: string[];
+        env?: EnvVar[];
+        serviceAccount?: {
+            create?: boolean;
+            name?: string;
+            annotations?: Record<string, string>;
+        };
+    };
+    webhook?: {
+        enabled?: boolean;
+        replicaCount?: number;
+        image?: {
+            repository?: string;
+            tag?: string;
+            pullPolicy?: 'Always' | 'IfNotPresent' | 'Never';
+        };
+        resources?: ResourceRequirements;
+        nodeSelector?: Record<string, string>;
+        tolerations?: Toleration[];
+        affinity?: Affinity;
+        securityContext?: SecurityContext;
+        containerSecurityContext?: SecurityContext;
+        args?: string[];
+        env?: EnvVar[];
+        serviceAccount?: {
+            create?: boolean;
+            name?: string;
+            annotations?: Record<string, string>;
+        };
+        config?: {
+            apiVersion?: string;
+            kind?: string;
+            metadata?: {
+                name?: string;
+            };
+            webhooks?: WebhookConfig[];
+        };
+        mutatingAdmissionWebhooks?: {
+            failurePolicy?: 'Fail' | 'Ignore';
+            admissionReviewVersions?: string[];
+            timeoutSeconds?: number;
+        };
+        validatingAdmissionWebhooks?: {
+            failurePolicy?: 'Fail' | 'Ignore';
+            admissionReviewVersions?: string[];
+            timeoutSeconds?: number;
+        };
+    };
+    cainjector?: {
+        enabled?: boolean;
+        replicaCount?: number;
+        image?: {
+            repository?: string;
+            tag?: string;
+            pullPolicy?: 'Always' | 'IfNotPresent' | 'Never';
+        };
+        resources?: ResourceRequirements;
+        nodeSelector?: Record<string, string>;
+        tolerations?: Toleration[];
+        affinity?: Affinity;
+        securityContext?: SecurityContext;
+        containerSecurityContext?: SecurityContext;
+        args?: string[];
+        env?: EnvVar[];
+        serviceAccount?: {
+            create?: boolean;
+            name?: string;
+            annotations?: Record<string, string>;
+        };
+    };
+    acmesolver?: {
+        image?: {
+            repository?: string;
+            tag?: string;
+            pullPolicy?: 'Always' | 'IfNotPresent' | 'Never';
+        };
+        resources?: ResourceRequirements;
+        nodeSelector?: Record<string, string>;
+        tolerations?: Toleration[];
+        affinity?: Affinity;
+        securityContext?: SecurityContext;
+        containerSecurityContext?: SecurityContext;
+    };
+    startupapicheck?: {
+        enabled?: boolean;
+        image?: {
+            repository?: string;
+            tag?: string;
+            pullPolicy?: 'Always' | 'IfNotPresent' | 'Never';
+        };
+        resources?: ResourceRequirements;
+        nodeSelector?: Record<string, string>;
+        tolerations?: Toleration[];
+        affinity?: Affinity;
+        securityContext?: SecurityContext;
+        containerSecurityContext?: SecurityContext;
+        timeout?: string;
+        backoffLimit?: number;
+        jobAnnotations?: Record<string, string>;
+        podAnnotations?: Record<string, string>;
+    };
+    prometheus?: {
+        enabled?: boolean;
+        servicemonitor?: {
+            enabled?: boolean;
+            prometheusInstance?: string;
+            targetPort?: number;
+            path?: string;
+            interval?: string;
+            scrapeTimeout?: string;
+            labels?: Record<string, string>;
+            honorLabels?: boolean;
+        };
+    };
+    customValues?: Record<string, any>;
+    id?: string;
+}
+export interface CertManagerBootstrapStatus {
+    phase: 'Pending' | 'Installing' | 'Ready' | 'Failed' | 'Upgrading';
+    ready: boolean;
+    version: string;
+    controllerReady: boolean;
+    webhookReady: boolean;
+    cainjectorReady: boolean;
+    crds: {
+        installed: boolean;
+        version: string;
+    };
+}
+export interface WebhookConfig {
+    name: string;
+    clientConfig: {
+        service?: {
+            name: string;
+            namespace: string;
+            path?: string;
+            port?: number;
+        };
+        url?: string;
+        caBundle?: string;
+    };
+    rules?: {
+        operations: ('CREATE' | 'UPDATE' | 'DELETE' | 'CONNECT')[];
+        apiGroups: string[];
+        apiVersions: string[];
+        resources: string[];
+        scope?: 'Cluster' | 'Namespaced' | '*';
+    }[];
+    admissionReviewVersions: string[];
+    sideEffects: 'None' | 'NoneOnDryRun' | 'Some' | 'Unknown';
+    timeoutSeconds?: number;
+    failurePolicy?: 'Fail' | 'Ignore';
+    matchPolicy?: 'Exact' | 'Equivalent';
+    namespaceSelector?: LabelSelector;
+    objectSelector?: LabelSelector;
+}
+export interface CertificateConfig {
+    name: string;
+    namespace?: string;
+    spec: {
+        secretName: string;
+        issuerRef: {
+            name: string;
+            kind: 'Issuer' | 'ClusterIssuer';
+            group?: string;
+        };
+        commonName?: string;
+        dnsNames?: string[];
+        ipAddresses?: string[];
+        uris?: string[];
+        emailAddresses?: string[];
+        subject?: {
+            organizationalUnits?: string[];
+            countries?: string[];
+            organizations?: string[];
+            localities?: string[];
+            provinces?: string[];
+            streetAddresses?: string[];
+            postalCodes?: string[];
+            serialNumber?: string;
+        };
+        duration?: string;
+        renewBefore?: string;
+        usages?: ('signing' | 'digital signature' | 'content commitment' | 'key encipherment' | 'key agreement' | 'data encipherment' | 'cert sign' | 'crl sign' | 'encipher only' | 'decipher only' | 'any' | 'server auth' | 'client auth' | 'code signing' | 'email protection' | 's/mime' | 'ipsec end system' | 'ipsec tunnel' | 'ipsec user' | 'timestamping' | 'ocsp signing' | 'microsoft sgc' | 'netscape sgc')[];
+        privateKey?: {
+            algorithm?: 'RSA' | 'ECDSA' | 'Ed25519';
+            encoding?: 'PKCS1' | 'PKCS8';
+            size?: number;
+            rotationPolicy?: 'Never' | 'Always';
+        };
+        keystores?: {
+            jks?: {
+                create?: boolean;
+                passwordSecretRef?: {
+                    name: string;
+                    key: string;
+                };
+            };
+            pkcs12?: {
+                create?: boolean;
+                passwordSecretRef?: {
+                    name: string;
+                    key: string;
+                };
+            };
+        };
+        additionalOutputFormats?: {
+            type: 'DER' | 'CombinedPEM';
+        }[];
+        secretTemplate?: {
+            annotations?: Record<string, string>;
+            labels?: Record<string, string>;
+        };
+    };
+    id?: string;
+}
+export interface ClusterIssuerConfig {
+    name: string;
+    spec: {
+        acme?: {
+            server: string;
+            email: string;
+            privateKeySecretRef: {
+                name: string;
+            };
+            externalAccountBinding?: {
+                keyID: string;
+                keySecretRef: {
+                    name: string;
+                    key: string;
+                };
+                keyAlgorithm?: 'HS256' | 'HS384' | 'HS512';
+            };
+            solvers: {
+                selector?: {
+                    dnsNames?: string[];
+                    dnsZones?: string[];
+                    matchLabels?: Record<string, string>;
+                };
+                http01?: {
+                    ingress?: {
+                        class?: string;
+                        name?: string;
+                        podTemplate?: {
+                            metadata?: {
+                                annotations?: Record<string, string>;
+                                labels?: Record<string, string>;
+                            };
+                            spec?: {
+                                nodeSelector?: Record<string, string>;
+                                tolerations?: Toleration[];
+                                affinity?: Affinity;
+                            };
+                        };
+                        serviceType?: 'ClusterIP' | 'NodePort' | 'LoadBalancer';
+                    };
+                    gateway?: {
+                        name: string;
+                        namespace?: string;
+                        httpRoute?: {
+                            labels?: Record<string, string>;
+                        };
+                    };
+                };
+                dns01?: {
+                    cnameStrategy?: 'Follow' | 'None';
+                    route53?: {
+                        accessKeyID?: string;
+                        accessKeyIDSecretRef?: {
+                            name: string;
+                            key: string;
+                            namespace?: string;
+                        };
+                        secretAccessKeySecretRef?: {
+                            name: string;
+                            key: string;
+                            namespace?: string;
+                        };
+                        region: string;
+                        hostedZoneID?: string;
+                        role?: string;
+                    };
+                    azureDNS?: {
+                        clientID?: string;
+                        clientSecretSecretRef?: {
+                            name: string;
+                            key: string;
+                        };
+                        subscriptionID: string;
+                        tenantID: string;
+                        resourceGroupName: string;
+                        hostedZoneName?: string;
+                        environment?: 'AzurePublicCloud' | 'AzureChinaCloud' | 'AzureGermanCloud' | 'AzureUSGovernmentCloud';
+                    };
+                    cloudflare?: {
+                        email?: string;
+                        apiKeySecretRef?: {
+                            name: string;
+                            key: string;
+                        };
+                        apiTokenSecretRef?: {
+                            name: string;
+                            key: string;
+                        };
+                    };
+                    cloudDNS?: {
+                        project: string;
+                        serviceAccountSecretRef?: {
+                            name: string;
+                            key: string;
+                        };
+                    };
+                    digitalocean?: {
+                        tokenSecretRef: {
+                            name: string;
+                            key: string;
+                        };
+                    };
+                    rfc2136?: {
+                        nameserver: string;
+                        tsigKeyName?: string;
+                        tsigAlgorithm?: string;
+                        tsigSecretSecretRef?: {
+                            name: string;
+                            key: string;
+                        };
+                    };
+                    webhook?: {
+                        groupName: string;
+                        solverName: string;
+                        config?: Record<string, any>;
+                    };
+                };
+            }[];
+        };
+        ca?: {
+            secretName: string;
+            crlDistributionPoints?: string[];
+            ocspServers?: string[];
+            issuingCertificateURLs?: string[];
+        };
+        vault?: {
+            server: string;
+            path: string;
+            namespace?: string;
+            caBundle?: string;
+            auth: {
+                tokenSecretRef?: {
+                    name: string;
+                    key: string;
+                };
+                appRole?: {
+                    path: string;
+                    roleId: string;
+                    secretRef: {
+                        name: string;
+                        key: string;
+                    };
+                };
+                kubernetes?: {
+                    mountPath: string;
+                    role: string;
+                    secretRef?: {
+                        name: string;
+                        key: string;
+                    };
+                };
+            };
+        };
+        venafi?: {
+            zone: string;
+            tpp?: {
+                url: string;
+                credentialsRef: {
+                    name: string;
+                };
+                caBundle?: string;
+            };
+            cloud?: {
+                url?: string;
+                apiTokenSecretRef: {
+                    name: string;
+                    key: string;
+                };
+            };
+        };
+        selfSigned?: {
+            crlDistributionPoints?: string[];
+        };
+    };
+    id?: string;
+}
+export interface IssuerConfig {
+    name: string;
+    namespace?: string;
+    spec: ClusterIssuerConfig['spec'];
+    id?: string;
+}
+export interface ChallengeConfig {
+    name: string;
+    namespace?: string;
+    spec: {
+        url: string;
+        authorizationURL: string;
+        dnsName: string;
+        wildcard?: boolean;
+        type: 'HTTP-01' | 'DNS-01';
+        token: string;
+        key: string;
+        solver: {
+            selector?: {
+                dnsNames?: string[];
+                dnsZones?: string[];
+                matchLabels?: Record<string, string>;
+            };
+            http01?: {
+                ingress?: {
+                    class?: string;
+                    name?: string;
+                    podTemplate?: {
+                        metadata?: {
+                            annotations?: Record<string, string>;
+                            labels?: Record<string, string>;
+                        };
+                        spec?: {
+                            nodeSelector?: Record<string, string>;
+                            tolerations?: Toleration[];
+                            affinity?: Affinity;
+                        };
+                    };
+                    serviceType?: 'ClusterIP' | 'NodePort' | 'LoadBalancer';
+                };
+            };
+            dns01?: {
+                cnameStrategy?: 'Follow' | 'None';
+                route53?: {
+                    accessKeyID?: string;
+                    secretAccessKeySecretRef?: {
+                        name: string;
+                        key: string;
+                    };
+                    region: string;
+                    hostedZoneID?: string;
+                    role?: string;
+                };
+                azureDNS?: {
+                    clientID?: string;
+                    clientSecretSecretRef?: {
+                        name: string;
+                        key: string;
+                    };
+                    subscriptionID: string;
+                    tenantID: string;
+                    resourceGroupName: string;
+                    hostedZoneName?: string;
+                    environment?: 'AzurePublicCloud' | 'AzureChinaCloud' | 'AzureGermanCloud' | 'AzureUSGovernmentCloud';
+                };
+                cloudflare?: {
+                    email?: string;
+                    apiKeySecretRef?: {
+                        name: string;
+                        key: string;
+                    };
+                    apiTokenSecretRef?: {
+                        name: string;
+                        key: string;
+                    };
+                };
+                cloudDNS?: {
+                    project: string;
+                    serviceAccountSecretRef?: {
+                        name: string;
+                        key: string;
+                    };
+                };
+                digitalocean?: {
+                    tokenSecretRef: {
+                        name: string;
+                        key: string;
+                    };
+                };
+                rfc2136?: {
+                    nameserver: string;
+                    tsigKeyName?: string;
+                    tsigAlgorithm?: string;
+                    tsigSecretSecretRef?: {
+                        name: string;
+                        key: string;
+                    };
+                };
+                webhook?: {
+                    groupName: string;
+                    solverName: string;
+                    config?: Record<string, any>;
+                };
+            };
+        };
+        issuerRef: {
+            name: string;
+            kind: 'Issuer' | 'ClusterIssuer';
+            group?: string;
+        };
+    };
+    id?: string;
+}
+export interface OrderConfig {
+    name: string;
+    namespace?: string;
+    spec: {
+        request: string;
+        issuerRef: {
+            name: string;
+            kind: 'Issuer' | 'ClusterIssuer';
+            group?: string;
+        };
+        commonName?: string;
+        dnsNames?: string[];
+        ipAddresses?: string[];
+        duration?: string;
+    };
+    id?: string;
+}
+export interface CertificateCondition {
+    type: 'Ready' | 'Issuing';
+    status: 'True' | 'False' | 'Unknown';
+    lastTransitionTime?: string;
+    reason?: string;
+    message?: string;
+}
+export interface CertificateStatus {
+    conditions?: CertificateCondition[];
+    lastFailureTime?: string;
+    notAfter?: string;
+    notBefore?: string;
+    renewalTime?: string;
+    revision?: number;
+    nextPrivateKeySecretName?: string;
+}
+export interface IssuerCondition {
+    type: 'Ready';
+    status: 'True' | 'False' | 'Unknown';
+    lastTransitionTime?: string;
+    reason?: string;
+    message?: string;
+}
+export interface IssuerStatus {
+    conditions?: IssuerCondition[];
+    acme?: {
+        uri?: string;
+        lastRegisteredEmail?: string;
+    };
+}
+export interface ChallengeStatus {
+    processing?: boolean;
+    presented?: boolean;
+    reason?: string;
+    state?: 'valid' | 'ready' | 'pending' | 'processing' | 'invalid' | 'expired' | 'errored';
+}
+export interface OrderStatus {
+    state?: 'valid' | 'ready' | 'pending' | 'processing' | 'invalid' | 'expired' | 'errored';
+    reason?: string;
+    url?: string;
+    finalizeURL?: string;
+    certificate?: string;
+    authorizations?: {
+        url: string;
+        identifier: {
+            type: string;
+            value: string;
+        };
+        wildcard?: boolean;
+        challenges?: {
+            url: string;
+            token: string;
+            type: string;
+        }[];
+    }[];
+}
+import { type Type } from 'arktype';
+/**
+ * ArkType schema for CertManagerBootstrapConfig
+ * Following KroCompatibleType constraints - only basic types, nested objects, and optional fields
+ */
+export declare const CertManagerBootstrapConfigSchema: Type<CertManagerBootstrapConfig>;
+/**
+ * ArkType schema for CertManagerBootstrapStatus
+ * Following KroCompatibleType constraints - only basic types, nested objects, and optional fields
+ */
+export declare const CertManagerBootstrapStatusSchema: Type<CertManagerBootstrapStatus>;
+/**
+ * Configuration interface for Cert-Manager HelmRepository
+ */
+export interface CertManagerHelmRepositoryConfig {
+    name: string;
+    namespace?: string;
+    url?: string;
+    interval?: string;
+    id?: string;
+}
+/**
+ * Configuration interface for Cert-Manager HelmRelease
+ */
+export interface CertManagerHelmReleaseConfig {
+    name: string;
+    namespace?: string;
+    repositoryName?: string;
+    version?: string;
+    values?: CertManagerHelmValues;
+    id?: string;
+}
+/**
+ * Cert-Manager Helm values interface
+ * Based on the official cert-manager Helm chart values
+ */
+export interface CertManagerHelmValues {
+    installCRDs?: boolean;
+    global?: {
+        leaderElection?: {
+            namespace?: string;
+        };
+        logLevel?: number;
+        podSecurityPolicy?: {
+            enabled?: boolean;
+            useAppArmor?: boolean;
+        };
+    };
+    replicaCount?: number;
+    strategy?: {
+        type?: 'Recreate' | 'RollingUpdate';
+        rollingUpdate?: {
+            maxSurge?: number | string;
+            maxUnavailable?: number | string;
+        };
+    };
+    image?: {
+        repository?: string;
+        tag?: string;
+        pullPolicy?: 'Always' | 'IfNotPresent' | 'Never';
+    };
+    controller?: {
+        image?: {
+            repository?: string;
+            tag?: string;
+            pullPolicy?: 'Always' | 'IfNotPresent' | 'Never';
+        };
+        resources?: ResourceRequirements;
+        nodeSelector?: Record<string, string>;
+        tolerations?: Toleration[];
+        affinity?: Affinity;
+        securityContext?: SecurityContext;
+        containerSecurityContext?: SecurityContext;
+        volumes?: Volume[];
+        volumeMounts?: VolumeMount[];
+        extraArgs?: string[];
+        env?: EnvVar[];
+        serviceAccount?: {
+            create?: boolean;
+            name?: string;
+            annotations?: Record<string, string>;
+        };
+    };
+    webhook?: {
+        enabled?: boolean;
+        replicaCount?: number;
+        image?: {
+            repository?: string;
+            tag?: string;
+            pullPolicy?: 'Always' | 'IfNotPresent' | 'Never';
+        };
+        resources?: ResourceRequirements;
+        nodeSelector?: Record<string, string>;
+        tolerations?: Toleration[];
+        affinity?: Affinity;
+        securityContext?: SecurityContext;
+        containerSecurityContext?: SecurityContext;
+        args?: string[];
+        env?: EnvVar[];
+        serviceAccount?: {
+            create?: boolean;
+            name?: string;
+            annotations?: Record<string, string>;
+        };
+        config?: {
+            apiVersion?: string;
+            kind?: string;
+            metadata?: {
+                name?: string;
+            };
+            webhooks?: WebhookConfig[];
+        };
+        mutatingAdmissionWebhooks?: {
+            failurePolicy?: 'Fail' | 'Ignore';
+            admissionReviewVersions?: string[];
+            timeoutSeconds?: number;
+        };
+        validatingAdmissionWebhooks?: {
+            failurePolicy?: 'Fail' | 'Ignore';
+            admissionReviewVersions?: string[];
+            timeoutSeconds?: number;
+        };
+    };
+    cainjector?: {
+        enabled?: boolean;
+        replicaCount?: number;
+        image?: {
+            repository?: string;
+            tag?: string;
+            pullPolicy?: 'Always' | 'IfNotPresent' | 'Never';
+        };
+        resources?: ResourceRequirements;
+        nodeSelector?: Record<string, string>;
+        tolerations?: Toleration[];
+        affinity?: Affinity;
+        securityContext?: SecurityContext;
+        containerSecurityContext?: SecurityContext;
+        args?: string[];
+        env?: EnvVar[];
+        serviceAccount?: {
+            create?: boolean;
+            name?: string;
+            annotations?: Record<string, string>;
+        };
+    };
+    acmesolver?: {
+        image?: {
+            repository?: string;
+            tag?: string;
+            pullPolicy?: 'Always' | 'IfNotPresent' | 'Never';
+        };
+        resources?: ResourceRequirements;
+        nodeSelector?: Record<string, string>;
+        tolerations?: Toleration[];
+        affinity?: Affinity;
+        securityContext?: SecurityContext;
+        containerSecurityContext?: SecurityContext;
+    };
+    startupapicheck?: {
+        enabled?: boolean;
+        image?: {
+            repository?: string;
+            tag?: string;
+            pullPolicy?: 'Always' | 'IfNotPresent' | 'Never';
+        };
+        resources?: ResourceRequirements;
+        nodeSelector?: Record<string, string>;
+        tolerations?: Toleration[];
+        affinity?: Affinity;
+        securityContext?: SecurityContext;
+        containerSecurityContext?: SecurityContext;
+        timeout?: string;
+        backoffLimit?: number;
+        jobAnnotations?: Record<string, string>;
+        podAnnotations?: Record<string, string>;
+    };
+    prometheus?: {
+        enabled?: boolean;
+        servicemonitor?: {
+            enabled?: boolean;
+            prometheusInstance?: string;
+            targetPort?: number;
+            path?: string;
+            interval?: string;
+            scrapeTimeout?: string;
+            labels?: Record<string, string>;
+            honorLabels?: boolean;
+        };
+    };
+    [key: string]: any;
+}
+//# sourceMappingURL=types.d.ts.map