/// <reference types="react" />
import * as React$1 from 'react';
import * as react_jsx_runtime from 'react/jsx-runtime';

declare enum DataType {
    PipelineRun = "tekton.dev/v1beta1.PipelineRun",
    TaskRun = "tekton.dev/v1beta1.TaskRun",
    Log = "results.tekton.dev/v1alpha2.Log"
}
declare type MatchExpression$1 = {
    key: string;
    operator: Operator | string;
    values?: string[];
};
declare type MatchLabels$1 = {
    [key: string]: string;
};
declare type Selector$1 = {
    matchLabels?: MatchLabels$1;
    matchExpressions?: MatchExpression$1[];
};
type ResultRecord = {
    name: string;
    uid: string;
    createTime: string;
    updateTime: string;
    etag: string;
    data: {
        type: string;
        value: string;
    };
};
type RecordsList = {
    nextPageToken?: string;
    records: ResultRecord[];
};
type TektonResultsOptions = {
    pageSize?: number;
    selector?: Selector$1;
    limit?: number;
    filter?: string;
    summary?: string;
    data_type?: DataType;
    groupBy?: string;
};
type ProxyRequest = {
    allowInsecure?: boolean;
    method: string;
    url: string;
    headers?: Record<string, string[]>;
    queryparams?: Record<string, string[]>;
    body?: string;
};
type GetNextPage = () => void | undefined;

