argo-cd

1
import {models} from 'argo-ui';
2

3
interface ItemsList<T> {
4
    /**
5
     * APIVersion defines the versioned schema of this representation of an object.
6
     * Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values.
7
     */
8
    apiVersion?: string;
9
    items: T[];
10
    /**
11
     * Kind is a string value representing the REST resource this object represents.
12
     * Servers may infer this from the endpoint the client submits requests to.
13
     */
14
    kind?: string;
15
    metadata: models.ListMeta;
16
}
17

18
export interface ApplicationList extends ItemsList<Application> {}
19

20
export interface SyncOperationResource {
21
    group: string;
22
    kind: string;
23
    name: string;
24
}
25

26
export interface SyncStrategy {
27
    apply?: {force?: boolean};
28
    hook?: {force?: boolean};
29
}
30

31
export interface SyncOperation {
32
    revision: string;
33
    prune: boolean;
34
    dryRun: boolean;
35
    resources?: SyncOperationResource[];
36
}
37

38
export interface RetryBackoff {
39
    duration: string;
40
    maxDuration: string;
41
    factor: number;
42
}
43

44
export interface RetryStrategy {
45
    limit: number;
46
    backoff: RetryBackoff;
47
}
48

49
export interface RollbackOperation {
50
    id: number;
51
    prune: boolean;
52
    dryRun: boolean;
53
}
54

55
export interface OperationInitiator {
56
    username: string;
57
    automated: boolean;
58
}
59

60
export interface Operation {
61
    sync: SyncOperation;
62
    initiatedBy: OperationInitiator;
63
}
64

65
export type OperationPhase = 'Running' | 'Error' | 'Failed' | 'Succeeded' | 'Terminating';
66

67
export const OperationPhases = {
68
    Running: 'Running' as OperationPhase,
69
    Failed: 'Failed' as OperationPhase,
70
    Error: 'Error' as OperationPhase,
71
    Succeeded: 'Succeeded' as OperationPhase,
72
    Terminating: 'Terminating' as OperationPhase
73
};
74

75
/**
76
 * OperationState contains information about state of currently performing operation on application.
77
 */
78
export interface OperationState {
79
    operation: Operation;
80
    phase: OperationPhase;
81
    message: string;
82
    syncResult: SyncOperationResult;
83
    startedAt: models.Time;
84
    finishedAt: models.Time;
85
}
86

87
export type HookType = 'PreSync' | 'Sync' | 'PostSync' | 'SyncFail' | 'Skip';
88

89
export interface RevisionMetadata {
90
    author?: string;
91
    date: models.Time;
92
    tags?: string[];
93
    message?: string;
94
    signatureInfo?: string;
95
}
96

97
export interface ChartDetails {
98
    description?: string;
99
    maintainers?: string[];
100
    home?: string;
101
}
102

103
export interface SyncOperationResult {
104
    resources: ResourceResult[];
105
    revision: string;
106
}
107

108
export type ResultCode = 'Synced' | 'SyncFailed' | 'Pruned' | 'PruneSkipped';
109

110
export const ResultCodes = {
111
    Synced: 'Synced',
112
    SyncFailed: 'SyncFailed',
113
    Pruned: 'Pruned',
114
    PruneSkipped: 'PruneSkipped'
115
};
116

117
export interface ResourceResult {
118
    name: string;
119
    group: string;
120
    kind: string;
121
    version: string;
122
    namespace: string;
123
    status: ResultCode;
124
    message: string;
125
    hookType: HookType;
126
    hookPhase: OperationPhase;
127
}
128

129
export const AnnotationRefreshKey = 'argocd.argoproj.io/refresh';
130
export const AnnotationHookKey = 'argocd.argoproj.io/hook';
131
export const AnnotationSyncWaveKey = 'argocd.argoproj.io/sync-wave';
132
export const AnnotationDefaultView = 'pref.argocd.argoproj.io/default-view';
133
export const AnnotationDefaultPodSort = 'pref.argocd.argoproj.io/default-pod-sort';
134

135
export interface Application {
136
    apiVersion?: string;
137
    kind?: string;
138
    metadata: models.ObjectMeta;
139
    spec: ApplicationSpec;
140
    status: ApplicationStatus;
141
    operation?: Operation;
142
    isAppOfAppsPattern?: boolean;
143
}
144

145
export type WatchType = 'ADDED' | 'MODIFIED' | 'DELETED' | 'ERROR';
146

