import { EnvVar, KubernetesResource, Probe, Condition, StringMap, WorkloadStatus, LabelSelector } from '@alauda-fe/common';
import { Selector } from '@alauda-fe/crd-form';
import { OamAppOriginalStatusEnum } from './status';
export declare enum SERVICE_APP_PROTOCOL {
    tcp = "TCP",
    udp = "UDP",
    http = "HTTP",
    https = "HTTPS",
    http2 = "HTTP2",
    grpc = "gRPC"
}
export interface AdvancedAPIVolumeSpec {
    storageClassName?: string;
    accessModes: string[];
    resources: {
        requests: {
            storage: string;
        };
    };
    volumeMode?: string;
}
export interface AdvancedApiVolume extends KubernetesResource {
    spec?: AdvancedAPIVolumeSpec;
    status?: {
        phase: string;
        progress: string;
        capacity?: {
            storage: string;
        };
    };
}
export interface Topology extends KubernetesResource {
    spec: {
        owner?: KubernetesResource;
        resources?: KubernetesResource[];
    };
}
export interface OamApplicationWorkflow {
    steps: OamApplicationWorkflowStep[];
}
export interface OamApplication extends KubernetesResource {
    spec: {
        components: OamComponent[];
        workflow?: OamApplicationWorkflow;
    };
    status?: OamApplicationStatus;
}
export interface OamComponent {
    name: string;
    type: string;
    properties?: any;
    traits: OamTrait[];
}
export declare enum OamTraitTypeInside {
    Scaler = "scaler",
    Ingress = "ingress",
    Hpa = "hpa",
    Env = "env",
    Healthcheck = "healthcheck",
    Monitor = "monitor",
    Patch = "generic-patch"
}
export interface OamTrait {
    type: string;
    properties: OamTraitScaler | OamTraitIngress | OamTraitHpa | OamTraitEnv | OamTraitMonitor;
}
export declare enum ScalerActionEnum {
    Start = "start",
    Stop = "stop"
}
export interface OamTraitScaler {
    action?: ScalerActionEnum;
    replicas?: number;
}
export declare enum OamTraitIngressType {
    HTTP = "http",
    HTTPS = "https"
}
export interface OamTraitIngress {
    domain?: string;
    type?: OamTraitIngressType;
    tls?: string;
    tlsType?: string;
    http?: {
        [x: string]: number;
    };
}
export interface OamTraitHpaMetrics {
    type: string;
    name: string;
    value: string;
    describedObject?: HpaIndicatedDescribedObject;
}
export declare enum OamTraitMonitorSourceSchemeType {
    HTTP = "http",
    HTTPS = "https",
    TCP = "tcp"
}
export interface HpaIndicatedDescribedObject {
    apiVersion: string;
    kind: string;
    name: string;
}
export interface OamTraitMonitorSource {
    path: string;
    scheme: OamTraitMonitorSourceSchemeType;
    port: number;
    interval: number;
}
export interface OamTraitMonitor {
    sources: OamTraitMonitorSource[];
    metrics: OamTraitMonitorMetric[];
}
export interface OamTraitMonitorMetric {
    uid: string;
    title: string;
    description?: string;
    name: string;
    unit: string;
    expression: string;
}
export interface OamTraitHpaScalePolicy {
    type: 'Percent' | 'Pods';
    value: number;
    stabilizationWindowSeconds: number;
}
export interface OamTraitHpa {
    maxReplicas: number;
    minReplicas: number;
    metrics: OamTraitHpaMetrics[];
    scalePolicy?: {
        up?: OamTraitHpaScalePolicy;
        down?: OamTraitHpaScalePolicy;
    };
}
export interface OamTraitHealthCheck {
    livenessProbe?: Probe;
    readinessProbe?: Probe;
}
export interface OamTraitEnv {
    env?: EnvVar[];
}
export declare enum OamComponentVolumeTypeEnum {
    pvc = "pvc",
    configMap = "configMap",
    secret = "secret",
    emptyDir = "emptyDir",
    oamConfig = "oamConfig"
}
export interface OamComponentVolume {
    name: string;
    mountPath: string;
    type: OamComponentVolumeTypeEnum;
    isAppResource?: boolean;
    defaultMode?: number;
    claimName?: string;
    cmName?: string;
    secretName?: string;
    items?: OamComponentVolumeKeyPath[];
    medium?: '' | 'Memory';
}
export interface OamComponentVolumeModel {
    name: string;
    mountPath: string;
    type: OamComponentVolumeTypeEnum;
    isAppResource?: boolean;
    defaultMode?: number;
    claimName?: string;
    emptyDirName?: string;
    oamConfig?: OamApplicationWorkflowStepConfig;
    items?: OamComponentVolumeKeyPath[];
    medium?: '' | 'Memory';
}
export interface OamComponentVolumeKeyPath {
    key: string;
    path: string;
    mode: number;
}
export declare enum PortProtocol {
    Tcp = "tcp",
    Udp = "udp",
    Http = "http",
    Https = "https",
    http2 = "http2",
    grpc = "grpc"
}
export declare enum PortProtocolLabel {
    Tcp = "TCP",
    Udp = "UDP",
    Http = "HTTP",
    Https = "HTTPS",
    http2 = "HTTPS",
    grpc = "gRPC"
}
export declare enum PortType {
    Internal = "internal",
    External = "external"
}
export interface OamComponentWebServicePort {
    protocol: PortProtocol;
    port: number;
    type: PortType;
}
export interface OamComponentWebService {
    image: string;
    imagePullPolicy?: string;
    imagePullSecrets?: string[];
    ports?: OamComponentWebServicePort[];
    addRevisionLabel?: boolean;
    cmd?: string[];
    env?: EnvVar[];
    cpu?: string;
    memory?: string;
    volumes?: OamComponentVolume[];
}
export interface OamApplicationStatusService {
    name: string;
    workloadDefinition: {
        apiVersion: string;
        kind: string;
    };
}
export interface OamApplicationStatus {
    status: string;
    latestRevision?: {
        name: string;
        revision: number;
        revisionHash: string;
    };
    services?: OamApplicationStatusService[];
}
export interface OamAppStatus extends KubernetesResource {
    spec?: OamAppStatusSpec;
}
export interface OamAppStatusSpec {
    appcreatetime: string;
    appupdatetime: string;
    components: OamAppStatusSpecComponent[];
    reason: string;
    status: OamAppOriginalStatusEnum;
    storages?: OamAppStatusSpecStorages;
}
export interface OamAppStatusSpecStorages {
    [key: string]: {
        name: string;
        type: string;
        resizeable: boolean;
    };
}
export interface OamAppStatusSpecComponent {
    name: string;
    reason: string;
    revision: string;
    status: OamAppOriginalStatusEnum;
    alerts?: number;
    serviceAddresses?: {
        internal: Array<{
            address: string;
        }>;
        external: Array<{
            address: string;
        }>;
    };
}
export interface OamComponentDefinition extends KubernetesResource {
    spec?: OamComponentDefinitionSpec;
    status?: OamDefinitionStatus;
}
export interface OamComponentDefinitionSpec {
    schematic: {
        cure: {
            template: string;
        };
    };
    workload: {
        definition: {
            apiVersion: string;
            kind: string;
        };
    };
}
export interface OamTraitDefinition extends KubernetesResource {
    spec?: OamTraitDefinitionSpec;
    status?: OamDefinitionStatus;
}
export interface OamTraitDefinitionSpec {
    appliesToWorkloads: string[];
    conflictsWith?: string[];
    podDisruptive?: boolean;
    schematic?: {
        spec: {
            template: string;
        };
    };
}
export interface OamDefinitionStatus {
    configMapRef?: string;
}
export interface OamApplicationRevisionSpec {
    application: OamApplication;
}
export interface OamApplicationRevision extends KubernetesResource {
    spec?: OamApplicationRevisionSpec;
}
export declare enum WorkflowStepType {
    ApplyStorages = "apply-storages",
    ApplyConfigs = "apply-configs"
}
export interface OamApplicationWorkflowStep {
    name: string;
    type: string;
    properties?: {
        storages?: OamApplicationWorkflowStepStorage[];
        configs?: OamApplicationWorkflowStepConfig[];
    };
}
export interface OamApplicationWorkflowStepStorage {
    name: string;
    size?: string;
    type?: string;
    cluster?: string;
    stepType?: string;
    stepName?: string;
}
export interface OamApplicationWorkflowStepConfig {
    name: string;
    type?: string;
    data?: StringMap;
    cluster?: string;
    stepType?: string;
    stepName?: string;
}
export interface AlaudaBucketRequest extends KubernetesResource {
    apiVersion: 'cosi.alauda.io/v1alpha1';
    kind: 'AlaudaBucketRequest';
    spec: {
        bucketClassName: string;
        defaultBucketAccess: {
            name: string;
            className: string;
        };
    };
    status?: {
        bucketName: string;
        endpoint: string;
        phase: 'Available' | 'Pending';
    };
}
export interface ClusterModule extends KubernetesResource {
    spec?: {
        version?: string;
    };
}
export interface BucketAccessClass extends KubernetesResource {
    policyActionsConfigMap: {
        namespace: string;
        name: string;
    };
}
export interface BucketAccessRequest extends KubernetesResource {
    apiVersion: 'objectstorage.k8s.io/v1alpha1';
    kind: 'BucketAccessRequest';
    spec: {
        bucketAccessClassName: string;
        bucketRequestName: string;
    };
    status: {
        accessGranted: boolean;
    };
}
export interface GatewayClassStatus {
    conditions?: Condition[];
}
export interface GatewayClass extends KubernetesResource {
    spec: {
        controllerName: string;
        parametersRef?: {
            group: string;
            kind: string;
            name: string;
            namespace: string;
        };
    };
    status?: GatewayClassStatus;
}
export type GatewayListenerProtocol = 'HTTP' | 'HTTPS' | 'TCP' | 'UDP';
export interface GatewayListener {
    allowedRoutes: {
        namespaces: {
            from: string;
        };
    };
    hostname?: string;
    name: string;
    port: number;
    protocol: GatewayListenerProtocol;
    tls?: {
        mode: 'Terminate';
        certificateRefs: Array<{
            kind: 'Secret';
            name: string;
            namespace: string;
        }>;
    };
}
export interface GatewayStatusAddress {
    type: 'Hostname' | 'IPAddress';
    value: string;
}
export interface GatewayStatusListener {
    name: string;
    attachedRoutes: number;
}
export interface GatewayStatus {
    addresses: GatewayStatusAddress[];
    conditions?: Condition[];
    listeners?: GatewayStatusListener[];
}
export interface Gateway extends KubernetesResource {
    spec: {
        gatewayClassName: string;
        listeners?: GatewayListener[];
    };
    status?: GatewayStatus;
}
export interface GatewayPathMatch {
    type: 'Exact' | 'PathPrefix' | 'RegularExpression';
    value: string;
}
export interface GatewayNameValueMatch {
    type: 'Exact' | 'RegularExpression';
    name: string;
    value: string;
}
export type GatewayMethod = 'CONNECT' | 'DELETE' | 'GET' | 'HEAD' | 'OPTIONS' | 'PATCH' | 'POST' | 'PUT' | 'TRACE';
export interface GatewayRouteRuleMatch {
    path?: GatewayPathMatch;
    headers?: GatewayNameValueMatch[];
    queryParams?: GatewayNameValueMatch[];
    method?: GatewayMethod;
}
export interface GatewayRouteRuleBackendRef {
    kind: 'Service';
    name: string;
    namespace: string;
    port: number;
    weight: number;
}
export interface GatewayHeader {
    name: string;
    value: string;
}
export interface GatewayRequestHeaderFilter {
    set?: GatewayHeader[];
    add?: GatewayHeader[];
    remove?: string[];
}
export interface GatewayPathModifier {
    type: 'ReplaceFullPath' | 'ReplacePrefixMatch';
    replaceFullPath?: string;
    replacePrefixMatch?: string;
}
export interface GatewayRequestRedirectFilter {
    scheme?: 'http' | 'https';
    hostname?: string;
    path?: GatewayPathModifier;
    port?: number;
    statusCode?: 301 | 302;
}
export interface GatewayURLRewriteFilter {
    hostname?: string;
    path?: GatewayPathModifier;
}
export interface GatewayRouteRuleFilter {
    type: 'RequestHeaderModifier' | 'RequestRedirect' | 'URLRewrite';
    requestHeaderModifier?: GatewayRequestHeaderFilter;
    requestRedirect?: GatewayRequestRedirectFilter;
    urlRewrite?: GatewayURLRewriteFilter;
}
export interface GatewayRouteRule {
    matches?: GatewayRouteRuleMatch[];
    filters?: GatewayRouteRuleFilter[];
    backendRefs: GatewayRouteRuleBackendRef[];
}
export interface GatewayRouteParentRef {
    kind: 'Gateway';
    namespace: string;
    name: string;
    sectionName: string;
}
export interface GatewayRoute extends KubernetesResource {
    spec: {
        hostnames: [string];
        parentRefs: [GatewayRouteParentRef];
        rules: [GatewayRouteRule];
    };
}
export interface GitSource {
    url: string;
    secret: string;
    revision: string;
}
export interface BuildSource {
    type: string;
    git: GitSource;
    contextDir: string;
}
export interface BuildTask {
    name: string;
    kind: string;
}
export interface ParamValue {
    name: string;
    value: string;
}
export interface BuildOutput {
    insecure?: boolean;
    image: string;
    pushSecret: string;
    annotations?: Record<string, string>;
    labels?: Record<string, string>;
}
export interface BuildCondition {
    lastTransitionTime: string;
    message: string;
    reason: string;
    status: string;
    type: string;
}
export interface AppBuildSpec {
    source: BuildSource;
    task: BuildTask;
    paramValues: ParamValue[];
    output: BuildOutput;
    timeout?: string;
}
export interface AppBuildStatus {
    ready: boolean;
    conditions: BuildCondition[];
}
export interface AppBuild extends KubernetesResource {
    spec: AppBuildSpec;
    status?: AppBuildStatus;
}
export interface AppBuildRunSpec {
    build: {
        name: string;
    };
    output: {
        image: string;
        pushSecret: string;
        annotations: Record<string, string>;
        labels: Record<string, string>;
    };
    paramValues: Array<{
        name: string;
        value: string;
    }>;
    state: string;
    timeout: string;
}
export interface AppBuildRunStatus {
    buildSpec: {
        output: {
            image: string;
        };
        source: {
            contextDir: string;
        };
        task: {
            name: string;
            kind: string;
        };
    };
    completedAt: string;
    taskRunName: string;
    conditions: Array<{
        lastTransitionTime: string;
        message: string;
        reason: string;
        status: string;
        type: string;
    }>;
    output: {
        digest: string;
        size: number;
    };
    startedAt: string;
}
export interface AppBuildRun extends KubernetesResource {
    spec: AppBuildRunSpec;
    status: AppBuildRunStatus;
}
export interface Application extends KubernetesResource {
    spec?: ApplicationSpec;
    status?: ApplicationStatus;
}
export interface ApplicationStatus {
    state: ApplicationStateEnum;
    totalComponents: number;
    conditions?: Condition[];
    workloadsStatus?: {
        pending?: number;
        ready?: number;
        stopped?: number;
        workloads?: WorkloadStatus[];
    };
}
export interface ApplicationSpec {
    componentKinds: GroupKind[];
    assemblyPhase?: ApplicationPhaseEnum;
    selector?: LabelSelector;
    descriptor?: any;
}
export interface GroupKind {
    kind: string;
    group: string;
}
export declare enum ApplicationStateEnum {
    Pending = "Pending",
    PartialRunning = "PartialRunning",
    Running = "Running",
    Stopped = "Stopped",
    Empty = "Empty"
}
export declare enum ApplicationPhaseEnum {
    Succeeded = "Succeeded",
    Failed = "Failed",
    Pending = "Pending"
}
export interface PodAutoscaler extends KubernetesResource {
    spec: {
        hpa?: HorizontalPodAutoscaler;
        cronHpa?: CronHorizontalPodAutoscaler;
        vpa?: VerticalPodAutoscaler;
    };
}
export interface HpaSpecBehaviorPolicy {
    type: 'Pods' | 'Percent';
    value: number;
    periodSeconds: number;
}
export interface HpaSpecBehavior {
    scaleDown: {
        stabilizationWindowSeconds: number;
        policies: HpaSpecBehaviorPolicy[];
    };
    scaleUp: {
        stabilizationWindowSeconds: number;
        policies: HpaSpecBehaviorPolicy[];
    };
}
export interface HorizontalPodAutoscalerSpec {
    maxReplicas?: number;
    minReplicas?: number;
    targetCPUUtilizationPercentage?: string;
    scaleTargetRef?: CrossVersionObjectReference;
    metrics?: HpaSpecMetric[];
    behavior?: HpaSpecBehavior;
}
export interface HorizontalPodAutoscaler extends KubernetesResource {
    spec: HorizontalPodAutoscalerSpec;
    status?: any;
}
export interface VerticalPodAutoscaler extends KubernetesResource {
    spec: VerticalPodAutoscalerSpec;
    status?: {
        recommendation?: VerticalPodAutoscalerRecommendation;
    };
}
export interface CronHorizontalPodAutoscaler extends KubernetesResource {
    spec: CronHorizontalPodAutoscalerSpec;
}
export declare enum VpaScalingMode {
    Manually = "Off",
    Dynamic = "Auto"
}
export interface VerticalPodAutoscalerSpec {
    targetRef: {
        apiVersion: string;
        kind: string;
        name: string;
    };
    updatePolicy: {
        updateMode: VpaScalingMode;
    };
    resourcePolicy: {
        containerPolicies: VerticalPodAutoscalerContainerPolice[];
    };
}
export interface VerticalPodAutoscalerContainerPolice {
    containerName: string;
    mode: string;
}
export interface VpaContainerRecommendation {
    containerName: string;
    lowerBound: {
        cpu: string;
        memory: string;
    };
    target: {
        cpu: string;
        memory: string;
    };
    uncappedTarget: {
        cpu: string;
        memory: string;
    };
    upperBound: {
        cpu: string;
        memory: string;
    };
}
export interface HpaSpecMetric {
    external?: ExternalMetricSource;
    object?: ObjectMetricSource;
    resource?: ResourceMetricSource;
    pods?: PodsMetricSource;
    type: string;
}
export interface ExternalMetricSource {
    metric?: MetricIdentifier;
    target?: MetricTarget;
}
export interface ObjectMetricSource {
    describedObject?: CrossVersionObjectReference;
    metric?: MetricIdentifier;
    target?: MetricTarget;
}
export interface PodsMetricSource {
    metric?: MetricIdentifier;
    target?: MetricTarget;
}
export interface ResourceMetricSource {
    name: string;
    target?: MetricTarget;
}
export interface MetricIdentifier {
    name: string;
    selector?: LabelSelector;
}
export interface MetricTarget {
    averageUtilization?: number;
    averageValue?: string;
    type: string;
    value?: string;
}
export interface VerticalPodAutoscalerRecommendation {
    containerRecommendations: VpaContainerRecommendation[];
}
export interface CronHorizontalPodAutoscalerSpec {
    crons: CronHorizontalPodAutoScalerRule[];
    scaleTargetRef?: CrossVersionObjectReference;
}
export interface CrossVersionObjectReference {
    apiVersion: string;
    kind: string;
    name: string;
}
export interface CronHorizontalPodAutoScalerRule {
    schedule: string;
    targetReplicas: number;
}
export interface HpaConfigResource {
    hpa?: HorizontalPodAutoscaler;
    cronHpa?: CronHorizontalPodAutoscaler;
    vpa?: VerticalPodAutoscaler;
}
export interface ChartRepo extends KubernetesResource {
    spec: ChartRepoSpec;
    status?: ChartRepoStatus;
}
export declare enum ChartRepoType {
    Chart = "Chart",
    Git = "Git",
    OCIChart = "OCI Chart"
}
export interface ChartRepoSpec {
    secret?: {
        name: string;
    };
    url: string;
    type?: ChartRepoType;
    source?: {
        url: string;
        path: string;
    };
}
export interface ChartRepoStatus {
    phase: ChartRepoPhaseEnum;
}
export declare enum ChartRepoPhaseEnum {
    Synced = "Synced",
    Failed = "Failed",
    Pending = "Pending"
}
export interface GitCommitSpec {
    project: string;
    repo: string;
    path: string;
    sourceRevision?: {
        [key in 'branch' | 'tag' | 'commit']: {
            name: string;
        };
    };
    branch: string;
    integration: string;
    message: string;
    createPullRequest: boolean;
    removeSourceBranch: boolean;
}
export interface GitCommit {
    spec: GitCommitSpec;
}
export interface EphemeralContainers extends KubernetesResource {
    ephemeralContainers: EphemeralContainerSpec[];
}
export interface EphemeralContainerSpec {
    command: string[];
    image: string;
    imagePullPolicy: string;
    name: string;
    stdin: boolean;
    tty: boolean;
    terminationMessagePolicy?: string;
    [key: string]: unknown;
}
export interface NamespaceOverviewAppStats {
    total: number;
    running: number;
    partialRunning: number;
    pending: number;
    failed: number;
    empty: number;
    stopped: number;
}
export interface WorkloadStats {
    ready: number;
    pending: number;
    stopped: number;
}
export interface ResourceQuotaItem {
    cpu?: string;
    memory?: string;
    pods?: string;
    'limits.cpu'?: string;
    'requests.cpu'?: string;
    'limits.memory'?: string;
    'requests.memory'?: string;
    'requests.storage'?: string;
    persistentvolumeclaims?: string;
}
export interface NamespaceOverviewResourceQuota {
    parent?: ResourceQuotaItem;
    hard?: ResourceQuotaItem;
    used?: ResourceQuotaItem;
}
export interface NamespaceOverview extends KubernetesResource {
    kind: 'NamespaceOverview';
    spec: NamespaceOverviewSpec;
}
export interface PodError {
    name: string;
    status: string;
    reason: string;
}
export interface ResourceQuota extends KubernetesResource {
    spec?: ResourceQuotaSpec;
}
export interface ResourceQuotaSpec {
    hard?: ResourceQuotaItem;
    scopes?: ResourceQuotaScope[];
}
export type ResourceQuotaScope = 'Terminating' | 'NotTerminating' | 'BestEffort' | 'NotBestEffort';
export interface NamespaceOverviewSpec {
    application: NamespaceOverviewAppStats;
    resourceQuota: NamespaceOverviewResourceQuota;
    workload: {
        deployment: WorkloadStats;
        daemonset: WorkloadStats;
        statefulset: WorkloadStats;
    };
    pod: {
        stats: {
            running: number;
            pending: number;
            error: number;
            succeeded: number;
            evicted: number;
        };
        errors: PodError[];
    };
}
export interface ArgoCdApplicationSet extends KubernetesResource {
    kind: GITOPS_APP_TYPES.ApplicationSet;
    spec: ArgoCdApplicationSetSpec;
    status?: {
        conditions: ArgoCdApplicationCondition[];
        applicationStatus: ArgoCdApplicationStatus[];
    };
}
export interface ArgoCdApplicationStatus {
    application: string;
    message: string;
    status: string;
    step: string;
}
export interface ArgoCdApplicationCondition {
    message: string;
    reason: string;
    status: 'True' | 'False';
    type: string;
}
export interface ArgoCdApplicationSetSpec {
    generators: ArgoCdApplicationSetSpecGenerator[];
    template: ArgoCdApplicationSpecTemplate;
}
export interface GitOpsIgnoreDifferenceConfig {
    group: string;
    kind: string;
    jsonPointers: string[];
}
export interface ArgoCdApplicationSpecTemplate {
    metadata: {
        name?: string;
        labels: StringMap;
    };
    spec: {
        project: string;
        source: {
            repoURL: string;
            targetRevision: string;
            path?: string;
            directory?: {
                recurse: boolean;
            };
        };
        destination?: {
            name: string;
            namespace: string;
        };
        ignoreDifferences?: GitOpsIgnoreDifferenceConfig[];
        helm?: {
            valueFiles: [string];
        };
        syncPolicy: {
            automated: unknown;
            syncOptions?: string[];
        };
    };
}
export interface ArgoCdApplicationSetSpecGenerator {
    merge?: {
        mergeKeys: string[];
        generators: [
            ArgoCdApplicationSetSpecMergeGeneratorBase,
            ArgoCdApplicationSetSpecMergeGeneratorExtend
        ];
    };
    list?: {
        elements: Array<{
            values: ArgoCdApplicationValues;
        }>;
    };
    clusters?: {
        selector: Selector;
        values?: StringMap;
    };
}
export interface ArgoCdApplicationSetSpecMergeGeneratorBase {
    list: {
        elements: Array<{
            values: {
                key: string;
                path: string;
            };
        }>;
    };
}
export interface ArgoCdApplicationSetSpecMergeGeneratorExtend {
    list: {
        elements: Array<{
            values: ArgoCdApplicationValues;
        }>;
    };
}
export interface ArgoCdApplicationValues {
    key?: string;
    cluster: string;
    namespace: string;
    nameSuffix?: string;
    path?: string;
    valueFile?: string;
}
export interface ArgoCdApplicationValuesModel {
    key?: string;
    cluster: string;
    namespaces: string[];
    nameSuffix?: string;
    path?: string;
    valueFile?: string;
}
export interface ArgoCdApplicationOperationState {
    phase: ArgoCdApplicationOperationStatePhase;
    operation?: {
        sync?: {
            resources?: ArgoCdApplicationResource[];
        };
    };
    message: string;
    startedAt: string;
    finishedAt: string;
    syncResult: {
        revision: string;
        source: ArgoCdApplicationSource;
        resources: ArgoCdApplicationSyncResource[];
    };
}
export interface ArgoCdApplicationSource {
    repoURL: string;
    targetRevision: string;
    path: string;
    kustomize?: unknown;
}
export interface ArgoCdApplicationHistory {
    deployStartedAt: string;
    deployedAt: string;
    id: string;
    revision: string;
    source: ArgoCdApplicationSource;
}
export declare enum GITOPS_APP_TYPES {
    Application = "Application",
    ApplicationSet = "ApplicationSet"
}
export interface ArgoCdApplication extends KubernetesResource {
    kind: GITOPS_APP_TYPES.Application;
    status?: {
        resources: ArgoCdApplicationResource[];
        sync: {
            status: GitopsResourceSyncStatus;
        };
        operationState: ArgoCdApplicationOperationState;
        health: {
            status: GitopsResourceHealthStatus;
        };
        conditions: ArgoCdApplicationCondition[];
        history?: ArgoCdApplicationHistory[];
    };
    operation?: {
        initiatedBy: {
            username: string;
        };
        retry: {
            limit: number;
        };
        sync: {
            prune: boolean;
            syncOptions: string[];
        };
    };
    spec: {
        project: string;
        source: ArgoCdApplicationSource;
        destination: {
            namespace: string;
            name?: string;
        };
        syncPolicy?: {
            automated: unknown;
            syncOptions?: string[];
        };
    };
}
export interface ArgoCdApplicationBaseResource {
    kind: string;
    name: string;
    namespace: string;
    status?: GitopsResourceSyncStatus;
    version: string;
    group: string;
}
export declare enum ArgoCdApplicationHealthStatus {
    Progressing = "Progressing",// 正在部署
    Missing = "Missing",// 资源丢失
    Healthy = "Healthy",// 健康，表示应用正常运行
    Suspended = "Suspended",// 暂停，表示有任务被暂停，指CronJob资源
    Degraded = "Degraded",// 降级，表示有些资源不健康
    Unknown = "Unknown"
}
export interface ArgoCdApplicationResource extends ArgoCdApplicationBaseResource {
    health: {
        status: ArgoCdApplicationHealthStatus;
    };
}
export interface ArgoCdApplicationSyncResource extends ArgoCdApplicationBaseResource {
    hookPhase: ArgoCdApplicationOperationStatePhase;
    message: string;
}
export declare enum ArgoCdApplicationOperationStatePhase {
    Error = "Error",
    Running = "Running",
    Failed = "Failed",
    Terminating = "Terminating",
    Succeeded = "Succeeded"
}
export declare enum GitopsResourceSyncStatus {
    Synced = "Synced",// 表示已同步
    OutOfSync = "OutOfSync",// 表示不一致
    Failed = "Failed",// 表示不一致
    Syncing = "Syncing",// 表示不一致
    Unknown = "Unknown"
}
export declare enum GitopsResourceHealthStatus {
    Progressing = "Progressing",// 正在部署
    Missing = "Missing",// 资源丢失
    Healthy = "Healthy",// 健康，表示应用正常运行
    Suspended = "Suspended",// 暂停，表示有任务被暂停，指CronJob资源
    Degraded = "Degraded",// 降级，表示有些资源不健康
    Unknown = "Unknown"
}
export interface RepoFilePathFlatTree {
    mode?: string;
    name: string;
    path: string;
    sha?: string;
    type: 'blob' | 'tree';
}
export interface RepoFilePath extends KubernetesResource {
    spec: {
        tree: RepoFilePathFlatTree[];
    };
}
export interface AppCustomMonitorIndicator {
    type: string;
    indicator: string;
    resources?: [];
    expr: string;
    displayName: string;
    unit: string;
    legend: string;
}
export interface AppCustomMonitorIndicatorsSpec {
    panels: Array<{
        targets: AppCustomMonitorIndicator[];
    }>;
}