type K8sResourceIdentifier = {
    apiGroup?: string;
    apiVersion: string;
    kind: string;
};
type OwnerReference = {
    apiVersion: string;
    kind: string;
    name: string;
    uid: string;
    controller?: boolean;
    blockOwnerDeletion?: boolean;
};
declare enum Operator {
    Exists = "Exists",
    DoesNotExist = "DoesNotExist",
    In = "In",
    NotIn = "NotIn",
    Equals = "Equals",
    NotEqual = "NotEqual",
    GreaterThan = "GreaterThan",
    LessThan = "LessThan",
    NotEquals = "NotEquals"
}
type MatchLabels = {
    [key: string]: string;
};
type Selector = Partial<{
    matchLabels: MatchLabels;
    matchExpressions: MatchExpression[];
    [key: string]: unknown;
}>;
type MatchExpression = {
    key: string;
    operator: Operator | string;
    values?: string[];
    value?: string;
};
type ObjectMetadata = {
    annotations?: {
        [key: string]: string;
    };
    clusterName?: string;
    creationTimestamp?: string;
    deletionGracePeriodSeconds?: number;
    deletionTimestamp?: string;
    finalizers?: string[];
    generateName?: string;
    generation?: number;
    labels?: {
        [key: string]: string;
    };
    managedFields?: any[];
    name?: string;
    namespace?: string;
    ownerReferences?: object[];
    resourceVersion?: string;
    uid?: string;
};
type K8sResourceCommon = K8sResourceIdentifier & Partial<{
    metadata: Partial<{
        annotations: Record<string, string>;
        clusterName: string;
        creationTimestamp: string | Date;
        deletionGracePeriodSeconds: number;
        deletionTimestamp: string;
        finalizers: string[];
        generateName: string;
        generation: number;
        labels: Record<string, string>;
        managedFields: unknown[];
        name: string;
        namespace: string;
        ownerReferences: OwnerReference[];
        resourceVersion: string;
        uid: string;
    }>;
    spec: {
        selector?: Selector | MatchLabels;
        [key: string]: unknown;
    };
    status: {
        [key: string]: unknown;
    };
    data: {
        [key: string]: unknown;
    };
}>;
declare type K8sModelCommon = K8sResourceIdentifier & {
    plural: string;
    propagationPolicy?: 'Foreground' | 'Background';
    verbs?: K8sVerb[];
    shortNames?: string[];
    crd?: boolean;
    namespaced?: boolean;
};
type K8sGroupVersionKind = {
    group?: string;
    version: string;
    kind: string;
};
type K8sVerb = 'create' | 'get' | 'list' | 'update' | 'patch' | 'delete' | 'deletecollection' | 'watch' | 'impersonate';
declare enum BadgeType {
    DEV = "Dev Preview",
    TECH = "Tech Preview"
}
type K8sModel = K8sModelCommon & {
    abbr: string;
    kind: string;
    label: string;
    labelKey?: string;
    labelPlural: string;
    labelPluralKey?: string;
    plural: string;
    propagationPolicy?: 'Foreground' | 'Background';
    id?: string;
    crd?: boolean;
    apiVersion: string;
    apiGroup?: string;
    namespaced?: boolean;
    selector?: Selector;
    labels?: {
        [key: string]: string;
    };
    annotations?: {
        [key: string]: string;
    };
    verbs?: K8sVerb[];
    shortNames?: string[];
    badge?: BadgeType;
    color?: string;
    legacyPluralURL?: boolean;
};
type QueryParams = {
    watch?: string;
    labelSelector?: string;
    fieldSelector?: string;
    resourceVersion?: string;
    [key: string]: string | undefined;
};
type WatchK8sResult<R extends K8sResourceCommon | K8sResourceCommon[]> = [R, boolean, any];
type UseK8sWatchResource = <R extends K8sResourceCommon | K8sResourceCommon[]>(initResource: WatchK8sResource | null) => WatchK8sResult<R>;
declare type BaseOptions = {
    name?: string;
    ns?: string;
    path?: string;
    queryParams?: QueryParams;
};
declare type OptionsGet = BaseOptions & {
    model: K8sModel;
    requestInit?: RequestInit;
};
type commonFetchJSON = {
    <TResult>(url: string, requestInit?: RequestInit | undefined, timeout?: number | undefined, isK8sAPIRequest?: boolean | undefined): Promise<TResult>;
    put<TResult_1>(url: string, data: unknown, requestInit?: RequestInit | undefined, timeout?: number | undefined, isK8sAPIRequest?: boolean | undefined): Promise<TResult_1>;
    post<TResult_2>(url: string, data: unknown, requestInit?: RequestInit | undefined, timeout?: number | undefined, isK8sAPIRequest?: boolean | undefined): Promise<TResult_2>;
    patch<TResult_3>(url: string, data: unknown, requestInit?: RequestInit | undefined, timeout?: number | undefined, isK8sAPIRequest?: boolean | undefined): Promise<TResult_3>;
    delete<TResult_4>(url: string, data?: unknown, requestInit?: RequestInit | undefined, timeout?: number | undefined, isK8sAPIRequest?: boolean | undefined): Promise<TResult_4>;
};
type commonFetchText = (url: string, requestInit?: RequestInit | undefined, timeout?: number | undefined, isK8sAPIRequest?: boolean | undefined) => Promise<string>;
type K8sGetResource = <R extends K8sResourceCommon>(options: OptionsGet) => Promise<R>;
type FetchUtilsType = {
    hooks: {
        useK8sWatchResource: UseK8sWatchResource;
        k8sGet?: K8sGetResource;
    };
    resourceFetchers: {
        commonFetchText: commonFetchText;
        commonFetchJson: commonFetchJSON;
        consoleProxyFetchJSON?: ConsoleProxyFetchJSON;
        consoleProxyFetchLog?: ConsoleProxyFetchJSON;
    };
};
type TektonConfiguration = {
    fetchUtils: FetchUtilsType;
    tektonResultsBaseURL: string;
    isTektonResultEnabled: boolean;
};
declare type Never<T> = {
    [K in keyof T]?: never;
};
declare type EitherNotBoth<TypeA, TypeB> = (TypeA & Never<TypeB>) | (TypeB & Never<TypeA>);
declare type K8sResourceKindReference = string;
declare type WatchK8sResource = EitherNotBoth<{
    kind: K8sResourceKindReference;
}, {
    groupVersionKind: K8sGroupVersionKind;
}> & {
    name?: string;
    namespace?: string;
    isList?: boolean;
    selector?: Selector;
    namespaced?: boolean;
    limit?: number;
    fieldSelector?: string;
    optional?: boolean;
    partialMetadata?: boolean;
};
type ConsoleProxyFetchJSON = <T>(proxyRequest: ProxyRequest) => Promise<T>;

type ResourceTarget = 'inputs' | 'outputs';
type TektonParam = {
    default?: string | string[];
    description?: string;
    name: string;
    type?: 'string' | 'array';
};
type TektonTaskSteps = {
    name: string;
    args?: string[];
    command?: string[];
    image?: string;
    computeResources?: {}[] | {};
    resources?: never[] | never;
    env?: {
        name: string;
        value: string;
    }[];
    script?: string | string[];
    workingDir?: string;
    volumeMounts?: {
        name: string;
        mountPath: string;
    }[];
};
type TektonTaskStepsV1Beta1 = {
    name: string;
    args?: string[];
    command?: string[];
    image?: string;
    resources?: {}[] | {};
    env?: {
        name: string;
        value: string;
    }[];
    script?: string | string[];
};
type TaskResult = {
    name: string;
    type?: string;
    value?: string;
    description?: string;
};
type TektonTaskSpec = {
    metadata?: {};
    description?: string;
    steps: TektonTaskSteps[];
    params?: TektonParam[];
    resources?: TektonResourceGroup<TektonResource>;
    results?: TaskResult[];
    volumes?: {};
    workspaces?: TektonWorkspace[];
};
type TektonResourceGroup<ResourceType> = {
    inputs?: ResourceType[];
    outputs?: ResourceType[];
};
/**
 * @deprecated
 */