147
export interface ApplicationWatchEvent {
148
    type: WatchType;
149
    application: Application;
150
}
151

152
export interface ComponentParameter {
153
    component: string;
154
    name: string;
155
    value: string;
156
}
157

158
export interface ApplicationDestination {
159
    /**
160
     * Server address of the destination cluster
161
     */
162
    server: string;
163
    /**
164
     * Namespace of the destination cluster
165
     */
166
    namespace: string;
167
    /**
168
     * Name of the destination cluster which can be used instead of server (url) field
169
     */
170
    name: string;
171
}
172

173
export interface OrphanedResource {
174
    group: string;
175
    kind: string;
176
    name: string;
177
}
178

179
export interface ApplicationSource {
180
    targetRevision: string;
181
    /**
182
     * RepoURL is repository URL which contains application project.
183
     */
184
    repoURL: string;
185

186
    /**
187
     * Path is a directory path within repository which
188
     */
189
    path?: string;
190

191
    chart?: string;
192

193
    helm?: ApplicationSourceHelm;
194

195
    kustomize?: ApplicationSourceKustomize;
196

197
    plugin?: ApplicationSourcePlugin;
198

199
    directory?: ApplicationSourceDirectory;
200
}
201

202
export interface ApplicationSourceHelm {
203
    valueFiles: string[];
204
    values?: string;
205
    valuesObject?: any;
206
    parameters: HelmParameter[];
207
    fileParameters: HelmFileParameter[];
208
}
209

210
export interface ApplicationSourceKustomize {
211
    namePrefix: string;
212
    nameSuffix: string;
213
    images: string[];
214
    version: string;
215
    namespace: string;
216
}
217
export interface EnvEntry {
218
    name: string;
219
    value: string;
220
}
221

222
export interface ApplicationSourcePlugin {
223
    name: string;
224
    env: EnvEntry[];
225
    parameters?: Parameter[];
226
}
227

228
export interface Parameter {
229
    name: string;
230
    string?: string;
231
    array?: string[];
232
    map?: Map<string, string>;
233
}
234

235
export interface JsonnetVar {
236
    name: string;
237
    value: string;
238
    code: boolean;
239
}
240

241
interface ApplicationSourceJsonnet {
242
    extVars: JsonnetVar[];
243
    tlas: JsonnetVar[];
244
}
245

246
export interface ApplicationSourceDirectory {
247
    recurse: boolean;
248
    jsonnet?: ApplicationSourceJsonnet;
249
    include?: string;
250
    exclude?: string;
251
}
252

253
export interface Automated {
254
    prune: boolean;
255
    selfHeal: boolean;
256
}
257

258
export interface SyncPolicy {
259
    automated?: Automated;
260
    syncOptions?: string[];
261
    retry?: RetryStrategy;
262
}
263

264
export interface Info {
265
    name: string;
266
    value: string;
267
}
268

269
export interface ApplicationSpec {
270
    project: string;
271
    source: ApplicationSource;
272
    sources: ApplicationSource[];
273
    destination: ApplicationDestination;
274
    syncPolicy?: SyncPolicy;
275
    ignoreDifferences?: ResourceIgnoreDifferences[];
276
    info?: Info[];
277
    revisionHistoryLimit?: number;
278
}
279

280
export interface ResourceIgnoreDifferences {
281
    group: string;
282
    kind: string;
283
    name: string;
284
    namespace: string;
285
    jsonPointers: string[];
286
    jqPathExpressions: string[];
287
}
288

289
/**
290
 * RevisionHistory contains information relevant to an application deployment
291
 */
292
export interface RevisionHistory {
293
    id: number;
294
    revision: string;
295
    source: ApplicationSource;
296
    revisions: string[];
297
    sources: ApplicationSource[];
298
    deployStartedAt: models.Time;
299
    deployedAt: models.Time;
300
    initiatedBy: OperationInitiator;
301
}
302

303
export type SyncStatusCode = 'Unknown' | 'Synced' | 'OutOfSync';
304

305
export const SyncStatuses: {[key: string]: SyncStatusCode} = {
306
    Unknown: 'Unknown',
307
    Synced: 'Synced',
308
    OutOfSync: 'OutOfSync'
309
};
310

311
export type HealthStatusCode = 'Unknown' | 'Progressing' | 'Healthy' | 'Suspended' | 'Degraded' | 'Missing';
312

