cdk8s-plus-31 2.0.0

package/lib/job.js

@@ -0,0 +1,54 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Job = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const cdk8s_1 = require("cdk8s");
+const k8s = require("./imports/k8s");
+const pod = require("./pod");
+const workload = require("./workload");
+/**
+ * A Job creates one or more Pods and ensures that a specified number of them successfully terminate. As pods successfully complete,
+ * the Job tracks the successful completions. When a specified number of successful completions is reached, the task (ie, Job) is complete.
+ * Deleting a Job will clean up the Pods it created. A simple case is to create one Job object in order to reliably run one Pod to completion.
+ * The Job object will start a new Pod if the first Pod fails or is deleted (for example due to a node hardware failure or a node reboot).
+ * You can also use a Job to run multiple Pods in parallel.
+ */
+class Job extends workload.Workload {
+    constructor(scope, id, props = {}) {
+        super(scope, id, {
+            restartPolicy: pod.RestartPolicy.NEVER,
+            select: false,
+            ...props,
+        });
+        this.resourceType = 'jobs';
+        this.apiObject = new k8s.KubeJob(this, 'Resource', {
+            metadata: props.metadata,
+            spec: cdk8s_1.Lazy.any({ produce: () => this._toKube() }),
+        });
+        this.activeDeadline = props.activeDeadline;
+        this.backoffLimit = props.backoffLimit;
+        this.ttlAfterFinished = props.ttlAfterFinished;
+        if (this.isolate) {
+            this.connections.isolate();
+        }
+    }
+    /**
+     * @internal
+     */
+    _toKube() {
+        return {
+            template: {
+                metadata: this.podMetadata.toJson(),
+                spec: this._toPodSpec(),
+            },
+            activeDeadlineSeconds: this.activeDeadline?.toSeconds(),
+            backoffLimit: this.backoffLimit,
+            ttlSecondsAfterFinished: this.ttlAfterFinished ? this.ttlAfterFinished.toSeconds() : undefined,
+        };
+    }
+}
+exports.Job = Job;
+_a = JSII_RTTI_SYMBOL_1;
+Job[_a] = { fqn: "cdk8s-plus-31.Job", version: "2.0.0" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/namespace.d.ts

@@ -0,0 +1,128 @@
+import { ApiObject } from 'cdk8s';
+import { Construct, IConstruct } from 'constructs';
+import * as base from './base';
+import * as k8s from './imports/k8s';
+import * as networkpolicy from './network-policy';
+import * as pod from './pod';
+/**
+ * Configuration for selecting namespaces.
+ */
+export interface NamespaceSelectorConfig {
+    /**
+     * A selector to select namespaces by labels.
+     */
+    readonly labelSelector?: pod.LabelSelector;
+    /**
+     * A list of names to select namespaces by names.
+     */
+    readonly names?: string[];
+}
+/**
+ * Represents an object that can select namespaces.
+ */
+export interface INamespaceSelector extends IConstruct {
+    /**
+     * Return the configuration of this selector.
+     */
+    toNamespaceSelectorConfig(): NamespaceSelectorConfig;
+}
+/**
+ * Properties for `Namespace`.
+ */
+export interface NamespaceProps extends base.ResourceProps {
+}
+/**
+ * In Kubernetes, namespaces provides a mechanism for isolating groups of resources within a single cluster.
+ * Names of resources need to be unique within a namespace, but not across namespaces.
+ * Namespace-based scoping is applicable only for namespaced objects (e.g. Deployments, Services, etc) and
+ * not for cluster-wide objects (e.g. StorageClass, Nodes, PersistentVolumes, etc).
+ */
+export declare class Namespace extends base.Resource implements INamespaceSelector, networkpolicy.INetworkPolicyPeer {
+    /**
+     * @see https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/#automatic-labelling
+     */
+    static readonly NAME_LABEL = "kubernetes.io/metadata.name";
+    /**
+     * @see base.Resource.apiObject
+     */
+    protected readonly apiObject: ApiObject;
+    readonly resourceType: string;
+    private readonly _pods;
+    constructor(scope: Construct, id: string, props?: NamespaceProps);
+    /**
+     * @see INamespaceSelector.toNamespaceSelectorConfig()
+     */
+    toNamespaceSelectorConfig(): NamespaceSelectorConfig;
+    /**
+     * @see INetworkPolicyPeer.toNetworkPolicyPeerConfig()
+     */
+    toNetworkPolicyPeerConfig(): networkpolicy.NetworkPolicyPeerConfig;
+    /**
+     * @see INetworkPolicyPeer.toPodSelector()
+     */
+    toPodSelector(): pod.IPodSelector | undefined;
+    /**
+     * @internal
+     */
+    _toKube(): k8s.NamespaceSpec;
+}
+/**
+ * Options for `Namespaces.select`.
+ */
+export interface NamespacesSelectOptions {
+    /**
+     * Labels the namespaces must have.
+     * This is equivalent to using an 'Is' selector.
+     *
+     * @default - no strict labels requirements.
+     */
+    readonly labels?: {
+        [key: string]: string;
+    };
+    /**
+     * Namespaces must satisfy these selectors.
+     * The selectors query labels, just like the `labels` property, but they
+     * provide a more advanced matching mechanism.
+     *
+     * @default - no selector requirements.
+     */
+    readonly expressions?: pod.LabelExpression[];
+    /**
+     * Namespaces names must be one of these.
+     *
+     * @default - no name requirements.
+     */
+    readonly names?: string[];
+}
+/**
+ * Represents a group of namespaces.
+ */
+export declare class Namespaces extends Construct implements INamespaceSelector, networkpolicy.INetworkPolicyPeer {
+    private readonly expressions?;
+    private readonly names?;
+    private readonly labels?;
+    /**
+     * Select specific namespaces.
+     */
+    static select(scope: Construct, id: string, options: NamespacesSelectOptions): Namespaces;
+    /**
+     * Select all namespaces.
+     */
+    static all(scope: Construct, id: string): Namespaces;
+    private readonly _pods;
+    constructor(scope: Construct, id: string, expressions?: pod.LabelExpression[] | undefined, names?: string[] | undefined, labels?: {
+        [key: string]: string;
+    } | undefined);
+    /**
+     * @see INamespaceSelector.toNamespaceSelectorConfig()
+     */
+    toNamespaceSelectorConfig(): NamespaceSelectorConfig;
+    /**
+     * @see INetworkPolicyPeer.toNetworkPolicyPeerConfig()
+     */
+    toNetworkPolicyPeerConfig(): networkpolicy.NetworkPolicyPeerConfig;
+    /**
+     * @see INetworkPolicyPeer.toPodSelector()
+     */
+    toPodSelector(): pod.IPodSelector | undefined;
+}

package/lib/namespace.js

@@ -0,0 +1,109 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Namespaces = exports.Namespace = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const cdk8s_1 = require("cdk8s");
+const constructs_1 = require("constructs");
+const base = require("./base");
+const k8s = require("./imports/k8s");
+const pod = require("./pod");
+/**
+ * In Kubernetes, namespaces provides a mechanism for isolating groups of resources within a single cluster.
+ * Names of resources need to be unique within a namespace, but not across namespaces.
+ * Namespace-based scoping is applicable only for namespaced objects (e.g. Deployments, Services, etc) and
+ * not for cluster-wide objects (e.g. StorageClass, Nodes, PersistentVolumes, etc).
+ */
+class Namespace extends base.Resource {
+    constructor(scope, id, props = {}) {
+        super(scope, id);
+        this.resourceType = 'namespaces';
+        this.apiObject = new k8s.KubeNamespace(this, 'Resource', {
+            metadata: props.metadata,
+            spec: cdk8s_1.Lazy.any({ produce: () => this._toKube() }),
+        });
+        this._pods = pod.Pods.all(this, 'Pods', {
+            namespaces: Namespaces.select(this, 'Namespaces', { names: [this.name] }),
+        });
+    }
+    /**
+     * @see INamespaceSelector.toNamespaceSelectorConfig()
+     */
+    toNamespaceSelectorConfig() {
+        return { names: [this.name] };
+    }
+    /**
+     * @see INetworkPolicyPeer.toNetworkPolicyPeerConfig()
+     */
+    toNetworkPolicyPeerConfig() {
+        return this._pods.toNetworkPolicyPeerConfig();
+    }
+    /**
+     * @see INetworkPolicyPeer.toPodSelector()
+     */
+    toPodSelector() {
+        return this._pods.toPodSelector();
+    }
+    /**
+     * @internal
+     */
+    _toKube() {
+        return {};
+    }
+}
+exports.Namespace = Namespace;
+_a = JSII_RTTI_SYMBOL_1;
+Namespace[_a] = { fqn: "cdk8s-plus-31.Namespace", version: "2.0.0" };
+/**
+ * @see https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/#automatic-labelling
+ */
+Namespace.NAME_LABEL = 'kubernetes.io/metadata.name';
+/**
+ * Represents a group of namespaces.
+ */
+class Namespaces extends constructs_1.Construct {
+    constructor(scope, id, expressions, names, labels) {
+        super(scope, id);
+        this.expressions = expressions;
+        this.names = names;
+        this.labels = labels;
+        this._pods = pod.Pods.all(this, 'Pods', { namespaces: this });
+    }
+    /**
+     * Select specific namespaces.
+     */
+    static select(scope, id, options) {
+        return new Namespaces(scope, id, options.expressions, options.names, options.labels);
+    }
+    /**
+     * Select all namespaces.
+     */
+    static all(scope, id) {
+        return Namespaces.select(scope, id, { expressions: [], labels: {} });
+    }
+    /**
+     * @see INamespaceSelector.toNamespaceSelectorConfig()
+     */
+    toNamespaceSelectorConfig() {
+        return {
+            labelSelector: pod.LabelSelector.of({ expressions: this.expressions, labels: this.labels }),
+            names: this.names,
+        };
+    }
+    /**
+     * @see INetworkPolicyPeer.toNetworkPolicyPeerConfig()
+     */
+    toNetworkPolicyPeerConfig() {
+        return this._pods.toNetworkPolicyPeerConfig();
+    }
+    /**
+     * @see INetworkPolicyPeer.toPodSelector()
+     */
+    toPodSelector() {
+        return this._pods.toPodSelector();
+    }
+}
+exports.Namespaces = Namespaces;
+_b = JSII_RTTI_SYMBOL_1;
+Namespaces[_b] = { fqn: "cdk8s-plus-31.Namespaces", version: "2.0.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"namespace.js","sourceRoot":"","sources":["../src/namespace.ts"],"names":[],"mappings":"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","sourcesContent":["import { ApiObject, Lazy } from 'cdk8s';\nimport { Construct, IConstruct } from 'constructs';\nimport * as base from './base';\nimport * as k8s from './imports/k8s';\nimport * as networkpolicy from './network-policy';\nimport * as pod from './pod';\n\n/**\n * Configuration for selecting namespaces.\n */\nexport interface NamespaceSelectorConfig {\n\n  /**\n   * A selector to select namespaces by labels.\n   */\n  readonly labelSelector?: pod.LabelSelector;\n\n  /**\n   * A list of names to select namespaces by names.\n   */\n  readonly names?: string[];\n}\n\n/**\n * Represents an object that can select namespaces.\n */\nexport interface INamespaceSelector extends IConstruct {\n  /**\n   * Return the configuration of this selector.\n   */\n  toNamespaceSelectorConfig(): NamespaceSelectorConfig;\n}\n\n/**\n * Properties for `Namespace`.\n */\nexport interface NamespaceProps extends base.ResourceProps {}\n\n/**\n * In Kubernetes, namespaces provides a mechanism for isolating groups of resources within a single cluster.\n * Names of resources need to be unique within a namespace, but not across namespaces.\n * Namespace-based scoping is applicable only for namespaced objects (e.g. Deployments, Services, etc) and\n * not for cluster-wide objects (e.g. StorageClass, Nodes, PersistentVolumes, etc).\n */\nexport class Namespace extends base.Resource implements INamespaceSelector, networkpolicy.INetworkPolicyPeer {\n\n  /**\n   * @see https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/#automatic-labelling\n   */\n  public static readonly NAME_LABEL = 'kubernetes.io/metadata.name';\n\n  /**\n   * @see base.Resource.apiObject\n   */\n  protected readonly apiObject: ApiObject;\n\n  public readonly resourceType: string = 'namespaces';\n\n  private readonly _pods: pod.Pods;\n\n  public constructor(scope: Construct, id: string, props: NamespaceProps = {}) {\n    super(scope, id);\n\n    this.apiObject = new k8s.KubeNamespace(this, 'Resource', {\n      metadata: props.metadata,\n      spec: Lazy.any({ produce: () => this._toKube() }),\n    });\n\n    this._pods = pod.Pods.all(this, 'Pods', {\n      namespaces: Namespaces.select(this, 'Namespaces', { names: [this.name] }),\n    });\n\n  }\n\n  /**\n   * @see INamespaceSelector.toNamespaceSelectorConfig()\n   */\n  public toNamespaceSelectorConfig(): NamespaceSelectorConfig {\n    return { names: [this.name] };\n  }\n\n  /**\n   * @see INetworkPolicyPeer.toNetworkPolicyPeerConfig()\n   */\n  public toNetworkPolicyPeerConfig(): networkpolicy.NetworkPolicyPeerConfig {\n    return this._pods.toNetworkPolicyPeerConfig();\n  }\n\n  /**\n   * @see INetworkPolicyPeer.toPodSelector()\n   */\n  public toPodSelector(): pod.IPodSelector | undefined {\n    return this._pods.toPodSelector();\n  }\n\n  /**\n   * @internal\n   */\n  public _toKube(): k8s.NamespaceSpec {\n    return {};\n  }\n\n}\n\n/**\n * Options for `Namespaces.select`.\n */\nexport interface NamespacesSelectOptions {\n\n  /**\n   * Labels the namespaces must have.\n   * This is equivalent to using an 'Is' selector.\n   *\n   * @default - no strict labels requirements.\n   */\n  readonly labels?: { [key: string]: string };\n\n  /**\n   * Namespaces must satisfy these selectors.\n   * The selectors query labels, just like the `labels` property, but they\n   * provide a more advanced matching mechanism.\n   *\n   * @default - no selector requirements.\n   */\n  readonly expressions?: pod.LabelExpression[];\n\n  /**\n   * Namespaces names must be one of these.\n   *\n   * @default - no name requirements.\n   */\n  readonly names?: string[];\n\n}\n\n/**\n * Represents a group of namespaces.\n */\nexport class Namespaces extends Construct implements INamespaceSelector, networkpolicy.INetworkPolicyPeer {\n\n  /**\n   * Select specific namespaces.\n   */\n  public static select(scope: Construct, id: string, options: NamespacesSelectOptions): Namespaces {\n    return new Namespaces(scope, id, options.expressions, options.names, options.labels);\n  }\n\n  /**\n   * Select all namespaces.\n   */\n  public static all(scope: Construct, id: string): Namespaces {\n    return Namespaces.select(scope, id, { expressions: [], labels: {} });\n  }\n\n  private readonly _pods: pod.Pods;\n\n  constructor(scope: Construct, id: string,\n    private readonly expressions?: pod.LabelExpression[],\n    private readonly names?: string[],\n    private readonly labels?: { [key: string]: string }) {\n    super(scope, id);\n\n    this._pods = pod.Pods.all(this, 'Pods', { namespaces: this });\n  }\n\n  /**\n   * @see INamespaceSelector.toNamespaceSelectorConfig()\n   */\n  public toNamespaceSelectorConfig(): NamespaceSelectorConfig {\n    return {\n      labelSelector: pod.LabelSelector.of({ expressions: this.expressions, labels: this.labels } ),\n      names: this.names,\n    };\n  }\n\n  /**\n   * @see INetworkPolicyPeer.toNetworkPolicyPeerConfig()\n   */\n  public toNetworkPolicyPeerConfig(): networkpolicy.NetworkPolicyPeerConfig {\n    return this._pods.toNetworkPolicyPeerConfig();\n  }\n\n  /**\n   * @see INetworkPolicyPeer.toPodSelector()\n   */\n  public toPodSelector(): pod.IPodSelector | undefined {\n    return this._pods.toPodSelector();\n  }\n\n}\n"]}

package/lib/network-policy.d.ts

@@ -0,0 +1,311 @@
+import { ApiObject } from 'cdk8s';
+import { Construct, IConstruct } from 'constructs';
+import * as base from './base';
+import * as k8s from './imports/k8s';
+import * as pod from './pod';
+/**
+ * Properties for `NetworkPolicyPort`.
+ */
+export interface NetworkPolicyPortProps {
+    /**
+     * Specific port number.
+     *
+     * @default - all ports are allowed.
+     */
+    readonly port?: number;
+    /**
+     * End port (relative to `port`). Only applies if `port` is defined.
+     * Use this to specify a port range, rather that a specific one.
+     *
+     * @default - not a port range.
+     */
+    readonly endPort?: number;
+    /**
+     * Protocol.
+     *
+     * @default NetworkProtocol.TCP
+     */
+    readonly protocol?: NetworkProtocol;
+}
+/**
+ * Describes a port to allow traffic on.
+ */
+export declare class NetworkPolicyPort {
+    private readonly port?;
+    private readonly endPort?;
+    private readonly protocol?;
+    /**
+     * Distinct TCP ports
+     */
+    static tcp(port: number): NetworkPolicyPort;
+    /**
+     * A TCP port range
+     */
+    static tcpRange(startPort: number, endPort: number): NetworkPolicyPort;
+    /**
+     * Any TCP traffic
+     */
+    static allTcp(): NetworkPolicyPort;
+    /**
+     * Distinct UDP ports
+     */
+    static udp(port: number): NetworkPolicyPort;
+    /**
+     * A UDP port range
+     */
+    static udpRange(startPort: number, endPort: number): NetworkPolicyPort;
+    /**
+     * Any UDP traffic
+     */
+    static allUdp(): NetworkPolicyPort;
+    /**
+     * Custom port configuration.
+     */
+    static of(props: NetworkPolicyPortProps): NetworkPolicyPort;
+    private constructor();
+    /**
+     * @internal
+     */
+    _toKube(): k8s.NetworkPolicyPort;
+}
+/**
+ * Configuration for network peers.
+ * A peer can either by an ip block, or a selection of pods, not both.
+ */
+export interface NetworkPolicyPeerConfig {
+    /**
+     * The ip block this peer represents.
+     */
+    readonly ipBlock?: NetworkPolicyIpBlock;
+    /**
+     * The pod selector this peer represents.
+     */
+    readonly podSelector?: pod.PodSelectorConfig;
+}
+/**
+ * Describes a peer to allow traffic to/from.
+ */
+export interface INetworkPolicyPeer extends IConstruct {
+    /**
+     * Return the configuration of this peer.
+     */
+    toNetworkPolicyPeerConfig(): NetworkPolicyPeerConfig;
+    /**
+     * Convert the peer into a pod selector, if possible.
+     */
+    toPodSelector(): pod.IPodSelector | undefined;
+}
+/**
+ * Describes a rule allowing traffic from / to pods matched by a network policy selector.
+ */
+export interface NetworkPolicyRule {
+    /**
+     * The ports of the rule.
+     *
+     * @default - traffic is allowed on all ports.
+     */
+    readonly ports?: NetworkPolicyPort[];
+    /**
+     * Peer this rule interacts with.
+     */
+    readonly peer: INetworkPolicyPeer;
+}
+/**
+ * Describes a particular CIDR (Ex. "192.168.1.1/24","2001:db9::/64") that is
+ * allowed to the pods matched by a network policy selector.
+ * The except entry describes CIDRs that should not be included within this rule.
+ */
+export declare class NetworkPolicyIpBlock extends Construct implements INetworkPolicyPeer {
+    /**
+     * A string representing the IP Block Valid examples are "192.168.1.1/24" or "2001:db9::/64".
+     */
+    readonly cidr: string;
+    /**
+     * A slice of CIDRs that should not be included within an IP Block Valid examples are "192.168.1.1/24" or "2001:db9::/64".
+     * Except values will be rejected if they are outside the CIDR range.
+     */
+    readonly except?: string[] | undefined;
+    /**
+     * Create an IPv4 peer from a CIDR
+     */
+    static ipv4(scope: Construct, id: string, cidrIp: string, except?: string[]): NetworkPolicyIpBlock;
+    /**
+     * Any IPv4 address
+     */
+    static anyIpv4(scope: Construct, id: string): NetworkPolicyIpBlock;
+    /**
+     * Create an IPv6 peer from a CIDR
+     */
+    static ipv6(scope: Construct, id: string, cidrIp: string, except?: string[]): NetworkPolicyIpBlock;
+    /**
+     * Any IPv6 address
+     */
+    static anyIpv6(scope: Construct, id: string): NetworkPolicyIpBlock;
+    private constructor();
+    /**
+     * @see INetworkPolicyPeer.toNetworkPolicyPeerConfig()
+     */
+    toNetworkPolicyPeerConfig(): NetworkPolicyPeerConfig;
+    /**
+     * @see INetworkPolicyPeer.toPodSelector()
+     */
+    toPodSelector(): pod.IPodSelector | undefined;
+    /**
+     * @internal
+     */
+    _toKube(): k8s.IpBlock;
+}
+/**
+ * Network protocols.
+ */
+export declare enum NetworkProtocol {
+    /**
+     * TCP.
+     */
+    TCP = "TCP",
+    /**
+     * UDP.
+     */
+    UDP = "UDP",
+    /**
+     * SCTP.
+     */
+    SCTP = "SCTP"
+}
+/**
+ * Default behaviors of network traffic in policies.
+ */
+export declare enum NetworkPolicyTrafficDefault {
+    /**
+     * The policy denies all traffic.
+     * Since rules are additive, additional rules or policies can allow
+     * specific traffic.
+     */
+    DENY = "DENY",
+    /**
+     * The policy allows all traffic (either ingress or egress).
+     * Since rules are additive, no additional rule or policies can
+     * subsequently deny the traffic.
+     */
+    ALLOW = "ALLOW"
+}
+/**
+ * Describes how the network policy should configure egress / ingress traffic.
+ */
+export interface NetworkPolicyTraffic {
+    /**
+     * Specifies the default behavior of the policy when
+     * no rules are defined.
+     *
+     * @default - unset, the policy does not change the behavior.
+     */
+    readonly default?: NetworkPolicyTrafficDefault;
+    /**
+     * List of rules to be applied to the selected pods.
+     * If empty, the behavior of the policy is dictated by the `default` property.
+     *
+     * @default - no rules
+     */
+    readonly rules?: NetworkPolicyRule[];
+}
+/**
+ * Options for `NetworkPolicy.addEgressRule`.
+ */
+export interface NetworkPolicyAddEgressRuleOptions {
+    /**
+     * Ports the rule should allow outgoing traffic to.
+     *
+     * @default - If the peer is a managed pod, take its ports. Otherwise, all ports are allowed.
+     */
+    readonly ports?: NetworkPolicyPort[];
+}
+/**
+ * Properties for `NetworkPolicy`.
+ */
+export interface NetworkPolicyProps extends base.ResourceProps {
+    /**
+     * Which pods does this policy object applies to.
+     *
+     * This can either be a single pod / workload, or a grouping of pods selected
+     * via the `Pods.select` function. Rules is applied to any pods selected by this property.
+     * Multiple network policies can select the same set of pods.
+     * In this case, the rules for each are combined additively.
+     *
+     * Note that
+     *
+     * @default - will select all pods in the namespace of the policy.
+     */
+    readonly selector?: pod.IPodSelector;
+    /**
+     * Egress traffic configuration.
+     *
+     * @default - the policy doesn't change egress behavior of the pods it selects.
+     */
+    readonly egress?: NetworkPolicyTraffic;
+    /**
+     * Ingress traffic configuration.
+     *
+     * @default - the policy doesn't change ingress behavior of the pods it selects.
+     */
+    readonly ingress?: NetworkPolicyTraffic;
+}
+/**
+ * Control traffic flow at the IP address or port level (OSI layer 3 or 4),
+ * network policies are an application-centric construct which allow you
+ * to specify how a pod is allowed to communicate with various network peers.
+ *
+ * - Outgoing traffic is allowed if there are no network policies selecting
+ *   the pod (and cluster policy otherwise allows the traffic),
+ *   OR if the traffic matches at least one egress rule across all of the
+ *   network policies that select the pod.
+ *
+ * - Incoming traffic is allowed to a pod if there are no network policies
+ *   selecting the pod (and cluster policy otherwise allows the traffic),
+ *   OR if the traffic source is the pod's local node,
+ *   OR if the traffic matches at least one ingress rule across all of
+ *   the network policies that select the pod.
+ *
+ * Network policies do not conflict; they are additive.
+ * If any policy or policies apply to a given pod for a given
+ * direction, the connections allowed in that direction from
+ * that pod is the union of what the applicable policies allow.
+ * Thus, order of evaluation does not affect the policy result.
+ *
+ * For a connection from a source pod to a destination pod to be allowed,
+ * both the egress policy on the source pod and the ingress policy on the
+ * destination pod need to allow the connection.
+ * If either side does not allow the connection, it will not happen.
+ *
+ * @see https://kubernetes.io/docs/concepts/services-networking/network-policies/#networkpolicy-resource
+ */
+export declare class NetworkPolicy extends base.Resource {
+    /**
+     * @see base.Resource.apiObject
+     */
+    protected readonly apiObject: ApiObject;
+    readonly resourceType: string;
+    private readonly _podSelectorConfig;
+    private readonly _egressRules;
+    private readonly _ingressRules;
+    private readonly _policyTypes;
+    constructor(scope: Construct, id: string, props?: NetworkPolicyProps);
+    /**
+     * Allow outgoing traffic to the peer.
+     *
+     * If ports are not passed, traffic will be allowed on all ports.
+     */
+    addEgressRule(peer: INetworkPolicyPeer, ports?: NetworkPolicyPort[]): void;
+    /**
+     * Allow incoming traffic from the peer.
+     *
+     * If ports are not passed, traffic will be allowed on all ports.
+     */
+    addIngressRule(peer: INetworkPolicyPeer, ports?: NetworkPolicyPort[]): void;
+    private createNetworkPolicyPeers;
+    private configureDefaultBehavior;
+    /**
+     * @internal
+     */
+    _toKube(): k8s.NetworkPolicySpec;
+}
+export declare function validatePeerConfig(peerConfig: NetworkPolicyPeerConfig): void;