type TektonTaskSpecV1Beta1 = {
    metadata?: {};
    description?: string;
    steps: TektonTaskStepsV1Beta1[];
    params?: TektonParam[];
    resources?: TektonResourceGroup<TektonResource>;
    results?: TaskResult[];
    volumes?: {};
    workspaces?: TektonWorkspace[];
};
/**
 * @deprecated - upstream Workspaces are replacing Resources
 */
type TektonResource = {
    name: string;
    optional?: boolean;
    type: string;
};
type TektonWorkspace = {
    name: string;
    description?: string;
    mountPath?: string;
    readOnly?: boolean;
    optional?: boolean;
};
type TektonResultsRun = {
    name: string;
    value: string;
    type?: string;
};
interface Addon {
    enablePipelinesAsCode: boolean;
    params: Param[];
}
interface Param {
    name: string;
    value: string;
}
interface Dashboard {
    readonly: boolean;
}
declare enum MetricsLevel {
    METRICS_PIPELINERUN_DURATION_TYPE = "metrics.pipelinerun.duration-type",
    METRICS_PIPELINERUN_LEVEL = "metrics.pipelinerun.level",
    METRICS_TASKRUN_DURATION_TYPE = "metrics.taskrun.duration-type",
    METRICS_TASKRUN_LEVEL = "metrics.taskrun.level"
}
declare enum LevelTypes {
    PIPELINE = "pipeline",
    PIPELINERUN = "pipelinerun",
    TASK = "task",
    TASKRUN = "taskrun"
}
declare enum DurationTypes {
    HISTOGRAM = "histogram",
    LASTVALUE = "lastvalue",
    NAMESPACE = "namespace"
}
interface Pipeline {
    'default-service-account': string;
    'disable-affinity-assistant': boolean;
    'disable-creds-init': boolean;
    'enable-api-fields': string;
    'enable-custom-tasks': boolean;
    'enable-tekton-oci-bundles': boolean;
    [MetricsLevel.METRICS_PIPELINERUN_DURATION_TYPE]: DurationTypes;
    [MetricsLevel.METRICS_PIPELINERUN_LEVEL]: LevelTypes;
    [MetricsLevel.METRICS_TASKRUN_DURATION_TYPE]: DurationTypes;
    [MetricsLevel.METRICS_TASKRUN_LEVEL]: LevelTypes;
    params: Param[];
    'require-git-ssh-secret-known-hosts': boolean;
    'running-in-environment-with-injected-sidecars': boolean;
    'scope-when-expressions-to-task': boolean;
}
interface Pruner {
    keep: number;
    resources: string[];
    schedule: string;
}
interface Trigger {
    'default-service-account': string;
    'enable-api-fields': string;
}
interface Spec {
    addon: Addon;
    config: {};
    dashboard: Dashboard;
    hub: {};
    params: Param[];
    pipeline: Pipeline;
    profile: string;
    pruner: Pruner;
    targetNamespace: string;
    trigger: Trigger;
}
interface Status {
    conditions: TektonConfigCondition[];
}
interface TektonConfigCondition {
    lastTransitionTime: string;
    status: string;
    type: string;
}
type TektonConfig = K8sResourceCommon & {
    spec: Spec;
    status: Status;
};
declare enum TektonResourceLabel {
    pipeline = "tekton.dev/pipeline",
    pipelinerun = "tekton.dev/pipelineRun",
    taskrun = "tekton.dev/taskRun",
    task = "tekton.dev/task",
    pipelineTask = "tekton.dev/pipelineTask"
}

type TaskKind = K8sResourceCommon & {
    spec: TektonTaskSpec;
};

type TaskRunWorkspace = {
    name: string;
    volumeClaimTemplate?: any;
    persistentVolumeClaim?: VolumeTypePVC;
    configMap?: VolumeTypeConfigMaps;
    emptyDir?: {};
    secret?: VolumeTypeSecret;
    subPath?: string;
};
type TaskRunStatus = {
    completionTime?: string;
    conditions?: Condition[];
    podName?: string;
    startTime?: string;
    steps?: PLRTaskRunStep[];
    results?: TektonResultsRun[];
    taskResults?: TektonResultsRun[];
    taskSpec?: TaskKind['spec'];
};
type TaskRunKind = K8sResourceCommon & {
    spec: {
        taskRef?: PipelineTaskRef;
        taskSpec?: TektonTaskSpec;
        serviceAccountName?: string;
        params?: PipelineTaskParam[];
        timeout?: string;
        workspaces?: TaskRunWorkspace[];
    };
    status?: TaskRunStatus;
};