313
export const HealthStatuses: {[key: string]: HealthStatusCode} = {
314
    Unknown: 'Unknown',
315
    Progressing: 'Progressing',
316
    Suspended: 'Suspended',
317
    Healthy: 'Healthy',
318
    Degraded: 'Degraded',
319
    Missing: 'Missing'
320
};
321

322
export interface HealthStatus {
323
    status: HealthStatusCode;
324
    message: string;
325
}
326

327
export type State = models.TypeMeta & {metadata: models.ObjectMeta} & {status: any; spec: any};
328

329
export type ReadinessGate = {
330
    conditionType: string;
331
};
332

333
export interface ResourceStatus {
334
    group: string;
335
    version: string;
336
    kind: string;
337
    namespace: string;
338
    name: string;
339
    status: SyncStatusCode;
340
    health: HealthStatus;
341
    createdAt?: models.Time;
342
    hook?: boolean;
343
    requiresPruning?: boolean;
344
    syncWave?: number;
345
    orphaned?: boolean;
346
}
347

348
export interface ResourceRef {
349
    uid: string;
350
    kind: string;
351
    namespace: string;
352
    name: string;
353
    version: string;
354
    group: string;
355
}
356

357
export interface ResourceNetworkingInfo {
358
    targetLabels: {[name: string]: string};
359
    targetRefs: ResourceRef[];
360
    labels: {[name: string]: string};
361
    ingress: LoadBalancerIngress[];
362
    externalURLs: string[];
363
}
364

365
export interface LoadBalancerIngress {
366
    hostname: string;
367
    ip: string;
368
}
369

370
export interface InfoItem {
371
    name: string;
372
    value: string;
373
}
374

375
export interface ResourceNode extends ResourceRef {
376
    parentRefs: ResourceRef[];
377
    info: InfoItem[];
378
    networkingInfo?: ResourceNetworkingInfo;
379
    images?: string[];
380
    resourceVersion: string;
381
    createdAt?: models.Time;
382
}
383

384
export interface ApplicationTree {
385
    nodes: ResourceNode[];
386
    orphanedNodes: ResourceNode[];
387
    hosts: Node[];
388
}
389

390
export interface ResourceID {
391
    group: string;
392
    kind: string;
393
    namespace: string;
394
    name: string;
395
}
396

397
export interface ResourceDiff extends ResourceID {
398
    targetState: State;
399
    liveState: State;
400
    predictedLiveState: State;
401
    normalizedLiveState: State;
402
    hook: boolean;
403
}
404

405
export interface SyncStatus {
406
    comparedTo: ApplicationSource;
407
    status: SyncStatusCode;
408
    revision: string;
409
    revisions: string[];
410
}
411

412
export interface ApplicationCondition {
413
    type: string;
414
    message: string;
415
    lastTransitionTime: string;
416
}
417

418
export interface ApplicationSummary {
419
    externalURLs?: string[];
420
    images?: string[];
421
}
422

423
export interface ApplicationStatus {
424
    observedAt: models.Time;
425
    resources: ResourceStatus[];
426
    sync: SyncStatus;
427
    conditions?: ApplicationCondition[];
428
    history: RevisionHistory[];
429
    health: HealthStatus;
430
    operationState?: OperationState;
431
    summary?: ApplicationSummary;
432
}
433

434
export interface JwtTokens {
435
    items: JwtToken[];
436
}
437
export interface AppProjectStatus {
438
    jwtTokensByRole: {[name: string]: JwtTokens};
439
}
440

441
export interface LogEntry {
442
    content: string;
443
    timeStamp: models.Time;
444
    // first field is inferred on the fly and indicats first log line received from backend
445
    first?: boolean;
446
    last: boolean;
447
    timeStampStr: string;
448
    podName: string;
449
}
450

451
// describes plugin settings
452
export interface Plugin {
453
    name: string;
454
}
455

456
export interface AuthSettings {
457
    url: string;
458
    statusBadgeEnabled: boolean;
459
    statusBadgeRootUrl: string;
460
    googleAnalytics: {
461
        trackingID: string;
462
        anonymizeUsers: boolean;
463
    };
464
    dexConfig: {
465
        connectors: {
466
            name: string;
467
            type: string;
468
        }[];
469
    };
470
    oidcConfig: {
471
        name: string;
472
        issuer: string;
473
        clientID: string;
474
        scopes: string[];
475
        enablePKCEAuthentication: boolean;
476
    };
477
    help: {
478
        chatUrl: string;
479
        chatText: string;
480
        binaryUrls: Record<string, string>;
481
    };
482
    userLoginsDisabled: boolean;
483
    kustomizeVersions: string[];
484
    uiCssURL: string;
485
    uiBannerContent: string;
486
    uiBannerURL: string;
487
    uiBannerPermanent: boolean;
488
    uiBannerPosition: string;
489
    execEnabled: boolean;
490
    appsInAnyNamespaceEnabled: boolean;
491
}
492

