@alauda-fe/network 1.0.0-beta.0

package/lib/components/loadbalancer-spec-form/component.d.ts

@@ -0,0 +1,34 @@
+import { BaseResourceFormGroupComponent } from 'ng-resource-form-util';
+import { AlbResourceLimitModel, SpecModel } from '../../types/alb-exports';
+import * as i0 from "@angular/core";
+export declare class LoadBalancerSpecFormComponent extends BaseResourceFormGroupComponent<AlbResourceLimitModel> {
+    SpecModel: typeof SpecModel;
+    SPEC_MODEL_TIPS: {
+        model: SpecModel;
+        tip: string;
+    }[];
+    POSITIVE_INT_PATTERN: {
+        pattern: RegExp;
+        tip: string;
+    };
+    createForm(): import("@angular/forms").FormGroup<{
+        specModel: import("@angular/forms").FormControl<SpecModel>;
+        resourceLimit: import("@angular/forms").FormGroup<{
+            cpu: import("@angular/forms").FormGroup<{
+                value: import("@angular/forms").FormControl<number>;
+                unit: import("@angular/forms").FormControl<"core" | "m">;
+            }>;
+            memory: import("@angular/forms").FormGroup<{
+                value: import("@angular/forms").FormControl<number>;
+                unit: import("@angular/forms").FormControl<"Gi" | "Mi">;
+            }>;
+        }>;
+    }>;
+    getDefaultFormModel(): {
+        specModel: SpecModel;
+        resourceLimit: import("../../utils/alb-internals").ResourceLimit;
+    };
+    onSpecModelChange(specModel: SpecModel): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoadBalancerSpecFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LoadBalancerSpecFormComponent, "acl-alb-spec-form", never, {}, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,74 @@
+import { BaseStringMapFormComponent, KeyValueTuple, Locale, StringMap, TranslateKey } from '@alauda-fe/common';
+import { Injector } from '@angular/core';
+import { FormArray, FormControl } from '@angular/forms';
+import { ClusterType } from '../../utils/cluster-exports';
+import * as i0 from "@angular/core";
+declare enum PRODUCT_BASE_HREF_MAP {
+    devops = "/console-devops/",
+    acp = "/console-acp/",
+    asm = "/console-asm/",
+    dataservices = "/console-dataservices/",
+    cec = "/console-cec/",
+    platform = "/console-platform/"
+}
+export interface AnnotationConfigOption {
+    key: string;
+    tip: TranslateKey<Locale>;
+    doc?: {
+        tip: TranslateKey<Locale>;
+        tipPrefix?: TranslateKey<Locale>;
+        path?: string;
+        rawUrl?: string;
+        product?: keyof typeof PRODUCT_BASE_HREF_MAP;
+    };
+    value?: {
+        example: string;
+        tip: TranslateKey<Locale>;
+        docLink: string;
+    };
+    values?: Array<{
+        value: string;
+        tip?: TranslateKey<Locale>;
+    }>;
+}
+export declare const KNOWN_ANNOTATIONS: Partial<Record<ClusterType, {
+    label: string;
+    docLink: string;
+    options: AnnotationConfigOption[];
+}>>;
+export declare class ServiceAnnotationsFormComponent extends BaseStringMapFormComponent {
+    private readonly baseDomain;
+    isUpdate: boolean;
+    clusterType: ClusterType;
+    resourceName: string;
+    private readonly translate;
+    protected readonly baseHref: string;
+    readonly readonlyPartialKeys: string[];
+    annotationsErrorsMapper: import("rxjs").Observable<{
+        key: {
+            namePattern: string;
+            prefixPattern: string;
+            nameTooLong: string;
+            prefixTooLong: string;
+        };
+    }>;
+    KNOWN_ANNOTATIONS: Partial<Record<ClusterType, {
+        label: string;
+        docLink: string;
+        options: AnnotationConfigOption[];
+    }>>;
+    constructor(injector: Injector, baseDomain: string);
+    filterOptions(options: AnnotationConfigOption[] | undefined, index: number): AnnotationConfigOption[];
+    getConfigOption(options: AnnotationConfigOption[] | undefined, key: string): AnnotationConfigOption;
+    isReadonly(key: string): boolean;
+    getDefaultFormModel(): KeyValueTuple[];
+    adaptResourceModel(resource: StringMap): [string, string][];
+    getKeyValidators(): typeof import("@alauda-fe/common").k8sResourceLabelKeyValidator;
+    isLabelReadonly(control: FormArray<FormControl<string>>): boolean;
+    getActiveConfigOption(options: AnnotationConfigOption[] | undefined, key: string): AnnotationConfigOption;
+    onKeySelected(control: FormArray<FormControl<string>>): void;
+    showDocLink(baseHref: string, product?: keyof typeof PRODUCT_BASE_HREF_MAP): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ServiceAnnotationsFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ServiceAnnotationsFormComponent, "acl-service-annotations-form", never, { "isUpdate": { "alias": "isUpdate"; "required": true; }; "clusterType": { "alias": "clusterType"; "required": true; }; "resourceName": { "alias": "resourceName"; "required": true; }; }, {}, never, ["*"], true, never>;
+}
+export {};

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

@@ -0,0 +1,14 @@
+import { StringMap } from '@alauda-fe/common';
+import { BaseResourceFormComponent } from 'ng-resource-form-util';
+import { ClusterType } from '../../utils/cluster-exports';
+import * as i0 from "@angular/core";
+export declare class ServiceAnnotationsFormItemComponent extends BaseResourceFormComponent<StringMap> {
+    isUpdate: boolean;
+    clusterType: ClusterType;
+    inService: boolean;
+    get resourceName(): "annotation" | "service_annotations";
+    isPublicCloud: (clusterType?: string) => boolean;
+    createForm(): import("@angular/forms").FormControl<{}>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ServiceAnnotationsFormItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ServiceAnnotationsFormItemComponent, "acl-service-annotations-form-item", never, { "isUpdate": { "alias": "isUpdate"; "required": true; }; "clusterType": { "alias": "clusterType"; "required": true; }; "inService": { "alias": "inService"; "required": false; }; }, {}, never, ["*"], true, never>;
+}

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

@@ -0,0 +1,56 @@
+import { ContainerPort, FeatureGateService, K8sUtilService, Service } from '@alauda-fe/common';
+import { AfterViewInit, Injector } from '@angular/core';
+import { BaseResourceFormGroupComponent } from 'ng-resource-form-util';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+interface ServiceFormModel extends Service {
+    virtualIp?: boolean;
+    sessionPersistence?: boolean;
+}
+export declare class K8sServiceFormComponent extends BaseResourceFormGroupComponent<Service, ServiceFormModel> implements AfterViewInit {
+    private readonly k8sUtil;
+    private readonly featureGate;
+    cluster: string;
+    cluster$: Observable<string>;
+    isUpdate: boolean;
+    isUpdate$: Observable<boolean>;
+    containerPortSuggestions: ContainerPort[];
+    targetComponent: 'workload' | 'vm' | 'label-selectors';
+    K8S_RESOURCE_NAME_START_WITH_CHARS_ONLY: {
+        pattern: RegExp;
+        tip: string;
+    };
+    DOMAIN_PATTERN: {
+        pattern: RegExp;
+        placeholder: string;
+        tip: string;
+    };
+    displayNameKey: string;
+    isLbEnabled$: Observable<boolean>;
+    types$: Observable<readonly ["ClusterIP", "NodePort", "LoadBalancer", "ExternalName"] | ("ClusterIP" | "NodePort" | "LoadBalancer" | "ExternalName")[]>;
+    constructor(injector: Injector, k8sUtil: K8sUtilService, featureGate: FeatureGateService);
+    ngAfterViewInit(): void;
+    getDefaultFormModel(): ServiceFormModel;
+    createForm(): import("@angular/forms").FormGroup<{
+        virtualIp: import("@angular/forms").FormControl<boolean>;
+        sessionPersistence: import("@angular/forms").FormControl<boolean>;
+        metadata: import("@angular/forms").FormGroup<{
+            name: import("@angular/forms").FormControl<string>;
+            labels: import("@angular/forms").FormControl<{}>;
+            annotations: import("@angular/forms").FormGroup<{
+                [x: string]: import("@angular/forms").FormControl<string>;
+            }>;
+        }>;
+        spec: import("@angular/forms").FormGroup<{
+            type: import("@angular/forms").FormControl<string>;
+            ports: import("@angular/forms").FormControl<unknown>;
+            externalName: import("@angular/forms").FormControl<string>;
+        }>;
+    }>;
+    adaptFormModel({ virtualIp, sessionPersistence, ...resource }: ServiceFormModel): Service;
+    adaptResourceModel(resource: Service): ServiceFormModel;
+    onVirtualIpChange(virtualIp: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<K8sServiceFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<K8sServiceFormComponent, "acl-k8s-service-form", never, { "cluster": { "alias": "cluster"; "required": true; }; "isUpdate": { "alias": "isUpdate"; "required": false; }; "containerPortSuggestions": { "alias": "containerPortSuggestions"; "required": true; }; "targetComponent": { "alias": "targetComponent"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+export {};

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

@@ -0,0 +1,46 @@
+import { ContainerPort, ServicePort, ServicePortProtocol, ServiceType, ValidateRowDuplicateService } from '@alauda-fe/common';
+import { Injector, OnInit } from '@angular/core';
+import { AbstractControl, ControlContainer, FormGroup } from '@angular/forms';
+import { BaseResourceFormArrayComponent } from 'ng-resource-form-util';
+import * as i0 from "@angular/core";
+export declare class ServicePortsFieldsetComponent extends BaseResourceFormArrayComponent<ServicePort> implements OnInit {
+    injector: Injector;
+    readonly controlContainer: ControlContainer;
+    private readonly rowDupService;
+    _required: boolean;
+    get required(): boolean | '';
+    set required(required: boolean | '');
+    serviceType: ServiceType;
+    containerPortSuggestions: ContainerPort[];
+    existedPorts: ServicePort[];
+    targetComponent: 'workload' | 'vm' | 'label-selectors';
+    constructor(injector: Injector, controlContainer: ControlContainer, rowDupService: ValidateRowDuplicateService);
+    servicePortProtocols: readonly ["TCP", "UDP", "HTTP", "HTTPS", "HTTP2", "gRPC"];
+    namePattern: {
+        pattern: RegExp;
+        tip: string;
+    };
+    ngOnInit(): void;
+    getOnFormArrayResizeFn(): () => FormGroup<{
+        name: import("@angular/forms").FormControl<string>;
+        protocol: import("@angular/forms").FormControl<"TCP">;
+        appProtocol: import("@angular/forms").FormControl<string>;
+        port: import("@angular/forms").FormControl<string>;
+        targetPort: import("@angular/forms").FormControl<string>;
+    }>;
+    getResourceMergeStrategy(): boolean;
+    private createNewControl;
+    validateServiceType(_ctrl?: AbstractControl): {
+        protocol: boolean;
+    };
+    adaptResourceModel(ports: ServicePort[]): ServicePort[];
+    adaptFormModel(ports: ServicePort[]): ServicePort[];
+    updateAppProtocol(group: FormGroup): void;
+    updateValueAndValidity(): void;
+    getContainerPortSuggestions(containerPortSuggestions: ContainerPort[], appProtocol: Lowercase<ServicePortProtocol>): ContainerPort[];
+    updateContainerPort(control: AbstractControl, value: string): void;
+    autoCompleteContainerPort(control: AbstractControl, value: number): void;
+    getContainerPortTranslateKey(targetComponent: 'vm' | 'workload' | 'label-selectors'): "vm_port" | "container_port";
+    static ɵfac: i0.ɵɵFactoryDeclaration<ServicePortsFieldsetComponent, [null, { optional: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ServicePortsFieldsetComponent, "acl-service-ports-fieldset", never, { "required": { "alias": "required"; "required": false; }; "serviceType": { "alias": "serviceType"; "required": false; }; "containerPortSuggestions": { "alias": "containerPortSuggestions"; "required": false; }; "existedPorts": { "alias": "existedPorts"; "required": false; }; "targetComponent": { "alias": "targetComponent"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/directives/subnet-validator.directive.d.ts

@@ -0,0 +1,34 @@
+import { AbstractControl, Validator } from '@angular/forms';
+import { IPMode } from '../utils/cidr-exports';
+import * as i0 from "@angular/core";
+export declare class CidrIpDirective implements Validator {
+    info?: {
+        ipMode: IPMode;
+        segment: string;
+    };
+    control: AbstractControl;
+    validate(control: AbstractControl): {
+        pattern: boolean;
+        ipNotInCidr?: undefined;
+    } | {
+        ipNotInCidr: string;
+        pattern?: undefined;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<CidrIpDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CidrIpDirective, "[rcCidrIp]", never, { "info": { "alias": "rcCidrIp"; "required": false; }; }, {}, never, never, true, never>;
+}
+export declare class CidrScaleSubnetDirective implements Validator {
+    info?: {
+        ipMode: IPMode;
+        segment: string;
+    };
+    validate(control: AbstractControl): {
+        pattern: boolean;
+        cidrContain?: undefined;
+    } | {
+        cidrContain: string;
+        pattern?: undefined;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<CidrScaleSubnetDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CidrScaleSubnetDirective, "[rcCidrScaleSubnet]", never, { "info": { "alias": "rcCidrScaleSubnet"; "required": false; }; }, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,16 @@
+import { HelmRequest, 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);
+    getAlbListByProject({ project, cluster }: {
+        project: string;
+        cluster: string;
+    }, queryParams?: Record<string, string>): import("rxjs").Observable<KubernetesResourceList<LoadBalancer>>;
+    v1ToV2Beta1(alb: LoadBalancer, hr?: HelmRequest): ALB2;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlbApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AlbApiService>;
+}

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

@@ -0,0 +1,38 @@
+import { FeatureGateService, K8sApiService, KubernetesResourceList, Certificate, ResourceType, Secret, K8sUtilService } from '@alauda-fe/common';
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class CertificateApiService {
+    private readonly http;
+    private readonly k8sApi;
+    private readonly k8sUtil;
+    private readonly featureGate;
+    private readonly globalNamespace;
+    private globalClusterInfo$;
+    isGlobalSecretEnabled$: Observable<boolean>;
+    constructor(http: HttpClient, k8sApi: K8sApiService<ResourceType>, k8sUtil: K8sUtilService, featureGate: FeatureGateService, globalNamespace: string);
+    getCertificatesAndSecrets(params$: Observable<{
+        cluster?: string;
+        namespace?: string;
+        project?: string;
+    }>, extraGlobalSecretEnabled$?: Observable<boolean>): Observable<Secret<import("@alauda-fe/common").StringMap>[]>;
+    getCertificates(names: string[], { cluster, namespace, }?: {
+        cluster?: string;
+        namespace?: string;
+    }): Observable<Certificate[]>;
+    getCertificate(name: string, params?: {
+        cluster: string;
+        namespace: string;
+    }): Observable<Certificate>;
+    normalizeCertificates(original: Secret, params?: {
+        cluster: string;
+        namespace: string;
+    }): Observable<Secret>;
+    normalizeCertificates(original: KubernetesResourceList<Secret>, params?: {
+        cluster: string;
+        namespace: string;
+    }): Observable<KubernetesResourceList<Secret>>;
+    private getGlobalClusterInfo;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CertificateApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CertificateApiService>;
+}

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

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

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

@@ -0,0 +1,29 @@
+import { ResourceLimit } from '../utils/alb-internals';
+export declare enum AlbResourceType {
+    ALB = "ALB2",
+    FRONTEND = "Frontend",
+    RULE = "Rule"
+}
+export interface PortRangeItem {
+    port: string;
+    projects: string[];
+    usedPorts?: number[];
+}
+export interface PlainResourceLimit {
+    cpu?: string;
+    memory?: string;
+}
+export interface AlbResources {
+    limits?: PlainResourceLimit;
+    requests?: PlainResourceLimit;
+}
+export declare enum SpecModel {
+    SMALL = "small",
+    MEDIUM = "medium",
+    LARGE = "large",
+    CUSTOMIZE = "customize"
+}
+export interface AlbResourceLimitModel {
+    specModel: SpecModel;
+    resourceLimit: ResourceLimit;
+}

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

@@ -0,0 +1,130 @@
+import { Condition, KubernetesResource, StringMap } from '@alauda-fe/common';
+export declare enum EncapsulateProtocol {
+    IPIP = "IPIP",
+    VXLAN = "VXLAN",
+    NEVER = "NEVER"
+}
+export declare enum EncapsulateMode {
+    ALWAYS = "Always",
+    CROSS_SUBNET = "CrossSubnet",
+    NEVER = "Never"
+}
+export interface SubnetStatus {
+    usingIPs?: number;
+    availableIPs?: number;
+    v4usingIPs?: number;
+    v4availableIPs?: number;
+    v6usingIPs?: number;
+    v6availableIPs?: number;
+}
+export interface SubnetSpec {
+    default: boolean;
+    protocol: 'IPv4' | 'IPv6' | 'Dual';
+    namespaces?: string[];
+    cidrBlock: string;
+    natOutgoing?: boolean;
+    ipipMode?: EncapsulateMode;
+    vxlanMode?: EncapsulateMode;
+    blockSize?: number;
+    v4blockSize?: number;
+    v6blockSize?: number;
+    gateway: string;
+    excludeIps: string[];
+    gatewayType: string;
+    gatewayNode?: string;
+    private?: boolean;
+    allowSubnets?: string[];
+    enableEcmp?: boolean;
+    vlan?: string;
+}
+export interface Subnet extends KubernetesResource {
+    spec?: SubnetSpec;
+    status?: SubnetStatus;
+}
+export interface SubnetIpSpec {
+    podName: string;
+    namespace: string;
+    subnet: string;
+    nodeName: string;
+    ipAddress?: string;
+    macAddress: string;
+}
+export interface SubnetIp extends KubernetesResource {
+    spec?: SubnetIpSpec;
+}
+export interface LoadBalancer extends KubernetesResource {
+    kind: 'ALB2';
+    spec?: LoadBalancerSpec;
+    status?: LoadBalancerStatus;
+}
+export interface LoadBalancerStatus {
+    probeTime: string;
+    reason: string;
+    state: 'ready' | 'warning';
+}
+export interface LoadBalancerSpec {
+    address: string;
+    bind_address: string;
+    domains: string[];
+    iaas_id: string;
+    type: 'nginx';
+}
+export interface ALB2Status extends Condition {
+    detail?: {
+        address: {
+            host: string[];
+            ipv4: string[];
+            ipv6: string[];
+            msg?: string;
+            ok?: boolean;
+        };
+        alb?: StringMap;
+        version?: {
+            imagePatch: string;
+            version: string;
+        };
+    };
+}
+export interface ALB2Spec {
+    address?: string;
+    config: {
+        enableAlb?: boolean;
+        vip?: {
+            enableLbSvc: boolean;
+            lbSvcAnnotations?: StringMap;
+        };
+        displayName?: string;
+        networkMode: 'host' | 'container';
+        enablePortProject?: boolean;
+        /**
+        Array<{
+          port: string;
+          projects: string[];
+        }>
+        */
+        portProjects?: string;
+        nodeSelector?: StringMap;
+        projects?: string[];
+        replicas?: number;
+        resources?: {
+            limits?: {
+                cpu: string;
+                memory: string;
+            };
+            requests?: {
+                cpu: string;
+                memory: string;
+            };
+        };
+        gateway?: {
+            mode: 'standalone' | 'share';
+            name: string;
+        };
+    };
+    type: 'nginx';
+}
+export interface ALB2 extends KubernetesResource {
+    kind: 'ALB2';
+    spec: ALB2Spec;
+    status?: ALB2Status;
+}

package/lib/types/resource-definition.d.ts

@@ -0,0 +1,25 @@
+export declare const KUBE_OVN_GROUP = "kubeovn.io";
+export declare const NetworkResourceDefinitions: {
+    readonly SUBNET_KUBE_OVN: {
+        readonly type: "subnets";
+        readonly apiGroup: "kubeovn.io";
+    };
+    readonly SUBNET_KUBE_OVN_IP: {
+        readonly type: "ips";
+        readonly apiGroup: "kubeovn.io";
+    };
+};
+export declare const NETWORK_RESOURCE_DEFINITIONS: {
+    readonly SUBNET_KUBE_OVN: {
+        readonly type: "subnets";
+        readonly apiGroup: "kubeovn.io";
+    };
+    readonly SUBNET_KUBE_OVN_IP: {
+        readonly type: "ips";
+        readonly apiGroup: "kubeovn.io";
+    };
+};
+export declare const NETWORK_RESOURCE_TYPES: {
+    readonly SUBNET_KUBE_OVN: "SUBNET_KUBE_OVN";
+    readonly SUBNET_KUBE_OVN_IP: "SUBNET_KUBE_OVN_IP";
+};

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

@@ -0,0 +1,16 @@
+import { LooseValueOf } from '@alauda-fe/common';
+import { PlainResourceLimit, SpecModel, AlbResourceLimitModel } from '../types/alb-exports';
+import { ALB2 } from '../types/k8s-exports';
+import { ResourceLimit } from './alb-internals';
+export declare const formatResourceLimit: ({ value, unit, }: LooseValueOf<ResourceLimit>) => string;
+export declare const parseResourceLimit: (plainResourceLimit?: PlainResourceLimit) => {
+    specModel: SpecModel;
+    resourceLimit: PlainResourceLimit;
+};
+export declare const RESOURCE_LIMIT_MAPPER: Partial<Record<SpecModel, ResourceLimit>>;
+export declare function getResourceLimit(resource: ALB2): AlbResourceLimitModel;
+export declare const METALLB = "metallb";
+export declare const METALLB_NS: "metallb-system";
+export declare function parseAddresses(alb2: ALB2): string[];
+export declare function getAddressPriority(address: string): 0 | 1 | 2;
+export declare function sortAddressesByPriority(addresses: string[]): string[];

package/lib/utils/alb-internals.d.ts

@@ -0,0 +1,10 @@
+export interface ResourceLimit {
+    cpu: {
+        value: number;
+        unit: 'core' | 'm';
+    };
+    memory: {
+        value: number;
+        unit: 'Gi' | 'Mi';
+    };
+}

package/lib/utils/cidr-exports.d.ts

@@ -0,0 +1,85 @@
+import { ValueOf } from '@alauda-fe/common';
+import { Address4, Address6 } from 'ip-address';
+interface SegmentModel {
+    ipV4Segment?: string;
+    ipV6Segment?: string;
+}
+/**
+ * note: we don't use enum here because ts do not support extends enum for now
+ * @link https://github.com/microsoft/TypeScript/issues/17592
+ */
+export declare const IPMode: {
+    readonly IPV4: "v4";
+    readonly IPV6: "v6";
+};
+export type IPMode = ValueOf<typeof IPMode>;
+export declare const AddressTypes: {
+    readonly ADVERTISE: "Advertise";
+    readonly PUBLIC: "Public";
+};
+export type AddressTypes = ValueOf<typeof AddressTypes>;
+export declare const IP_MODES: readonly ["v4", "v6"];
+export declare const IP_MODE_TEXTS: {
+    readonly v4: "IPv4";
+    readonly v6: "IPv6";
+};
+export declare const NetworkMode: {
+    readonly DUAL: "dual";
+    readonly IPV4: "v4";
+    readonly IPV6: "v6";
+};
+export type NetworkMode = ValueOf<typeof NetworkMode>;
+/**
+ * @param {string} cidrStr cidrBlock, e.g. 10.16.0.0/24 may support ipv6
+ * @param {string} ipStr specific ip, e.g. 10.16.1.2 may support ipv6
+ * @param {IPMode} ipMode ip network mode ipv4/ipv6
+ * @return {boolean} whether ip belongs to cidr
+ */
+export declare function isBelongCidr(cidrStr: string, ipStr: string, ipMode?: IPMode): boolean;
+/**
+ * @param {string} ip specific ip, e.g. 10.16.1.2
+ * @param {string} cidr specific cidr which ip may belongs to, e.g. 10.16.0.0/24
+ * @return {boolean} whether ip is broadcast address
+ */
+export declare function isBroadcastAddr(ipStr: string, cidrStr?: string, ipMode?: IPMode): boolean;
+export declare function isLoopback(ipStr: string, ipMode?: IPMode): boolean;
+export declare function isMultiBroadcast(ipStr: string, ipMode?: IPMode): boolean;
+export declare function isLinkLocal(ipStr: string, ipMode?: IPMode): boolean;
+export declare function isAllZero(ipStr: string, ipMode?: IPMode): boolean;
+export declare function isNetworkAddr(ipStr: string, cidrStr?: string, ipMode?: IPMode): boolean;
+/**
+ * @param {string} cidrAStr cidrBlock A, e.g. 10.16.0.0/24. support IPv6
+ * @param {string} cidrBStr cidrBlock B, e.g. 10.10.0.0/16. support IPv6
+ * @param {IPMode} ipMode ipMode, v4 or v6
+ * @return {boolean} whether 2 cidr blocks may conflict, judge by whether ip belongs to cidrBlock A may also belongs to B
+ */
+export declare function isCidrConflict(cidrAStr: string, cidrBStr: string, ipMode?: IPMode): boolean;
+export declare function isCidrContain(cidrAStr: string, cidrBStr: string, ipMode?: IPMode): boolean;
+export declare function getAddressBuilder(ipMode: IPMode): typeof Address6 | typeof Address4;
+export declare const parseCIDR: (address: string, ipMode?: IPMode) => Address6 | Address4;
+export declare function ipAddressEqual(ipAStr: string, ipBStr: string, ipMode?: IPMode): boolean;
+export declare function isIpAddressValid(address: string, ipMode?: IPMode): boolean;
+export declare function isCidrAddressValid(address: string, ipMode?: IPMode): boolean;
+export declare function getCidrType(ip: string): "v4" | "v6";
+export declare function isIpv4(value: string): boolean;
+export declare function isIpv6(value: string): boolean;
+export declare function ipAddress(value: string): string;
+export declare function getStrictCidr(cidrStr: string, ipMode: IPMode): string;
+export declare const parseSegment: (segment?: string, networkMode?: NetworkMode) => SegmentModel;
+export declare function getCidrBlock(segment: string, networkType?: NetworkMode): string;
+export declare function getCidrBlock({ ipV4Segment, ipV6Segment, }: SegmentModel): string;
+export declare const DEFAULT_IPV4_MAX_CIDR_PREFIX = 31;
+export declare const DEFAULT_IPV6_MAX_CIDR_PREFIX = 127;
+export declare const DEFAULT_NETWORK_CIDR_PREFIX_MAPPER: {
+    readonly v4: 31;
+    readonly v6: 127;
+};
+export declare function getCidrMaximumPrefix(ipMode?: IPMode): 31 | 127;
+export declare const adaptIpMode: (value: string, networkMode: NetworkMode) => "v4" | "v6";
+export declare const isIpPartValid: (part: string, isIpV4: boolean) => boolean;
+export declare const isIpPartsValid: (parts: string[], isIpV4: boolean) => boolean;
+export declare const isIpInputValid: (input: string, isIpV4: boolean) => boolean;
+export declare const getIpAddressSuggestionsByCidrs: (cidrs: string[], networkMode: NetworkMode, usedIps: string[], inputValue: string, isCalico: boolean, maxSize?: number) => string[];
+export declare function adaptSubnetCidrs(cidrs: string, networkMode: NetworkMode, enableFixIpV6ForDual?: boolean): string[];
+export declare function invalidIpOrder<T extends Address4 | Address6>(ipBegin: T, ipEnd: T): boolean;
+export {};

package/lib/utils/cluster-exports.d.ts

@@ -0,0 +1,14 @@
+export declare enum ClusterType {
+    Baremetal = "Baremetal",
+    Imported = "Imported",
+    OCP = "OCP",
+    AlibabaCloudACKDedicated = "AlibabaCloudACKDedicated",
+    AlibabaCloudACKManaged = "AlibabaCloudACKManaged",
+    AmazonEKS = "AmazonEKS",
+    AzureAKS = "AzureAKS",
+    GoogleCloudGKE = "GoogleCloudGKE",
+    HuaweiCloudCCE = "HuaweiCloudCCE",
+    TencentTKEManaged = "TencentTKEManaged",
+    TencentTKESelfDeployed = "TencentTKESelfDeployed"
+}
+export declare const isPublicCloud: (clusterType?: string) => boolean;