type PipelineTaskRef = {
    resolver?: string;
    kind?: string;
    name?: string;
    params?: {
        name: string;
        value: string;
    }[];
};
type PipelineTaskWorkspace = {
    name: string;
    workspace: string;
    optional?: boolean;
};
type PipelineTaskResource = {
    name: string;
    resource?: string;
    from?: string[];
};
type PipelineTaskParam = {
    name: string;
    value: any;
};
type WhenExpression = {
    input: string;
    operator: string;
    values: string[];
};
type PipelineResult = {
    name: string;
    value: string;
    description?: string;
};
type PipelineTask = {
    name: string;
    params?: PipelineTaskParam[];
    resources?: TektonResourceGroup<PipelineTaskResource>;
    runAfter?: string[];
    taskRef?: PipelineTaskRef;
    taskSpec?: TektonTaskSpec;
    when?: WhenExpression[];
    workspaces?: PipelineTaskWorkspace[];
    status?: TaskRunStatus;
};
type PipelineSpec = {
    params?: TektonParam[];
    serviceAccountName?: string;
    tasks: PipelineTask[];
    workspaces?: TektonWorkspace[];
    finally?: PipelineTask[];
    results?: PipelineResult[];
};
type PipelineKind = K8sResourceCommon & {
    spec: PipelineSpec;
};

type PLRTaskRunStep = {
    container: string;
    imageID?: string;
    name: string;
    waiting?: {
        reason: string;
    };
    running?: {
        startedAt: string;
    };
    terminated?: {
        containerID: string;
        exitCode: number;
        finishedAt: string;
        reason: string;
        startedAt: string;
        message?: string;
    };
};
type PLRTaskRunData = {
    pipelineTaskName: string;
    status: TaskRunStatus;
};
type PLRTaskRuns = {
    [taskRunName: string]: PLRTaskRunData;
};
type VolumeTypeSecret = {
    secretName: string;
    items?: {
        key: string;
        path: string;
    }[];
};
type VolumeTypeConfigMaps = {
    name: string;
    items?: {
        key: string;
        path: string;
    }[];
};
type VolumeTypePVC = {
    claimName: string;
};
type PersistentVolumeClaimType = {
    persistentVolumeClaim: VolumeTypePVC;
};
type VolumeClaimTemplateType = {
    volumeClaimTemplate: VolumeTypeClaim;
};
type VolumeTypeClaim = {
    metadata?: ObjectMetadata;
    spec: {
        accessModes: string[];
        resources: {
            requests: {
                storage: string;
            };
        };
        storageClassName?: string;
        volumeMode?: string;
    };
};
type Condition = {
    type: string;
    status: string;
    reason?: string;
    message?: string;
    binding?: string;
    lastTransitionTime?: string;
};
type PipelineRunEmbeddedResourceParam = {
    name: string;
    value: string;
};
type PipelineRunEmbeddedResource = {
    name: string;
    resourceSpec: {
        params: PipelineRunEmbeddedResourceParam[];
        type: string;
    };
};
type PipelineRunReferenceResource = {
    name: string;
    resourceRef: {
        name: string;
    };
};
type PipelineRunResource = PipelineRunReferenceResource | PipelineRunEmbeddedResource;
type PipelineRunWorkspace = {
    name: string;
    [volumeType: string]: VolumeTypeSecret | VolumeTypeConfigMaps | VolumeTypePVC | VolumeTypeClaim | {};
};
type PipelineRunParam = {
    name: string;
    value: string | string[];
    input?: string;
    output?: string;
    resource?: object;
};
type PipelineRunStatus = {
    succeededCondition?: string;
    creationTimestamp?: string;
    conditions?: Condition[];
    startTime?: string;
    completionTime?: string;
    taskRuns?: PLRTaskRuns;
    pipelineSpec: PipelineSpec;
    skippedTasks?: {
        name: string;
        reason?: string;
        whenExpressions?: WhenExpression[];
    }[];
    results?: TektonResultsRun[];
};
type PipelineRunKind = K8sResourceCommon & {
    spec: {
        pipelineRef?: {
            name: string;
            resolver?: string;
        };
        pipelineSpec?: PipelineSpec;
        params?: PipelineRunParam[];
        workspaces?: PipelineRunWorkspace[];
        taskRunTemplate?: {
            serviceAccountName?: string;
        };
        timeout?: {
            pipeline: string;
            tasks: string;
            finally: string;
        };
        status?: 'StoppedRunFinally' | 'CancelledRunFinally' | 'PipelineRunPending';
    };
    status?: PipelineRunStatus;
};
type PipelineWithLatest = PipelineKind & {
    latestRun?: PipelineRunKind;
};
declare enum ComputedStatus {
    All = "All",
    Cancelling = "Cancelling",
    Succeeded = "Succeeded",
    Failed = "Failed",
    Running = "Running",
    'In Progress' = "In Progress",
    FailedToStart = "FailedToStart",
    PipelineNotStarted = "PipelineNotStarted",
    Skipped = "Skipped",
    Cancelled = "Cancelled",
    Pending = "Pending",
    Idle = "Idle",
    Other = "Other"
}
declare enum TerminatedReasons {
    Completed = "Completed"
}
type StatusMessage = {
    message: string;
    color: string;
};
type TaskStatusTypes = {
    PipelineNotStarted: number;
    Pending: number;
    Running: number;
    Succeeded: number;
    Cancelled: number;
    Failed: number;
    Skipped: number;
};
type PipelineTaskWithStatus = PipelineTask & {
    status: {
        reason: string;
        completionTime?: string;
        conditions: Condition[];
        podName?: string;
        startTime?: string;
        steps?: PLRTaskRunStep[];
        taskSpec?: TektonTaskSpec;
        taskResults?: {
            name: string;
            value: string;
        }[];
        duration?: string;
    };
};