493
export interface UserInfo {
494
    loggedIn: boolean;
495
    username: string;
496
    iss: string;
497
    groups: string[];
498
}
499

500
export type ConnectionStatus = 'Unknown' | 'Successful' | 'Failed';
501

502
export const ConnectionStatuses = {
503
    Unknown: 'Unknown',
504
    Failed: 'Failed',
505
    Successful: 'Successful'
506
};
507

508
export interface ConnectionState {
509
    status: ConnectionStatus;
510
    message: string;
511
    attemptedAt: models.Time;
512
}
513

514
export interface RepoCert {
515
    serverName: string;
516
    certType: string;
517
    certSubType: string;
518
    certData: string;
519
    certInfo: string;
520
}
521

522
export interface RepoCertList extends ItemsList<RepoCert> {}
523

524
export interface Repository {
525
    repo: string;
526
    type?: string;
527
    name?: string;
528
    connectionState: ConnectionState;
529
    project?: string;
530
    username?: string;
531
    password?: string;
532
    tlsClientCertData?: string;
533
    tlsClientCertKey?: string;
534
    proxy?: string;
535
    insecure?: boolean;
536
    enableLfs?: boolean;
537
    githubAppId?: string;
538
    forceHttpBasicAuth?: boolean;
539
    enableOCI: boolean;
540
}
541

542
export interface RepositoryList extends ItemsList<Repository> {}
543

544
export interface RepoCreds {
545
    url: string;
546
    username?: string;
547
}
548

549
export interface RepoCredsList extends ItemsList<RepoCreds> {}
550

551
export interface Cluster {
552
    name: string;
553
    server: string;
554
    namespaces?: [];
555
    refreshRequestedAt?: models.Time;
556
    config?: {
557
        awsAuthConfig?: {
558
            clusterName: string;
559
        };
560
        execProviderConfig?: {
561
            command: string;
562
        };
563
    };
564
    info?: {
565
        applicationsCount: number;
566
        serverVersion: string;
567
        connectionState: ConnectionState;
568
        cacheInfo: ClusterCacheInfo;
569
    };
570
    annotations?: {[name: string]: string};
571
    labels?: {[name: string]: string};
572
}
573

574
export interface ClusterCacheInfo {
575
    resourcesCount: number;
576
    apisCount: number;
577
    lastCacheSyncTime: models.Time;
578
}
579

580
export interface ClusterList extends ItemsList<Cluster> {}
581

582
export interface HelmChart {
583
    name: string;
584
    versions: string[];
585
}
586

587
export type AppSourceType = 'Helm' | 'Kustomize' | 'Directory' | 'Plugin';
588

589
export interface RepoAppDetails {
590
    type: AppSourceType;
591
    path: string;
592
    helm?: HelmAppSpec;
593
    kustomize?: KustomizeAppSpec;
594
    plugin?: PluginAppSpec;
595
    directory?: {};
596
}
597

598
export interface RefsInfo {
599
    branches: string[];
600
    tags: string[];
601
}
602

603
export interface AppInfo {
604
    type: string;
605
    path: string;
606
}
607

608
export interface HelmParameter {
609
    name: string;
610
    value: string;
611
}
612

613
export interface HelmFileParameter {
614
    name: string;
615
    path: string;
616
}
617

618
export interface HelmAppSpec {
619
    name: string;
620
    path: string;
621
    valueFiles: string[];
622
    values?: string;
623
    parameters: HelmParameter[];
624
    fileParameters: HelmFileParameter[];
625
}
626

627
export interface KustomizeAppSpec {
628
    path: string;
629
    images?: string[];
630
    namespace?: string;
631
}
632

633
export interface PluginAppSpec {
634
    name: string;
635
    env: EnvEntry[];
636
    parametersAnnouncement?: ParameterAnnouncement[];
637
}
638

