@alauda-fe/network 1.0.1 → 1.0.3

package/index.d.ts

@@ -5,14 +5,22 @@ export { ServiceAnnotationsFormComponent } from './lib/components/service-annota
 export { ServiceAnnotationsFormItemComponent } from './lib/components/service-annotations-form-item/annotations.component';
 export { K8sServiceFormComponent } from './lib/components/service-form/component';
 export * from './lib/directives/subnet-validator.directive';
+export { LabelSelectorDisplayComponent } from './lib/features/network-policy/components/label-selector-display/component';
+export { NetworkPolicyRuleTableComponent } from './lib/features/network-policy/components/rule-table/component';
+export { NetworkPolicyFormComponent } from './lib/features/network-policy/form/network-policy/component';
+export { NetworkPolicyExceptRemoteInputFormComponent } from './lib/features/network-policy/form/network-policy-remote-except-input/component';
 export * from './lib/services/alb-api.service';
 export * from './lib/services/certificate-api.service';
 export * from './lib/services/network-util.service';
+export * from './lib/services/subnet-util.service';
 export * from './lib/types/alb-exports';
 export * from './lib/types/k8s-exports';
-export * from './lib/types/resource-definition';
+export * from './lib/types/metallb-exports';
+export { KUBE_OVN_GROUP, NETWORK_RESOURCE_DEFINITIONS, NETWORK_RESOURCE_TYPES, NetworkResourceDefinitions, } from './lib/types/resource-definition';
 export * from './lib/utils/alb-exports';
 export * from './lib/utils/cidr-exports';
 export * from './lib/utils/cluster-exports';
+export * from './lib/utils/common-exports';
 export * from './lib/utils/service-exports';
 export * from './lib/utils/subnet-exports';
+export * from './lib/utils/validators-exports';

package/lib/components/fixed-ip/component.d.ts

@@ -36,15 +36,21 @@ export declare class FixedIpInputComponent extends CommonFormControl<string | st
     errors$: Observable<ValidationErrors>;
     errorsMapper: StringMap;
     errorsMapper$: Observable<StringMap>;
-    uniq: <T>(array: import("lodash").List<T>) => T[];
+    uniq: <T>(array: import("lodash").List<T> | null | undefined) => T[];
     onValidatorChange: () => void;
     get isCalico(): boolean;
     private readonly namespaceResource$;
     private readonly networkMode$;
-    private readonly $networkMode;
+    readonly $networkMode: import("@angular/core").Signal<"v4" | "v6" | "dual">;
     private readonly subnetDetails$;
     private readonly subnetInfo$;