declare enum SucceedConditionReason {
    PipelineRunStopped = "StoppedRunFinally",
    PipelineRunCancelled = "CancelledRunFinally",
    TaskRunCancelled = "TaskRunCancelled",
    Cancelled = "Cancelled",
    PipelineRunStopping = "PipelineRunStopping",
    PipelineRunPending = "PipelineRunPending",
    TaskRunStopping = "TaskRunStopping",
    CreateContainerConfigError = "CreateContainerConfigError",
    ExceededNodeResources = "ExceededNodeResources",
    ExceededResourceQuota = "ExceededResourceQuota",
    ConditionCheckFailed = "ConditionCheckFailed"
}
declare enum RunStatus {
    Succeeded = "Succeeded",
    Failed = "Failed",
    Running = "Running",
    'In Progress' = "In Progress",
    FailedToStart = "FailedToStart",
    PipelineNotStarted = "Starting",
    WithoutStatusConditions = "WithoutStatusConditions",
    NeedsMerge = "PR needs merge",
    Skipped = "Skipped",
    Cancelled = "Cancelled",
    Cancelling = "Cancelling",
    Pending = "Pending",
    Idle = "Idle",
    TestWarning = "Test Warnings",
    TestFailed = "Test Failures",
    Unknown = "Unknown"
}
declare const conditionsRunStatus: (conditions: Condition[], specStatus?: string) => RunStatus;
declare const pipelineRunStatus: (pipelineRun: PipelineRunKind) => RunStatus;

interface ResultsListProps {
    results: {
        name: string;
        value: string;
    }[];
    pipelineRunName: string;
    pipelineRunStatus: RunStatus;
}
declare const ResultsList: React.FC<ResultsListProps>;