639
export interface ParameterAnnouncement {
640
    name?: string;
641
    title?: string;
642
    tooltip?: string;
643
    required?: boolean;
644
    itemType?: string;
645
    collectionType?: string;
646
    string?: string;
647
    array?: string[];
648
    map?: Map<string, string>;
649
}
650

651
export interface ObjectReference {
652
    kind: string;
653
    namespace: string;
654
    name: string;
655
    uid: string;
656
    apiVersion: string;
657
    resourceVersion: string;
658
    fieldPath: string;
659
}
660

661
export interface EventSource {
662
    component: string;
663
    host: string;
664
}
665

666
export interface EventSeries {
667
    count: number;
668
    lastObservedTime: models.Time;
669
    state: string;
670
}
671

672
export interface Event {
673
    apiVersion?: string;
674
    kind?: string;
675
    metadata: models.ObjectMeta;
676
    involvedObject: ObjectReference;
677
    reason: string;
678
    message: string;
679
    source: EventSource;
680
    firstTimestamp: models.Time;
681
    lastTimestamp: models.Time;
682
    count: number;
683
    type: string;
684
    eventTime: models.Time;
685
    series: EventSeries;
686
    action: string;
687
    related: ObjectReference;
688
    reportingController: string;
689
    reportingInstance: string;
690
}
691

692
export interface EventList extends ItemsList<Event> {}
693

694
export interface ProjectRole {
695
    description: string;
696
    policies: string[];
697
    name: string;
698
    groups: string[];
699
}
700

701
export interface JwtToken {
702
    iat: number;
703
    exp: number;
704
    id: string;
705
}
706

707
export interface GroupKind {
708
    group: string;
709
    kind: string;
710
}
711

712
export interface ProjectSignatureKey {
713
    keyID: string;
714
}
715

716
export interface ProjectSpec {
717
    sourceRepos: string[];
718
    sourceNamespaces: string[];
719
    destinations: ApplicationDestination[];
720
    description: string;
721
    roles: ProjectRole[];
722
    clusterResourceWhitelist: GroupKind[];
723
    clusterResourceBlacklist: GroupKind[];
724
    namespaceResourceBlacklist: GroupKind[];
725
    namespaceResourceWhitelist: GroupKind[];
726
    signatureKeys: ProjectSignatureKey[];
727
    orphanedResources?: {warn?: boolean; ignore: OrphanedResource[]};
728
    syncWindows?: SyncWindows;
729
}
730

731
export type SyncWindows = SyncWindow[];
732

733
export interface SyncWindow {
734
    kind: string;
735
    schedule: string;
736
    duration: string;
737
    applications: string[];
738
    namespaces: string[];
739
    clusters: string[];
740
    manualSync: boolean;
741
    timeZone: string;
742
}
743

744
export interface Project {
745
    apiVersion?: string;
746
    kind?: string;
747
    metadata: models.ObjectMeta;
748
    spec: ProjectSpec;
749
    status: AppProjectStatus;
750
}
751

752
export interface DetailedProjectsResponse {
753
    project: Project;
754
    globalProjects: Project[];
755
    repositories: Repository[];
756
    clusters: Cluster[];
757
}
758

759
export type ProjectList = ItemsList<Project>;
760

761
export const DEFAULT_PROJECT_NAME = 'default';
762

763
export interface ManifestResponse {
764
    manifests: string[];
765
    namespace: string;
766
    server: string;
767
    revision: string;
768
}
769

770
export interface ResourceActionParam {
771
    name: string;
772
    value: string;
773
    type: string;
774
    default: string;
775
}
776

777
export interface ResourceAction {
778
    name: string;
779
    params: ResourceActionParam[];
780
    disabled: boolean;
781
    iconClass: string;
782
    displayName: string;
783
}
784

785
export interface SyncWindowsState {
786
    windows: SyncWindow[];
787
}
788

789
export interface ApplicationSyncWindowState {
790
    activeWindows: SyncWindow[];
791
    assignedWindows: SyncWindow[];
792
    canSync: boolean;
793
}
794

795
export interface VersionMessage {
796
    Version: string;
797
    BuildDate: string;
798
    GoVersion: string;
799
    Compiler: string;
800
    Platform: string;
801
    KustomizeVersion: string;
802
    HelmVersion: string;
803
    KubectlVersion: string;
804
    JsonnetVersion: string;
805
}
806

807
export interface Token {
808
    id: string;
809
    issuedAt: number;
810
    expiresAt: number;
811
}
812

813
export interface Account {
814
    name: string;
815
    enabled: boolean;
816
    capabilities: string[];
817
    tokens: Token[];
818
}
819