-    private readonly $subnetInfo;
+    readonly $subnetInfo: import("@angular/core").Signal<{
+        cluster: string;
+        subnetCidrs: string[];
+        subnetName: string;
+        gateway: string;
+        excludeIps: string[];
+    }>;
     cidr$: Observable<string>;
     private readonly innerErrorsMapper$;
     combinedErrorsMapper$: Observable<{
@@ -57,6 +63,7 @@ export declare class FixedIpInputComponent extends CommonFormControl<string | st
     private readonly $usedIps;
     ipAddressSuggestions$: Observable<string[]>;
     constructor(cdr: ChangeDetectorRef, k8sUtil: K8sUtilService, k8sApi: K8sApiService, networkUtilService: NetworkUtilService, translate: TranslateService);
+    isReservedIp(ip: string, excludeIps: string[]): boolean;
     registerOnValidatorChange(fn: () => void): void;
     validate(ctrl: AbstractControl): Observable<ValidationErrors>;
     private setErrors;

package/lib/components/service-annotations-form/annotations.component.d.ts

@@ -1,4 +1,4 @@
-import { BaseStringMapFormComponent, KeyValueTuple, Locale, StringMap, TranslateKey } from '@alauda-fe/common';
+import { BaseStringMapFormComponent, KeyValueTuple, StringMap, TranslateKey } from '@alauda-fe/common';
 import { Injector } from '@angular/core';
 import { FormArray, FormControl } from '@angular/forms';
 import { ClusterType } from '../../utils/cluster-exports';
@@ -13,22 +13,22 @@ declare enum PRODUCT_BASE_HREF_MAP {
 }
 export interface AnnotationConfigOption {
     key: string;
-    tip: TranslateKey<Locale>;
+    tip: TranslateKey;
     doc?: {
-        tip: TranslateKey<Locale>;
-        tipPrefix?: TranslateKey<Locale>;
+        tip: TranslateKey;
+        tipPrefix?: TranslateKey;
         path?: string;
         rawUrl?: string;
         product?: keyof typeof PRODUCT_BASE_HREF_MAP;
     };
     value?: {
         example: string;
-        tip: TranslateKey<Locale>;
+        tip: TranslateKey;
         docLink: string;
     };
     values?: Array<{
         value: string;
-        tip?: TranslateKey<Locale>;
+        tip?: TranslateKey;
     }>;
 }
 export declare const KNOWN_ANNOTATIONS: Partial<Record<ClusterType, {

package/lib/components/service-annotations-form-item/annotations.component.d.ts

@@ -6,7 +6,7 @@ export declare class ServiceAnnotationsFormItemComponent extends BaseResourceFor
     isUpdate: boolean;
     clusterType: ClusterType;
     inService: boolean;
-    get resourceName(): "annotation" | "service_annotations";
+    get resourceName(): "annotation" | "network.service_annotations";
     isPublicCloud: (clusterType?: string) => boolean;
     createForm(): import("@angular/forms").FormControl<{}>;
     static ɵfac: i0.ɵɵFactoryDeclaration<ServiceAnnotationsFormItemComponent, never>;

package/lib/components/service-form/component.d.ts

@@ -27,7 +27,7 @@ export declare class K8sServiceFormComponent extends BaseResourceFormGroupCompon
     };
     displayNameKey: string;
     isLbEnabled$: Observable<boolean>;
-    types$: Observable<readonly ["ClusterIP", "NodePort", "LoadBalancer", "ExternalName"] | ("ClusterIP" | "NodePort" | "LoadBalancer" | "ExternalName")[]>;
+    types$: Observable<readonly ["ClusterIP", "NodePort", "LoadBalancer", "ExternalName"] | ("ClusterIP" | "NodePort" | "ExternalName")[]>;
     constructor(injector: Injector, k8sUtil: K8sUtilService, featureGate: FeatureGateService);
     ngAfterViewInit(): void;
     getDefaultFormModel(): ServiceFormModel;

package/lib/features/network-policy/components/add-peer-rule-handler/component.d.ts

@@ -0,0 +1,8 @@
+import { EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+export type NetworkPolicyPeerType = 'ipBlock' | 'namespaceLevel' | 'clusterLevel';
+export declare class PeerRuleHandlerComponent {
+    peerTypeChange: EventEmitter<NetworkPolicyPeerType>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PeerRuleHandlerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PeerRuleHandlerComponent, "acl-peer-rule-handler", never, {}, { "peerTypeChange": "peerTypeChange"; }, never, never, true, never>;
+}

package/lib/features/network-policy/components/ip-block-display/component.d.ts

@@ -0,0 +1,7 @@
+import { IPBlock } from '../../../../types/k8s-exports';
+import * as i0 from "@angular/core";
+export declare class IPBlockDisplayComponent {
+    ipBlock: IPBlock;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IPBlockDisplayComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IPBlockDisplayComponent, "acl-ip-block-display", never, { "ipBlock": { "alias": "ipBlock"; "required": true; }; }, {}, never, never, true, never>;
+}

package/lib/features/network-policy/components/label-selector-display/component.d.ts

@@ -0,0 +1,13 @@
+import { LabelSelector, matchExpressionsToString, StringMap } from '@alauda-fe/common';
+import * as i0 from "@angular/core";
+export declare const matchLabelsToString: (params?: StringMap) => string;
+export declare class LabelSelectorDisplayComponent {
+    type: 'podSelector' | 'namespaceSelector';
+    selector: LabelSelector;
+    showTitle: boolean;
+    emptyPlaceholder: string;
+    matchExpressionsToString: typeof matchExpressionsToString;
+    matchLabelsToString: (params?: StringMap) => string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LabelSelectorDisplayComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LabelSelectorDisplayComponent, "acl-label-selector-display", never, { "type": { "alias": "type"; "required": true; }; "selector": { "alias": "selector"; "required": true; }; "showTitle": { "alias": "showTitle"; "required": false; }; "emptyPlaceholder": { "alias": "emptyPlaceholder"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/features/network-policy/components/peer-container/component.d.ts

@@ -0,0 +1,18 @@
+import { EventEmitter, TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class PeerTitleDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PeerTitleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PeerTitleDirective, "[alkPeerTitle]", never, {}, {}, never, never, true, never>;
+}
+export declare class PeerFooterDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PeerFooterDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PeerFooterDirective, "[alkPeerFooter]", never, {}, {}, never, never, true, never>;
+}
+export declare class NetworkPolicyPeerContainerComponent {
+    peerTitleTemplate: TemplateRef<any>;
+    peerFooterTemplate: TemplateRef<any>;
+    deleteRule: EventEmitter<void>;
+    get hasPeerFooter(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NetworkPolicyPeerContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NetworkPolicyPeerContainerComponent, "acl-network-policy-peer-container", never, {}, { "deleteRule": "deleteRule"; }, ["peerTitleTemplate", "peerFooterTemplate"], ["[alkPeerTitle]", "*", "[alkPeerFooter]"], true, never>;
+}

package/lib/features/network-policy/components/pod-review/component.d.ts

@@ -0,0 +1,37 @@
+import { K8sApiService, K8sUtilService, Pod, StringMap, WorkspaceParams } from '@alauda-fe/common';
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+type PodMap = Record<string, Pod[]>;
+export declare class PodPreviewComponent {
+    private readonly k8sApi;
+    private readonly k8sUtil;
+    private readonly http;
+    hint: string;
+    podLabelSelector: StringMap;
+    namespaceLabelSelector: StringMap;
+    baseParams: WorkspaceParams;
+    baseParams$: Observable<WorkspaceParams>;
+    podMapExpandState: Record<string, boolean>;
+    isEmpty: {
+        <T extends {
+            __trapAny: any;
+        }>(value?: T): boolean;
+        (value: string): value is "";
+        (value: Map<any, any> | Set<any> | import("lodash").List<any> | null | undefined): boolean;
+        (value: object): boolean;
+        <T extends object>(value: T | null | undefined): value is import("lodash").EmptyObjectOf<T> | null | undefined;
+        (value?: any): boolean;
+    };
+    private readonly projects$;
+    private readonly namespaces$;
+    private readonly pods$;
+    podMap$: Observable<PodMap>;
+    constructor(k8sApi: K8sApiService, k8sUtil: K8sUtilService, http: HttpClient);
+    private getPods;
+    private getClusterNamespaces;
+    private getClusterProjects;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PodPreviewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PodPreviewComponent, "acl-pod-preview", never, { "hint": { "alias": "hint"; "required": true; }; "podLabelSelector": { "alias": "podLabelSelector"; "required": false; }; "namespaceLabelSelector": { "alias": "namespaceLabelSelector"; "required": false; }; "baseParams": { "alias": "baseParams"; "required": true; }; }, {}, never, never, true, never>;
+}
+export {};

package/lib/features/network-policy/components/rule-table/component.d.ts

@@ -0,0 +1,21 @@
+import { LabelSelector } from '@alauda-fe/common';
+import { IPBlock, NetworkPolicyPort, PolicyType } from '../../../../types/k8s-exports';
+import { NetworkPolicyPeerType } from '../add-peer-rule-handler/component';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../types/k8s-exports";
+interface RuleListModel {
+    peerType?: NetworkPolicyPeerType;
+    namespaceSelector?: LabelSelector;
+    podSelector?: LabelSelector;
+    ipBlock?: IPBlock;
+    ports?: NetworkPolicyPort[];
+}
+export declare class NetworkPolicyRuleTableComponent {
+    rules: RuleListModel[];
+    policyType: Lowercase<PolicyType>;
+    COLUMNS: string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<NetworkPolicyRuleTableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NetworkPolicyRuleTableComponent, "acl-network-policy-rule-table", never, { "rules": { "alias": "rules"; "required": true; }; "policyType": { "alias": "policyType"; "required": true; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_rules: i1.NetworkPolicyIngressRule[] | i1.NetworkPolicyEgressRule[];
+}
+export {};

package/lib/features/network-policy/form/network-policy/component.d.ts

@@ -0,0 +1,70 @@
+import { DialogService } from '@alauda/ui';
+import { K8sUtilService, TranslateService, Workspace } from '@alauda-fe/common';
+import { Injector } from '@angular/core';
+import { FormArray } from '@angular/forms';
+import { BaseResourceFormGroupComponent } from 'ng-resource-form-util';
+import { NetworkPolicy, PolicyType } from '../../../../types/k8s-exports';
+import * as i0 from "@angular/core";
+export declare class NetworkPolicyFormComponent extends BaseResourceFormGroupComponent<NetworkPolicy> {
+    private readonly k8sUtil;
+    private readonly translate;
+    private readonly dialog;
+    baseParams: Workspace;
+    isUpdate: boolean;
+    get ingressRuleFormArray(): FormArray;
+    get ingressRuleControls(): import("@angular/forms").AbstractControl<any, any>[];
+    get egressRuleFormArray(): FormArray;
+    get egressRuleControls(): import("@angular/forms").AbstractControl<any, any>[];
+    K8S_RESOURCE_NAME_START_WITH_CHARS_ONLY: {
+        pattern: RegExp;
+        tip: string;
+    };
+    labelValidator: {
+        key: typeof import("@alauda-fe/common").k8sResourceLabelKeyValidator;
+        value: import("@angular/forms").ValidatorFn;
+    };
+    labelErrorMapper$: import("rxjs").Observable<{
+        key: {
+            namePattern: string;
+            prefixPattern: string;
+            nameTooLong: string;
+            prefixTooLong: string;
+        };
+        value: {
+            pattern: string;
+            maxlength: string;
+        };
+    }>;
+    PolicyTypes: readonly ["ingress", "egress"];
+    displayNameKey: string;
+    ruleDisabledStateMap: Record<'ingress' | 'egress', boolean>;
+    constructor(injector: Injector, k8sUtil: K8sUtilService, translate: TranslateService, dialog: DialogService);
+    createForm(): import("@angular/forms").FormGroup<{
+        metadata: import("@angular/forms").FormGroup<{
+            name: import("@angular/forms").FormControl<string>;
+            namespace: import("@angular/forms").FormControl<string>;
+            annotations: import("@angular/forms").FormGroup<{
+                [x: string]: import("@angular/forms").FormControl<string>;
+            }>;
+        }>;
+        spec: import("@angular/forms").FormGroup<{
+            podSelector: import("@angular/forms").FormGroup<{
+                matchLabels: import("@angular/forms").FormControl<any>;
+            }>;
+            ingress: FormArray<import("@angular/forms").FormControl<unknown>>;
+            egress: FormArray<import("@angular/forms").FormControl<unknown>>;
+            policyTypes: import("@angular/forms").FormControl<any[]>;
+        }>;
+    }>;
+    getOnFormArrayResizeFn(): () => import("@angular/forms").FormControl<{}>;
+    adaptResourceModel(resource: NetworkPolicy): NetworkPolicy;
+    ruleDisabledChanged(disabled: boolean, policyType: Lowercase<PolicyType>): Promise<void>;
+    addRule(policyType: Lowercase<PolicyType>): void;
+    removeRule(index: number, policyType: Lowercase<PolicyType>): void;
+    private ruleDisabledConfirm;
+    private addPolicyType;
+    private removePolicyType;
+    private updateRuleDisabledStateMap;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NetworkPolicyFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NetworkPolicyFormComponent, "acl-network-policy-form", never, { "baseParams": { "alias": "baseParams"; "required": true; }; "isUpdate": { "alias": "isUpdate"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/features/network-policy/form/network-policy-ip-block/component.d.ts

@@ -0,0 +1,23 @@
+import { Injector } from '@angular/core';
+import { AbstractControl } from '@angular/forms';
+import { BaseResourceFormGroupComponent } from 'ng-resource-form-util';
+import { Observable } from 'rxjs';
+import { NetworkUtilService } from '../../../../services/network-util.service';
+import { IPBlock } from '../../../../types/k8s-exports';
+import * as i0 from "@angular/core";
+export declare class NetworkPolicyIpBlockFormComponent extends BaseResourceFormGroupComponent<IPBlock> {
+    private readonly networkUtil;
+    cluster: string;
+    cluster$: Observable<string>;
+    networkMode$: Observable<"v4" | "v6" | "dual">;
+    constructor(injector: Injector, networkUtil: NetworkUtilService);
+    createForm(): import("@angular/forms").FormGroup<{
+        cidr: import("@angular/forms").FormControl<string>;
+        except: import("@angular/forms").FormControl<any[]>;
+    }>;
+    asyncValidateCidr(ctrl: AbstractControl): Observable<{
+        cidrPattern: boolean;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NetworkPolicyIpBlockFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NetworkPolicyIpBlockFormComponent, "acl-network-policy-ip-block-form", never, { "cluster": { "alias": "cluster"; "required": true; }; }, {}, never, never, true, never>;
+}

package/lib/features/network-policy/form/network-policy-peer/component.d.ts

@@ -0,0 +1,43 @@
+import { TranslateService, Workspace } from '@alauda-fe/common';
+import { EventEmitter, Injector } from '@angular/core';
+import { BaseResourceFormGroupComponent } from 'ng-resource-form-util';
+import { NetworkPolicyPeer, PolicyType } from '../../../../types/k8s-exports';
+import { NetworkPolicyPeerType } from '../../components/add-peer-rule-handler/component';
+import * as i0 from "@angular/core";
+export declare const getPeerType: (peer: NetworkPolicyPeer) => NetworkPolicyPeerType;
+export declare class NetworkPolicyPeerFormComponent extends BaseResourceFormGroupComponent<NetworkPolicyPeer> {
+    private readonly translate;
+    baseParams: Workspace;
+    policyType: Lowercase<PolicyType>;
+    peer: NetworkPolicyPeer;
+    deletePeer: EventEmitter<void>;
+    labelValidator: {
+        key: typeof import("@alauda-fe/common").k8sResourceLabelKeyValidator;
+        value: import("@angular/forms").ValidatorFn;
+    };
+    labelErrorMapper$: import("rxjs").Observable<{
+        key: {
+            namePattern: string;
+            prefixPattern: string;
+            nameTooLong: string;
+            prefixTooLong: string;
+        };
+        value: {
+            pattern: string;
+            maxlength: string;
+        };
+    }>;
+    getPeerType: (peer: NetworkPolicyPeer) => NetworkPolicyPeerType;
+    constructor(injector: Injector, translate: TranslateService);
+    createForm(): import("@angular/forms").FormGroup<{
+        ipBlock: import("@angular/forms").FormControl<import("../../../../types/k8s-exports").IPBlock>;
+        podSelector: import("@angular/forms").FormGroup<{
+            matchLabels: import("@angular/forms").FormControl<import("@alauda-fe/common").LabelSelector>;
+        }>;
+        namespaceSelector: import("@angular/forms").FormGroup<{
+            matchLabels: import("@angular/forms").FormControl<import("@alauda-fe/common").LabelSelector>;
+        }>;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NetworkPolicyPeerFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NetworkPolicyPeerFormComponent, "acl-network-policy-peer-form", never, { "baseParams": { "alias": "baseParams"; "required": true; }; "policyType": { "alias": "policyType"; "required": true; }; "peer": { "alias": "peer"; "required": true; }; }, { "deletePeer": "deletePeer"; }, never, never, true, never>;
+}

package/lib/features/network-policy/form/network-policy-ports/component.d.ts

@@ -0,0 +1,17 @@
+import { Injector } from '@angular/core';
+import { ControlContainer, FormGroup } from '@angular/forms';
+import { BaseResourceFormArrayComponent, OnFormArrayResizeFn } from 'ng-resource-form-util';
+import { NetworkPolicyPort, PolicyType } from '../../../../types/k8s-exports';
+import * as i0 from "@angular/core";
+export declare class NetworkPolicyPortsFormComponent extends BaseResourceFormArrayComponent<NetworkPolicyPort, NetworkPolicyPort, FormGroup> {
+    readonly controlContainer: ControlContainer;
+    policyType: Lowercase<PolicyType>;
+    PROTOCOLS: readonly ["TCP", "UDP"];
+    constructor(injector: Injector, controlContainer: ControlContainer);
+    getOnFormArrayResizeFn(): OnFormArrayResizeFn;
+    adaptFormModel(formModel: NetworkPolicyPort[]): NetworkPolicyPort[];
+    private createNewPortControl;
+    private portValidator;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NetworkPolicyPortsFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NetworkPolicyPortsFormComponent, "acl-network-policy-ports-form", never, { "policyType": { "alias": "policyType"; "required": true; }; }, {}, never, never, true, never>;
+}

package/lib/features/network-policy/form/network-policy-remote-except-input/component.d.ts

@@ -0,0 +1,23 @@
+import { OnInit } from '@angular/core';
+import { AbstractControl, FormControl } from '@angular/forms';
+import { BaseResourceFormArrayComponent } from 'ng-resource-form-util';
+import { Observable } from 'rxjs';
+import { NetworkMode } from '../../../../utils/cidr-exports';
+import * as i0 from "@angular/core";
+export declare class NetworkPolicyExceptRemoteInputFormComponent extends BaseResourceFormArrayComponent implements OnInit {
+    remoteIpBlock: string;
+    remoteIpBlock$: Observable<string>;
+    networkMode: NetworkMode;
+    networkMode$: Observable<NetworkMode>;
+    ngOnInit(): void;
+    getOnFormArrayResizeFn(): () => FormControl<string>;
+    ipValidator: (ctrl: AbstractControl) => {
+        cidrPattern: boolean;
+    };
+    cidrValidator: (exceptRemoteIp: FormControl) => Observable<{
+        includes: boolean;
+    }>;
+    showRowError(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NetworkPolicyExceptRemoteInputFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NetworkPolicyExceptRemoteInputFormComponent, "acl-network-policy-remote-ip-except-input", never, { "remoteIpBlock": { "alias": "remoteIpBlock"; "required": false; }; "networkMode": { "alias": "networkMode"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/features/network-policy/form/network-policy-rule/component.d.ts

@@ -0,0 +1,28 @@
+import { Workspace } from '@alauda-fe/common';
+import { BaseResourceFormGroupComponent } from 'ng-resource-form-util';
+import { NetworkPolicyEgressRule, NetworkPolicyIngressRule, NetworkPolicyPort, PolicyType } from '../../../../types/k8s-exports';
+import { NetworkPolicyPeerType } from '../../components/add-peer-rule-handler/component';
+import * as i0 from "@angular/core";
+interface NetworkPolicyRuleModel {
+    ports: NetworkPolicyPort[];
+    to?: NetworkPolicyEgressRule[];
+    from?: NetworkPolicyIngressRule[];
+}
+export declare class NetworkPolicyRuleFormComponent extends BaseResourceFormGroupComponent<NetworkPolicyRuleModel> {
+    baseParams: Workspace;
+    policyType: Lowercase<PolicyType>;
+    get direction(): "from" | "to";
+    get peerControls(): import("@angular/forms").AbstractControl<any, any>[];
+    getDefaultFormModel(): NetworkPolicyRuleModel;
+    getOnFormArrayResizeFn(): () => import("@angular/forms").FormControl<{}>;
+    createForm(): import("@angular/forms").FormGroup<{
+        [x: string]: import("@angular/forms").AbstractControl<any[] | import("@angular/forms").FormControlState<any[]>, any[] | import("@angular/forms").FormControlState<any[]>>;
+        ports: import("@angular/forms").FormControl<any[]>;
+    }>;
+    addPeer(type: NetworkPolicyPeerType): void;
+    private getPeerControl;
+    deletePeer(index: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NetworkPolicyRuleFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NetworkPolicyRuleFormComponent, "acl-network-policy-rule-form", never, { "baseParams": { "alias": "baseParams"; "required": true; }; "policyType": { "alias": "policyType"; "required": true; }; }, {}, never, never, true, never>;
+}
+export {};

package/lib/services/alb-api.service.d.ts

@@ -1,16 +1,18 @@
-import { HelmRequest, K8sSharedUtilService, KubernetesResourceList } from '@alauda-fe/common';
+import { HelmRequest, K8sApiService, K8sSharedUtilService, KubernetesResourceList } from '@alauda-fe/common';
 import { HttpClient } from '@angular/common/http';
 import { ALB2, LoadBalancer } from '../types/k8s-exports';
 import * as i0 from "@angular/core";
 export declare class AlbApiService {
     private readonly http;
     private readonly k8sUtil;
-    constructor(http: HttpClient, k8sUtil: K8sSharedUtilService);
+    private readonly k8sApi;
+    constructor(http: HttpClient, k8sUtil: K8sSharedUtilService, k8sApi: K8sApiService);
     getAlbListByProject({ project, cluster }: {
         project: string;
         cluster: string;
     }, queryParams?: Record<string, string>): import("rxjs").Observable<KubernetesResourceList<LoadBalancer>>;
     v1ToV2Beta1(alb: LoadBalancer, hr?: HelmRequest): ALB2;
+    getExceptPortRange(cluster: string): import("rxjs").Observable<string>;
     static ɵfac: i0.ɵɵFactoryDeclaration<AlbApiService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<AlbApiService>;
 }

package/lib/services/network-util.service.d.ts

@@ -1,4 +1,4 @@
-import { K8sApiService, K8sUtilService, Namespace } from '@alauda-fe/common';
+import { K8sApiService, K8sUtilService, Namespace, AuthApiService } from '@alauda-fe/common';
 import { Observable } from 'rxjs';
 import { Subnet } from '../types/k8s-exports';
 import { IPMode, NetworkMode } from '../utils/cidr-exports';
@@ -7,7 +7,8 @@ import * as i0 from "@angular/core";
 export declare class NetworkUtilService {
     private readonly k8sApi;
     private readonly k8sUtil;
-    constructor(k8sApi: K8sApiService, k8sUtil: K8sUtilService);
+    private readonly authApi;
+    constructor(k8sApi: K8sApiService, k8sUtil: K8sUtilService, authApi: AuthApiService);
     /**
      *  集群网络类型，支持 kube-ovn，calico
      *  若 kube-ovn，calico 同时存在，优先判定为 ovn
@@ -15,6 +16,7 @@ export declare class NetworkUtilService {
     getNetworkTypeByCluster$(cluster: string): Observable<ClusterNetworkType>;
     getNetworkMode$(cluster: string): Observable<"v4" | "v6" | "dual">;
     getCalicoCidrs(namespace: Namespace, subnets: Subnet[], networkMode: NetworkMode, enableFixIpV6ForDual?: boolean): string[];
+    getCalicoSubnetNames(namespace: Namespace, networkMode: NetworkMode): string[];
     static ɵfac: i0.ɵɵFactoryDeclaration<NetworkUtilService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<NetworkUtilService>;
 }

package/lib/services/subnet-util.service.d.ts

@@ -0,0 +1,26 @@
+import { DialogService } from '@alauda/ui';
+import { K8sApiService, K8sUtilService, TranslateService, AuthApiService } from '@alauda-fe/common';
+import { HttpClient } from '@angular/common/http';
+import { InterConnectionSubnet, Subnet } from '../types/k8s-exports';
+import { NetworkMode } from '../utils/cidr-exports';
+import { ConflictCidrType } from '../utils/subnet-exports';
+import * as i0 from "@angular/core";
+export declare class SubnetUtilService {
+    private readonly httpClient;
+    private readonly dialog;
+    private readonly translate;
+    private readonly k8sUtil;
+    private readonly k8sApi;
+    private readonly authApi;
+    constructor(httpClient: HttpClient, dialog: DialogService, translate: TranslateService, k8sUtil: K8sUtilService, k8sApi: K8sApiService, authApi: AuthApiService);
+    getClusterNodeIp$(cluster: string): import("rxjs").Observable<string[]>;
+    getTkeClusterCidr$(cluster: string): import("rxjs").Observable<string>;
+    getInterSubnets$(cluster: string): import("rxjs").Observable<InterConnectionSubnet[]>;
+    delete(subnet: Subnet, cluster: string): import("rxjs").Observable<import("@alauda-fe/common").Status>;
+    getUsedCidrBlock(subnets: Subnet[], nodeIps: string[], clusterCidr: string, networkMode: NetworkMode, interSubnets: InterConnectionSubnet[]): {
+        cidr: string;
+        type: ConflictCidrType;
+    }[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<SubnetUtilService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SubnetUtilService>;
+}

package/lib/types/alb-exports.d.ts

@@ -1,3 +1,4 @@
+import { AlbProtocol, KubernetesResource, ServiceGroup } from '@alauda-fe/common';
 import { ResourceLimit } from '../utils/alb-internals';
 export declare enum AlbResourceType {
     ALB = "ALB2",
@@ -27,3 +28,25 @@ export interface AlbResourceLimitModel {
     specModel: SpecModel;
     resourceLimit: ResourceLimit;
 }
+export interface FrontendSpec {
+    port?: number | '';
+    protocol?: AlbProtocol;
+    source?: {
+        name: string;
+        namespace: string;
+        type: string;
+    };
+    backendProtocol?: 'HTTP' | 'HTTPS' | 'gRPC';
+    serviceGroup?: ServiceGroup;
+    certificate_name?: string;
+}
+export interface FrontendStatus {
+    instances: Record<string, {
+        conflict: boolean;
+        probe_time: string;
+    }>;
+}
+export interface Frontend extends KubernetesResource {
+    spec?: FrontendSpec;
+    status?: FrontendStatus;
+}

package/lib/types/k8s-exports.d.ts

@@ -1,4 +1,4 @@
-import { Condition, KubernetesResource, StringMap } from '@alauda-fe/common';
+import { Certificate, Condition, KubernetesResource, LabelSelector, StringMap } from '@alauda-fe/common';
 export declare enum EncapsulateProtocol {
     IPIP = "IPIP",
     VXLAN = "VXLAN",
@@ -35,6 +35,7 @@ export interface SubnetSpec {
     private?: boolean;
     allowSubnets?: string[];
     enableEcmp?: boolean;
+    namespaceSelectors?: LabelSelector[];
     vlan?: string;
 }
 export interface Subnet extends KubernetesResource {
@@ -52,6 +53,15 @@ export interface SubnetIpSpec {
 export interface SubnetIp extends KubernetesResource {
     spec?: SubnetIpSpec;
 }
+export interface InterConnectionSubnet extends KubernetesResource {
+    spec: InterConnectionSubnetSpec;
+}
+export interface InterConnectionSubnetSpec {
+    subnets: Array<{
+        name: string;
+        cidr: string;
+    }>;
+}
 export interface LoadBalancer extends KubernetesResource {
     kind: 'ALB2';
     spec?: LoadBalancerSpec;
@@ -128,3 +138,43 @@ export interface ALB2 extends KubernetesResource {
     spec: ALB2Spec;
     status?: ALB2Status;
 }
+export interface IPBlock {
+    cidr: string;
+    except: string[];
+}
+export interface NetworkPolicyPort {
+    port: number | string;
+    protocol: string;
+    endPort?: number;
+}
+export interface NetworkPolicyPeer {
+    ipBlock?: IPBlock;
+    namespaceSelector?: LabelSelector;
+    podSelector?: LabelSelector;
+}
+export interface NetworkPolicyEgressRule {
+    ports?: NetworkPolicyPort[];
+    to?: NetworkPolicyPeer[];
+}
+export interface NetworkPolicyIngressRule {
+    from?: NetworkPolicyPeer[];
+    ports?: NetworkPolicyPort[];
+}
+export type PolicyType = 'Ingress' | 'Egress';
+export interface NetworkPolicySpec {
+    egress?: NetworkPolicyEgressRule[];
+    ingress?: NetworkPolicyIngressRule[];
+    podSelector?: LabelSelector;
+    policyTypes?: PolicyType[];
+}
+export interface NetworkPolicy extends KubernetesResource {
+    spec?: NetworkPolicySpec;
+}
+export interface DomainSpec {
+    name: string;
+    kind: 'full' | 'extensive';
+}
+export interface Domain extends KubernetesResource {
+    spec?: DomainSpec;
+    _certificate?: Certificate;
+}