declare enum ENTERPRISE_CONTRACT_POLICY_STATUS {
    failed = "Failed",
    successes = "Success",
    warnings = "Warning"
}
type EnterpriseContractPolicy = {
    title: string;
    description: string;
    status: ENTERPRISE_CONTRACT_POLICY_STATUS;
    timestamp?: string;
    component?: string;
    msg?: string;
    collection?: string[];
    solution?: string;
};
type EnterpriseContractRule = {
    metadata?: {
        title: string;
        description: string;
        collections: string[];
        code: string;
        effective_on?: string;
        solution?: string;
    };
    msg: string;
};
type ComponentEnterpriseContractResult = {
    name: string;
    success: boolean;
    containerImage: string;
    violations?: EnterpriseContractRule[];
    successes?: EnterpriseContractRule[];
    warnings?: EnterpriseContractRule[];
    signatures?: {
        keyid: string;
        metadata: {
            predicateBuildType: string;
            predicateType: string;
            type: string;
        };
        sig: string;
    }[];
};
interface ECPolicy {
    description: string;
    publicKey: string;
    configuration: {
        collections: string[];
        exclude: string[];
    };
    sources: {
        data: string[];
        name: string;
        policy: string[];
    }[];
}
type EnterpriseContractResult = {
    components: ComponentEnterpriseContractResult[];
    key?: string;
    policy?: ECPolicy;
    success?: boolean;
    Error?: string;
};
declare const ACS_STATUS: {
    readonly Fixable: "Fixable";
    readonly Unavailable: "Unavailable";
};
declare const ACS_SCAN_RESULTS: {
    readonly Vulnerabilites: "Vulnerabilites";
    readonly Components: "Components";
};
declare const ACS_SEVERITY: {
    readonly Critical: "Critical";
    readonly Low: "Low";
    readonly Moderate: "Moderate";
    readonly Important: "Important";
};
declare const ACS_IMAGE_CHECK_SEVERITY: {
    readonly Critical: "Critical";
    readonly High: "High";
    readonly Medium: "Medium";
    readonly Low: "Low";
};
declare const ACS_BREAKING_CHANGES: {
    readonly Breaking: "Breaking";
    readonly NotBreaking: "NotBreaking";
};
interface ACSImageScanSummary {
    CRITICAL: number;
    IMPORTANT: number;
    LOW: number;
    MODERATE: number;
    'TOTAL-COMPONENTS': number;
    'TOTAL-VULNERABILITIES': number;
}
interface Vulnerability {
    cveId: string;
    cveSeverity: string;
    cveInfo: string;
    componentName: string;
    componentVersion: string;
    componentFixedVersion: string;
}
interface ACSImageScanResult {
    result: {
        summary: ACSImageScanSummary;
        vulnerabilities: Vulnerability[];
    };
}
interface Result {
    metadata: {
        id: string;
        additionalInfo: {
            namespace?: string;
            name: string;
            type: string;
        };
    };
    summary: ACSImageCheckSummary;
    violatedPolicies: ViolatedPolicy[];
}
interface ACSImageCheckSummary {
    CRITICAL: number;
    HIGH: number;
    LOW: number;
    MEDIUM: number;
    TOTAL: number;
}
interface ViolatedPolicy {
    name: string;
    severity: string;
    description: string;
    violation: string[];
    remediation: string;
    failingCheck: boolean;
}
interface ACSCheckResults {
    results: Result[];
    summary: ACSImageCheckSummary;
}
declare enum TaskRunResultsAnnotations {
    KEY = "task.results.key",
    TYPE = "task.results.type",
    LOCATION = "task.results.location",
    CONTAINER = "task.results.container",
    FORMAT = "task.results.format"
}
declare enum TaskRunResultsTypeValue {
    EC = "ec",
    EXTERNAL_LINK = "external-link",
    ROXCTL_IMAGE_SCAN = "roxctl-image-scan",
    ROXCTL_IMAGE_CHECK = "roxctl-image-check",
    ROXCTL_DEPLOYMENT_CHECK = "roxctl-deployment-check"
}
declare enum TaskRunResultsFormatValue {
    JSON = "application/json",
    YAML = "application/yaml",
    TEXT = "application/text"
}
declare enum TaskRunResultsLocationValue {
    LOGS = "logs",
    RESULTS = "results"
}
declare enum TaskRunResultsKeyValue {
    SBOM = "LINK_TO_SBOM",
    SCAN_OUTPUT = "SCAN_OUTPUT"
}
declare enum TaskType {
    sbom = "sbom",
    ec = "ec",
    acsImageScan = "acsImageScan",
    acsImageCheck = "acsImageCheck",
    acsDeploymentCheck = "acsDeploymentCheck"
}
type OutputGroup = {
    [key in TaskType]?: {
        taskRun: TaskRunKind | undefined;
        loading: boolean;
        data: string | object | any;
    };
} & {
    status: RunStatus;
    results: {
        loading: boolean;
        data: TektonResultsRun[] | [];
    };
};
type OutputTaskRunGroup = {
    [key in `${TaskType}TaskRun`]?: TaskRunKind;
};

type OutputProps = {
    enterpriseContractPolicies?: EnterpriseContractPolicy[];
    acsImageScanResult?: ACSImageScanResult;
    acsImageCheckResults?: ACSCheckResults;
    acsDeploymentCheckResults?: ACSCheckResults;
} & ResultsListProps;
/**
 * Output component supports EC, ACS policy reports and pipelinerun results.
 * @param OutputProps
 * @returns React.ReactNode
 */
declare const Output: React$1.FC<OutputProps>;

declare const mapEnterpriseContractResultData: (ecResult: EnterpriseContractResult) => EnterpriseContractPolicy[];

type AdvancedClusterSecurityProps = {
    acsImageScanResult: ACSImageScanResult;
    acsImageCheckResults: ACSCheckResults;
    acsDeploymentCheckResults: ACSCheckResults;
};
declare const AdvancedClusterSecurity: React$1.FC<AdvancedClusterSecurityProps>;
//# sourceMappingURL=AdvancedClusterSecurity.d.ts.map

type EnterpriseContractProps = {
    enterpriseContractPolicies: EnterpriseContractPolicy[];
};
declare const EnterpriseContract: React$1.FC<EnterpriseContractProps>;
//# sourceMappingURL=EnterpriseContract.d.ts.map