820
export interface GnuPGPublicKey {
821
    keyID?: string;
822
    fingerprint?: string;
823
    subType?: string;
824
    owner?: string;
825
    keyData?: string;
826
}
827

828
export interface GnuPGPublicKeyList extends ItemsList<GnuPGPublicKey> {}
829

830
// https://kubernetes.io/docs/reference/kubectl/overview/#resource-types
831

832
export const ResourceKinds = [
833
    '*',
834
    'Binding',
835
    'ComponentStatus',
836
    'ConfigMap',
837
    'Endpoints',
838
    'LimitRange',
839
    'Namespace',
840
    'Node',
841
    'PersistentVolumeClaim',
842
    'PersistentVolume',
843
    'Pod',
844
    'PodTemplate',
845
    'ReplicationController',
846
    'ResourceQuota',
847
    'Secret',
848
    'ServiceAccount',
849
    'Service',
850
    'MutatingWebhookConfiguration',
851
    'ValidatingWebhookConfiguration',
852
    'CustomResourceDefinition',
853
    'APIService',
854
    'ControllerRevision',
855
    'DaemonSet',
856
    'Deployment',
857
    'ReplicaSet',
858
    'StatefulSet',
859
    'TokenReview',
860
    'LocalSubjectAccessReview',
861
    'SelfSubjectAccessReview',
862
    'SelfSubjectRulesReview',
863
    'SubjectAccessReview',
864
    'HorizontalPodAutoscaler',
865
    'CronJob',
866
    'Job',
867
    'CertificateSigningRequest',
868
    'Lease',
869
    'Event',
870
    'Ingress',
871
    'NetworkPolicy',
872
    'PodDisruptionBudget',
873
    'ClusterRoleBinding',
874
    'ClusterRole',
875
    'RoleBinding',
876
    'Role',
877
    'PriorityClass',
878
    'CSIDriver',
879
    'CSINode',
880
    'StorageClass',
881
    'Volume'
882
];
883

884
export const Groups = [
885
    'admissionregistration.k8s.io',
886
    'apiextensions.k8s.io',
887
    'apiregistration.k8s.io',
888
    'apps',
889
    'authentication.k8s.io',
890
    'authorization.k8s.io',
891
    'autoscaling',
892
    'batch',
893
    'certificates.k8s.io',
894
    'coordination.k8s.io',
895
    'events.k8s.io',
896
    'extensions',
897
    'networking.k8s.io',
898
    'node.k8s.io',
899
    'policy',
900
    'rbac.authorization.k8s.io',
901
    'scheduling.k8s.io',
902
    'stable.example.com',
903
    'storage.k8s.io'
904
];
905

906
export interface HostResourceInfo {
907
    resourceName: ResourceName;
908
    requestedByApp: number;
909
    requestedByNeighbors: number;
910
    capacity: number;
911
}
912

913
export interface Node {
914
    name: string;
915
    systemInfo: NodeSystemInfo;
916
    resourcesInfo: HostResourceInfo[];
917
}
918

919
export interface NodeSystemInfo {
920
    architecture: string;
921
    operatingSystem: string;
922
    kernelVersion: string;
923
}
924

925
export enum ResourceName {
926
    ResourceCPU = 'cpu',
927
    ResourceMemory = 'memory',
928
    ResourceStorage = 'storage'
929
}
930

931
export interface Pod extends ResourceNode {
932
    fullName: string;
933
    metadata: models.ObjectMeta;
934
    spec: PodSpec;
935
    health: HealthStatusCode;
936
}
937

938
export interface PodSpec {
939
    nodeName: string;
940
}
941

942
export enum PodPhase {
943
    PodPending = 'Pending',
944
    PodRunning = 'Running',
945
    PodSucceeded = 'Succeeded',
946
    PodFailed = 'Failed',
947
    PodUnknown = 'Unknown'
948
}
949

950
export interface NotificationChunk {
951
    name: string;
952
}
953

954
export interface LinkInfo {
955
    title: string;
956
    url: string;
957
    description?: string;
958
    iconClass?: string;
959
}
960

961
export interface LinksResponse {
962
    items: LinkInfo[];
963
}
964

965
export interface UserMessages {
966
    appName: string;
967
    msgKey: string;
968
    display: boolean;
969
    condition?: HealthStatusCode;
970
    duration?: number;
971
    animation?: string;
972
}
973