/**
 * Returns the data needed to pass into the Output component
 * @param pipelineRun
 * @param taskRuns
 * @param getLogs
 * @returns OutputGroup
 */
declare const usePipelineRunOutput: (pipelineRun: PipelineRunKind, taskRuns: TaskRunKind[], getLogs: (podName: string, containerName: string) => Promise<string>) => OutputGroup;

type StackedValue = {
    color: string;
    name: string;
    size: number;
};
type HorizontalStackedBarsProps = {
    id: string;
    barGap?: number;
    height?: number | string;
    inline?: boolean;
    values: StackedValue[];
    width?: number | string;
    onClick?: () => void;
};
declare const HorizontalStackedBars: ({ id, barGap, height, inline, values, width, onClick, }: HorizontalStackedBarsProps) => react_jsx_runtime.JSX.Element;

interface TaskStatusToolTipProps {
    taskStatus: TaskStatusTypes;
}
declare const TaskStatusTooltip: ({ taskStatus }: TaskStatusToolTipProps) => react_jsx_runtime.JSX.Element;

type DataStateConditions = RunStatus | SucceedConditionReason | 'STATUS_WITHOUT_CONDITIONS' | 'STATUS_WITH_EMPTY_CONDITIONS';
type ResourceConfig = {
    name: string;
    status: DataStateConditions;
    labels?: {
        [key: string]: string;
    };
    annotations?: {
        [key: string]: string;
    };
    results?: TektonResultsRun[];
};
type mockPipelineRunConfig = ResourceConfig & {
    spec?: any;
    tasks: ResourceConfig[];
    createTaskRuns?: boolean;
    createPods?: boolean;
};
declare const createPipelineRunData: (config: mockPipelineRunConfig) => {
    pipelineRun: PipelineRunKind;
    taskRuns?: TaskRunKind[] | undefined;
    pods?: any[] | undefined;
};

declare const getTaskRunLog: (namespace: string, taskRunName: string, config: TektonConfiguration) => Promise<string>;

declare const getRunStatusColor: (status: string) => StatusMessage;
declare const getLatestPipelineRun: (runs: PipelineRunKind[], field: string) => PipelineRunKind | null;
declare const getPipelineRunStatus: (pipelineRun: PipelineRunKind | TaskRunKind | PipelineTaskWithStatus | null) => ComputedStatus | null;
declare const pipelineRunFilterReducer: (pipelineRun: PipelineRunKind | TaskRunKind) => ComputedStatus;
declare const updateTaskStatus: (pipelinerun: PipelineRunKind | null, taskRuns: TaskRunKind[]) => TaskStatusTypes;
declare const totalPipelineRunTasks: (pipelinerun: PipelineRunKind | null) => number;
declare const getTaskStatus: (pipelinerun: PipelineRunKind, taskRuns: TaskRunKind[]) => TaskStatusTypes;

declare const getTaskRunsForPipelineRun: (pipelinerun: PipelineRunKind | null, taskRuns: TaskRunKind[]) => TaskRunKind[];

type GetGroupVersionKindForModel = (model: K8sModel) => K8sGroupVersionKind;
declare const useDeepCompareMemoize: <T = any>(value: T, strinfigy?: boolean) => T | undefined;
declare const getGroupVersionKindForModel: GetGroupVersionKindForModel;

declare const usePipelineRuns: (namespace: string, config: TektonConfiguration, options?: {
    selector?: Selector$1;
    limit?: number;
}, cacheKey?: string) => [PipelineRunKind[], boolean, unknown, GetNextPage];
declare const usePipelineRun: (namespace: string, pipelineRunName: string, config: TektonConfiguration, cacheKey?: string) => [PipelineRunKind, boolean, string];

declare const useRuns: <Kind extends K8sResourceCommon>(groupVersionKind: K8sGroupVersionKind, namespace: string, config: TektonConfiguration, options?: {
    selector?: Selector$1;
    limit?: number;
    name?: string;
}, cacheKey?: string) => [Kind[], boolean, unknown, GetNextPage];

declare const useTRTaskRunLog: (namespace: string, taskRunName: string, config: TektonConfiguration) => [string | null, boolean, unknown];

declare const getTaskRunsOfPipelineRun: (taskRuns: TaskRunKind[], pipelineRunName: string) => TaskRunKind[];
declare const useTaskRuns: (namespace: string, config: TektonConfiguration, options?: {
    selector?: Selector$1;
    limit?: number;
}, cacheKey?: string) => [TaskRunKind[], boolean, unknown, GetNextPage];
declare const useTaskRun: (namespace: string, taskRunName: string, config: TektonConfiguration, cacheKey?: string) => [TaskRunKind, boolean, string];

declare const useTektonResultsRuns: <Kind extends K8sResourceCommon>(getRuns: (namespace: string, config: TektonConfiguration, options?: TektonResultsOptions, nextPageToken?: string, cacheKey?: string) => Promise<[Kind[], RecordsList, (boolean | undefined)?]>, namespace: string, config: TektonConfiguration, options?: TektonResultsOptions, cacheKey?: string) => [Kind[], boolean, unknown, GetNextPage];

declare const usePipelineRunsForPipelineOrRepository: (ns: string, config: TektonConfiguration, options?: {
    name: string;
    kind: string;
}, cacheKey?: string) => [PipelineRunKind[], boolean, unknown, GetNextPage];

declare const useTaskRunsForPipelineRunOrTask: (namespace: string, config: TektonConfiguration, pipelineRunName?: string, taskName?: string, cacheKey?: string) => [TaskRunKind[], boolean, unknown, GetNextPage];

declare const useTRPipelineRuns: (namespace: string, config: TektonConfiguration, options?: TektonResultsOptions, cacheKey?: string) => [PipelineRunKind[], boolean, unknown, GetNextPage];

declare const useTRTaskRuns: (namespace: string, config: TektonConfiguration, options?: TektonResultsOptions, cacheKey?: string) => [TaskRunKind[], boolean, unknown, GetNextPage];

export { type ACSCheckResults, type ACSImageCheckSummary, type ACSImageScanResult, type ACSImageScanSummary, ACS_BREAKING_CHANGES, ACS_IMAGE_CHECK_SEVERITY, ACS_SCAN_RESULTS, ACS_SEVERITY, ACS_STATUS, type Addon, AdvancedClusterSecurity, type ComponentEnterpriseContractResult, ComputedStatus, type Condition, type Dashboard, DurationTypes, type ECPolicy, ENTERPRISE_CONTRACT_POLICY_STATUS, EnterpriseContract, type EnterpriseContractPolicy, type EnterpriseContractResult, type EnterpriseContractRule, type GetGroupVersionKindForModel, HorizontalStackedBars, LevelTypes, MetricsLevel, Output, type OutputGroup, type OutputTaskRunGroup, type PLRTaskRunData, type PLRTaskRunStep, type PLRTaskRuns, type Param, type PersistentVolumeClaimType, type Pipeline, type PipelineKind, type PipelineResult, type PipelineRunEmbeddedResource, type PipelineRunEmbeddedResourceParam, type PipelineRunKind, type PipelineRunParam, type PipelineRunReferenceResource, type PipelineRunResource, type PipelineRunStatus, type PipelineRunWorkspace, type PipelineSpec, type PipelineTask, type PipelineTaskParam, type PipelineTaskRef, type PipelineTaskResource, type PipelineTaskWithStatus, type PipelineTaskWorkspace, type PipelineWithLatest, type Pruner, type ResourceTarget, type Result, ResultsList, RunStatus, type Spec, type Status, type StatusMessage, SucceedConditionReason, type TaskKind, type TaskResult, type TaskRunKind, TaskRunResultsAnnotations, TaskRunResultsFormatValue, TaskRunResultsKeyValue, TaskRunResultsLocationValue, TaskRunResultsTypeValue, type TaskRunStatus, type TaskRunWorkspace, TaskStatusTooltip, type TaskStatusTypes, TaskType, type TektonConfig, type TektonConfigCondition, type TektonParam, type TektonResource, type TektonResourceGroup, TektonResourceLabel, type TektonResultsRun, type TektonTaskSpec, type TektonTaskSpecV1Beta1, type TektonWorkspace, TerminatedReasons, type Trigger, type ViolatedPolicy, type VolumeClaimTemplateType, type VolumeTypeClaim, type VolumeTypeConfigMaps, type VolumeTypePVC, type VolumeTypeSecret, type Vulnerability, type WhenExpression, conditionsRunStatus, createPipelineRunData, getGroupVersionKindForModel, getLatestPipelineRun, getPipelineRunStatus, getRunStatusColor, getTaskRunLog, getTaskRunsForPipelineRun, getTaskRunsOfPipelineRun, getTaskStatus, pipelineRunFilterReducer, pipelineRunStatus, totalPipelineRunTasks, mapEnterpriseContractResultData as transformECResult, updateTaskStatus, useDeepCompareMemoize, usePipelineRun, usePipelineRunOutput, usePipelineRuns, usePipelineRunsForPipelineOrRepository, useRuns, useTRPipelineRuns, useTRTaskRunLog, useTRTaskRuns, useTaskRun, useTaskRuns, useTaskRunsForPipelineRunOrTask, useTektonResultsRuns };