@highstate/k8s 0.4.5

package/dist/index.d.ts

@@ -0,0 +1,676 @@
+import { k8s } from '@highstate/library';
+import { Input, Unwrap, Output, InputArray, ComponentResource, ComponentResourceOptions, Resource, ResourceOptions, InputMap } from '@highstate/pulumi';
+import { Provider, core, types, apps, batch, helm } from '@pulumi/kubernetes';
+import { gateway, types as types$1 } from '@highstate/gateway-api';
+import { PartialKeys, RequiredKeys } from '@highstate/contract';
+import { DnsRecord } from '@highstate/common';
+import { Input as Input$1, ComponentResource as ComponentResource$1, Output as Output$1, ComponentResourceOptions as ComponentResourceOptions$1 } from '@pulumi/pulumi';
+
+declare function createProvider(cluster: Input<k8s.Cluster>): Promise<Provider>;
+declare function createNamespace(name: string, provider: Provider, args?: core.v1.NamespaceArgs): core.v1.Namespace;
+type NamespaceLike = core.v1.Namespace | string;
+type CommonArgs = {
+    /**
+     * The name of the resource.
+     */
+    name?: string;
+    /**
+     * The namespace to create the resource in.
+     */
+    namespace?: Input<NamespaceLike>;
+    /**
+     * The metadata to apply to the resource.
+     */
+    metadata?: Input<types.input.meta.v1.ObjectMeta>;
+};
+declare function mapMetadata(args: Unwrap<CommonArgs>, fallbackName?: string): types.input.meta.v1.ObjectMeta;
+declare function resolveChartPath(packageName: string, chartName: string, parent: string): string;
+type SelectorLike = types.input.meta.v1.LabelSelector | Record<string, Input<string>>;
+declare function mapSelectorLikeToSelector(selector: SelectorLike): types.input.meta.v1.LabelSelector;
+declare function mapNamespaceLikeToNamespaceName(namespace: NamespaceLike): Output<string>;
+declare function mapNamespaceNameToSelector(namespace: Input<string>): types.input.meta.v1.LabelSelector;
+
+interface FullBackendRef {
+    /**
+     * The name of the resource being referenced.
+     */
+    name: Input<string>;
+    /**
+     * The namespace of the resource being referenced.
+     * May be undefined if the resource is not in a namespace.
+     */
+    namespace?: Input<string | undefined>;
+    /**
+     * The port of the resource being referenced.
+     */
+    port: Input<number>;
+}
+interface ServiceBackendRef {
+    /**
+     * The name of the service being referenced.
+     */
+    service: Input<core.v1.Service>;
+    /**
+     * The port of the service being referenced.
+     */
+    port: Input<number> | Input<string>;
+}
+type BackendRef = FullBackendRef | ServiceBackendRef | core.v1.Service;
+
+type HttpRouteArgs = Omit<CommonArgs, "namespace"> & {
+    /**
+     * The gateway to associate with the route.
+     */
+    gateway: Input<gateway.v1.Gateway>;
+    /**
+     * The alias for `hostnames: [hostname]`.
+     */
+    hostname?: Input<string>;
+    /**
+     * The rule of the route.
+     */
+    rule?: Input<HttpRouteRuleArgs>;
+    /**
+     * The rules of the route.
+     */
+    rules?: InputArray<HttpRouteRuleArgs>;
+} & Omit<Partial<types$1.input.gateway.v1.HTTPRouteSpec>, "rules">;
+type HttpRouteRuleArgs = Omit<types$1.input.gateway.v1.HTTPRouteSpecRules, "matches" | "filters" | "backendRefs"> & {
+    /**
+     * The conditions of the rule.
+     * Can be specified as string to match on the path.
+     */
+    matches?: InputArray<HttpRouteRuleMatchOptions>;
+    /**
+     * The condition of the rule.
+     * Can be specified as string to match on the path.
+     */
+    match?: Input<HttpRouteRuleMatchOptions>;
+    /**
+     * The filters of the rule.
+     */
+    filters?: InputArray<types$1.input.gateway.v1.HTTPRouteSpecRulesFilters>;
+    /**
+     * The filter of the rule.
+     */
+    filter?: Input<types$1.input.gateway.v1.HTTPRouteSpecRulesFilters>;
+    /**
+     * The service to route to.
+     */
+    backend?: Input<BackendRef>;
+};
+type HttpRouteRuleMatchOptions = types$1.input.gateway.v1.HTTPRouteSpecRulesMatches | string;
+declare class HttpRoute extends ComponentResource {
+    /**
+     * The underlying Kubernetes resource.
+     */
+    readonly route: Output<gateway.v1.HTTPRoute>;
+    constructor(name: string, args: HttpRouteArgs, opts?: ComponentResourceOptions);
+}
+
+type ServiceArgs = CommonArgs & {
+    port?: Input<types.input.core.v1.ServicePort>;
+} & types.input.core.v1.ServiceSpec;
+declare class Service extends ComponentResource {
+    /**
+     * The underlying Kubernetes service.
+     */
+    readonly service: Output<core.v1.Service>;
+    constructor(name: string, args: ServiceArgs, opts?: ComponentResourceOptions);
+}
+declare function mapContainerPortToServicePort(port: types.input.core.v1.ContainerPort): types.input.core.v1.ServicePort;
+declare function mapServiceToLabelSelector(service: core.v1.Service): types.input.meta.v1.LabelSelector;
+declare function getServiceHost(service: core.v1.Service): Output<string>;
+
+type Container = Omit<PartialKeys<types.input.core.v1.Container, "name">, "volumeMounts"> & {
+    /**
+     * The single port to add to the container.
+     */
+    port?: Input<types.input.core.v1.ContainerPort>;
+    /**
+     * The volume mount to attach to the container.
+     */
+    volumeMount?: Input<ContainerVolumeMount>;
+    /**
+     * The volume mounts to attach to the container.
+     */
+    volumeMounts?: InputArray<ContainerVolumeMount>;
+    /**
+     * The volume to include in the parent workload.
+     * It is like the `volumes` property, but defined at the container level.
+     * It will be defined as a volume mount in the parent workload automatically.
+     */
+    volume?: Input<WorkloadVolume>;
+    /**
+     * The volumes to include in the parent workload.
+     * It is like the `volumes` property, but defined at the container level.
+     * It will be defined as a volume mount in the parent workload automatically.
+     */
+    volumes?: InputArray<WorkloadVolume>;
+    /**
+     * The map of environment variables to set in the container.
+     * It is like the `env` property, but more convenient to use.
+     */
+    environment?: Input<ContainerEnvironment>;
+    /**
+     * The source of environment variables to set in the container.
+     * It is like the `envFrom` property, but more convenient to use.
+     */
+    environmentSource?: Input<ContainerEnvironmentSource>;
+    /**
+     * The sources of environment variables to set in the container.
+     * It is like the `envFrom` property, but more convenient to use.
+     */
+    environmentSources?: InputArray<ContainerEnvironmentSource>;
+};
+type ContainerEnvironment = Record<string, Input<string | undefined | null | ContainerEnvironmentVariable>>;
+type ContainerEnvironmentVariable = types.input.core.v1.EnvVarSource | {
+    /**
+     * The secret to select from.
+     */
+    secret: Input<core.v1.Secret>;
+    /**
+     * The key of the secret to select from.
+     */
+    key: string;
+} | {
+    /**
+     * The config map to select from.
+     */
+    configMap: Input<core.v1.ConfigMap>;
+    /**
+     * The key of the config map to select from.
+     */
+    key: string;
+};
+type ContainerEnvironmentSource = types.input.core.v1.EnvFromSource | core.v1.ConfigMap | core.v1.Secret;
+type ContainerVolumeMount = types.input.core.v1.VolumeMount | (Omit<types.input.core.v1.VolumeMount, "name"> & {
+    /**
+     * The volume to mount.
+     */
+    volume: Input<WorkloadVolume>;
+});
+type WorkloadVolume = types.input.core.v1.Volume | core.v1.PersistentVolumeClaim | core.v1.ConfigMap | core.v1.Secret;
+
+type DeploymentArgs = CommonArgs & {
+    container?: Input<Container>;
+    containers?: InputArray<Container>;
+    gateway?: Input<gateway.v1.Gateway>;
+    service?: Input<ServiceArgs>;
+    httpRoute?: Input<HttpRouteArgs>;
+} & Omit<Partial<types.input.apps.v1.DeploymentSpec>, "template"> & {
+    template?: {
+        metadata?: types.input.meta.v1.ObjectMeta;
+        spec?: Partial<types.input.core.v1.PodSpec>;
+    };
+};
+declare class Deployment extends ComponentResource {
+    /**
+     * The underlying Kubernetes deployment.
+     */
+    readonly deployment: Output<apps.v1.Deployment>;
+    /**
+     * The service associated with the deployment.
+     */
+    readonly service: Output<Service | undefined>;
+    /**
+     * The HTTP route associated with the deployment.
+     */
+    readonly httpRoute: Output<HttpRoute | undefined>;
+    constructor(name: string, args: DeploymentArgs, opts?: ComponentResourceOptions);
+    getRequiredService(): Output<Service>;
+}
+
+type PersistentVolumeClaimArgs = CommonArgs & types.input.core.v1.PersistentVolumeClaimSpec;
+
+type StatefulSetArgs = CommonArgs & {
+    container?: Input<Container>;
+    containers?: InputArray<Container>;
+    volumeClaim?: Input<PersistentVolumeClaimArgs>;
+    volumeClaims?: InputArray<PersistentVolumeClaimArgs>;
+    service?: Input<ServiceArgs>;
+} & Partial<types.input.apps.v1.StatefulSetSpec>;
+declare class StatefulSet extends ComponentResource {
+    /**
+     * The underlying Kubernetes stateful set.
+     */
+    readonly statefulSet: Output<apps.v1.StatefulSet>;
+    /**
+     * The service associated with the stateful set.
+     */
+    readonly service: Output<Service>;
+    constructor(name: string, args: StatefulSetArgs, opts?: ComponentResourceOptions);
+}
+
+type NetworkPolicyPort = {
+    /**
+     * The protocol to match.
+     *
+     * If not provided, "TCP" will be used.
+     */
+    protocol?: string;
+} & ({
+    /**
+     * The single port to match.
+     */
+    port: number;
+} | {
+    /**
+     * The range of ports to match.
+     */
+    range: [start: number, end: number];
+});
+type IngressRuleArgs = {
+    /**
+     * Whether to allow all incoming traffic.
+     *
+     * If set to `true`, all other rules will be ignored for matched traffic.
+     */
+    fromAll?: Input<boolean>;
+    /**
+     * The allowed cidr for incoming traffic.
+     *
+     * Will be ORed with other conditions inside the same rule (except ports).
+     */
+    fromCidr?: Input<string>;
+    /**
+     * The list of allowed cidrs for incoming traffic.
+     *
+     * Will be ORed with other conditions inside the same rule (except ports).
+     */
+    fromCidrs?: InputArray<string>;
+    /**
+     * The service to allow traffic from.
+     *
+     * Will be ORed with other conditions inside the same rule (except ports).
+     */
+    fromService?: Input<core.v1.Service>;
+    /**
+     * The list of allowed services for incoming traffic.
+     *
+     * Will be ORed with other conditions inside the same rule (except ports).
+     */
+    fromServices?: InputArray<core.v1.Service>;
+    /**
+     * The namespace to allow traffic from.
+     *
+     * If provided with `fromSelector(s)`, it will be ANDed with them.
+     * Otherwise, it will match all pods in the namespace.
+     *
+     * Will be ORed with other conditions inside the same rule (except ports and selectors).
+     */
+    fromNamespace?: Input<NamespaceLike>;
+    /**
+     * The list of allowed namespaces for incoming traffic.
+     *
+     * If provided with `fromSelector(s)`, it will be ANDed with them.
+     * Otherwise, it will match all pods in the namespaces.
+     *
+     * Will be ORed with other conditions inside the same rule (except ports and selectors).
+     */
+    fromNamespaces?: InputArray<NamespaceLike>;
+    /**
+     * The selector for incoming traffic.
+     *
+     * If provided with `fromNamespace(s)`, it will be ANDed with them.
+     * Otherwise, it will match pods in all namespaces.
+     *
+     * Will be ORed with other conditions inside the same rule (except ports and namespaces).
+     */
+    fromSelector?: Input<SelectorLike>;
+    /**
+     * The list of selectors for incoming traffic.
+     *
+     * If provided with `fromNamespace(s)`, it will be ANDed with them.
+     * Otherwise, it will match pods in all namespaces.
+     *
+     * Will be ORed with other conditions inside the same rule (except ports and namespaces).
+     */
+    fromSelectors?: InputArray<SelectorLike>;
+    /**
+     * The port to allow incoming traffic on.
+     *
+     * Will be ANDed with all conditions inside the same rule.
+     */
+    toPort?: Input<NetworkPolicyPort>;
+    /**
+     * The list of allowed ports for incoming traffic.
+     *
+     * Will be ANDed with all conditions inside the same rule.
+     */
+    toPorts?: InputArray<NetworkPolicyPort>;
+};
+type EgressRuleArgs = {
+    /**
+     * Whether to allow all outgoing traffic.
+     *
+     * If set to `true`, all other rules will be ignored for matched traffic.
+     */
+    toAll?: Input<boolean>;
+    /**
+     * The allowed cidr for outgoing traffic.
+     *
+     * Will be ORed with other conditions inside the same rule (except ports).
+     */
+    toCidr?: Input<string>;
+    /**
+     * The list of allowed cidrs for outgoing traffic.
+     *
+     * Will be ORed with other conditions inside the same rule (except ports).
+     */
+    toCidrs?: InputArray<string>;
+    /**
+     * the FQDN to allow outgoing traffic.
+     *
+     * Will be ORed with other conditions inside the same rule (except ports).
+     */
+    toFqdn?: Input<string>;
+    /**
+     * The list of allowed FQDNs for outgoing traffic.
+     *
+     * Will be ORed with other conditions inside the same rule (except ports).
+     */
+    toFqdns?: InputArray<string>;
+    /**
+     * The service to allow traffic to.
+     *
+     * Will be ORed with other conditions inside the same rule (except ports).
+     */
+    toService?: Input<core.v1.Service>;
+    /**
+     * The list of allowed services for outgoing traffic.
+     *
+     * Will be ORed with other conditions inside the same rule (except ports).
+     */
+    toServices?: InputArray<core.v1.Service>;
+    /**
+     * The namespace to allow traffic to.
+     *
+     * If provided with `toSelector(s)`, it will be ANDed with them.
+     * Otherwise, it will match all pods in the namespace.
+     *
+     * Will be ORed with other conditions inside the same rule (except ports and selectors).
+     */
+    toNamespace?: Input<NamespaceLike>;
+    /**
+     * The list of allowed namespaces for outgoing traffic.
+     *
+     * If provided with `toSelector(s)`, it will be ANDed with them.
+     * Otherwise, it will match all pods in the namespaces.
+     *
+     * Will be ORed with other conditions inside the same rule (except ports and selectors).
+     */
+    toNamespaces?: InputArray<NamespaceLike>;
+    /**
+     * The selector for outgoing traffic.
+     *
+     * If provided with `toNamespace(s)`, it will be ANDe with them.
+     *
+     * Otherwise, it will match pods only in all namespaces.
+     */
+    toSelector?: Input<SelectorLike>;
+    /**
+     * The list of selectors for outgoing traffic.
+     *
+     * If provided with `toNamespace(s)`, it will be ANDed with them.
+     * Otherwise, it will match pods only in all namespaces.
+     */
+    toSelectors?: InputArray<SelectorLike>;
+    /**
+     * The port to allow outgoing traffic on.
+     *
+     * Will be ANDed with all conditions inside the same rule.
+     */
+    toPort?: Input<NetworkPolicyPort>;
+    /**
+     * The list of allowed ports for outgoing traffic.
+     *
+     * Will be ANDed with all conditions inside the same rule.
+     */
+    toPorts?: InputArray<NetworkPolicyPort>;
+};
+type NetworkPolicyArgs = CommonArgs & {
+    /**
+     * The description of this network policy.
+     */
+    description?: Input<string>;
+    /**
+     * The pod selector for this network policy.
+     * If not provided, it will select all pods in the namespace.
+     */
+    selector?: SelectorLike;
+    /**
+     * The rule for incoming traffic.
+     */
+    ingressRule?: Input<IngressRuleArgs>;
+    /**
+     * The rules for incoming traffic.
+     */
+    ingressRules?: InputArray<IngressRuleArgs>;
+    /**
+     * The rule for outgoing traffic.
+     */
+    egressRule?: Input<EgressRuleArgs>;
+    /**
+     * The rules for outgoing traffic.
+     */
+    egressRules?: InputArray<EgressRuleArgs>;
+    /**
+     * Enable the isolation of ingress traffic, so that only matched traffic can ingress.
+     */
+    isolateIngress?: Input<boolean>;
+    /**
+     * Enable the isolation of egress traffic, so that only matched traffic can egress.
+     */
+    isolateEgress?: Input<boolean>;
+};
+type FullNetworkPolicyArgs = NetworkPolicyArgs & {
+    /**
+     * The name of the CNI plugin to use for creating network policies.
+     * If not provided or set to `unknown`, it will use the native `NetworkPolicy` resource.
+     */
+    cni?: Input<string | undefined>;
+};
+type NormalizedRuleArgs = {
+    all: boolean;
+    cidrs: string[];
+    fqdns: string[];
+    services: core.v1.Service[];
+    namespaces: NamespaceLike[];
+    selectors: SelectorLike[];
+    ports: NetworkPolicyPort[];
+};
+type NormalizedNetworkPolicyArgs = Omit<Unwrap<NetworkPolicyArgs>, "podSelector" | "ingressRule" | "ingressRules" | "egressRule" | "egressRules" | "isolateIngress" | "isolateEgress"> & {
+    podSelector: Unwrap<types.input.meta.v1.LabelSelector>;
+    isolateIngress: boolean;
+    isolateEgress: boolean;
+    ingressRules: NormalizedRuleArgs[];
+    egressRules: NormalizedRuleArgs[];
+};
+/**
+ * The abstract resource for creating network policies.
+ * Will use different resources depending on the environment.
+ *
+ * Note: In the worst case, it will create native `NetworkPolicy` resources and ignore some features like L7 rules.
+ */
+declare abstract class NetworkPolicy extends ComponentResource {
+    /**
+     * The underlying network policy resource.
+     */
+    readonly networkPolicy: Output<Resource>;
+    protected constructor(name: string, args: Unwrap<NetworkPolicyArgs>, opts?: ResourceOptions);
+    protected abstract create(name: string, args: NormalizedNetworkPolicyArgs, opts?: ResourceOptions): Input<Resource>;
+    static create(name: string, args: FullNetworkPolicyArgs, opts?: ResourceOptions): Output<NetworkPolicy>;
+}
+
+type UseAccessPointResult = {
+    /**
+     * The gateway instance created according to the access point.
+     */
+    gateway: gateway.v1.Gateway;
+    /**
+     * The DNS record associated created according to the access point and gateway.
+     */
+    dnsRecord: DnsRecord;
+};
+type UseAccessPointArgs = Omit<CreateGatewayArgs, "gateway"> & {
+    accessPoint: Input<k8s.AccessPoint>;
+};
+declare function useAccessPoint(args: UseAccessPointArgs): Promise<UseAccessPointResult>;
+type CreateGatewayArgs = {
+    name: string;
+    namespace: Input<NamespaceLike>;
+    annotations?: Input<Record<string, string>>;
+    fqdn: Input<string>;
+    gateway: Input<k8s.Gateway>;
+    provider: Provider;
+};
+
+type ScriptDistribution = "alpine" | "ubuntu";
+type DistributionEnvironment = {
+    /**
+     * The utility packages that should be installed before running "preInstallScripts".
+     *
+     * Useful for installing tools like `curl` to install additional repositories.
+     */
+    preInstallPackages?: InputArray<string>;
+    /**
+     * The pre-install scripts that should be run before installing packages.
+     * Typically, these scripts are used to install additional repositories.
+     */
+    preInstallScripts?: InputMap<string>;
+    /**
+     * The packages that are available in the environment.
+     */
+    packages?: InputArray<string>;
+};
+type ScriptEnvironment = {
+    [distribution in ScriptDistribution]?: DistributionEnvironment;
+} & {
+    /**
+     * The setup scripts that should be run before the script.
+     */
+    setupScripts?: InputMap<string>;
+    /**
+     * The cleanup scripts that should be run after the script.
+     */
+    cleanupScripts?: InputMap<string>;
+    /**
+     * The arbitrary scripts available in the environment.
+     */
+    scripts?: InputMap<string>;
+    /**
+     * The volumes that should be defined in the environment.
+     */
+    volumes?: InputArray<WorkloadVolume>;
+    /**
+     * The volume mounts that should be defined in the environment.
+     */
+    volumeMounts?: InputArray<ContainerVolumeMount>;
+    /**
+     * The environment variables that should be defined in the environment.
+     */
+    environment?: Input<ContainerEnvironment>;
+};
+
+type ScriptBundleArgs = CommonArgs & {
+    /**
+     * The environment to bundle the scripts from.
+     */
+    environment?: Input$1<ScriptEnvironment>;
+    /**
+     * The environments to bundle the scripts from.
+     */
+    environments?: InputArray<ScriptEnvironment>;
+    /**
+     * The distribution to use for the scripts.
+     */
+    distribution: ScriptDistribution;
+};
+declare class ScriptBundle extends ComponentResource$1 {
+    /**
+     * The config map containing the scripts.
+     */
+    readonly configMap: Output$1<core.v1.ConfigMap>;
+    /**
+     * The volumes that should be included in the workload.
+     */
+    readonly volumes: Output$1<WorkloadVolume[]>;
+    /**
+     * The volume mounts that should be defined in the container.
+     */
+    readonly volumeMounts: Output$1<ContainerVolumeMount[]>;
+    /**
+     * The environment variables that should be defined in the container.
+     */
+    readonly environment: Output$1<ContainerEnvironment>;
+    /**
+     * The distribution to use for the scripts.
+     */
+    readonly distribution: ScriptDistribution;
+    constructor(name: string, args: ScriptBundleArgs, opts?: ComponentResourceOptions$1);
+}
+
+interface ScriptContainer extends Container {
+    /**
+     * The script bundle to use.
+     */
+    bundle: Input$1<ScriptBundle>;
+    /**
+     * The name of the main script to run.
+     * The script must be available in the bundle.
+     */
+    main: Input$1<string>;
+}
+/**
+ * Creates a spec for a container that runs a script.
+ * This spec can be used to create a complete workload or an init container.
+ *
+ * @param options The options to create the container spec.
+ * @returns The container spec.
+ */
+declare function createScriptContainer(options: ScriptContainer): Output$1<Container>;
+
+type JobArgs = CommonArgs & {
+    container?: Input<Container>;
+    containers?: InputArray<Container>;
+} & Omit<Partial<types.input.batch.v1.JobSpec>, "template"> & {
+    template?: {
+        metadata?: types.input.meta.v1.ObjectMeta;
+        spec?: Partial<types.input.core.v1.PodSpec>;
+    };
+};
+declare class Job extends ComponentResource {
+    /**
+     * The underlying Kubernetes job.
+     */
+    readonly job: Output<batch.v1.Job>;
+    constructor(name: string, args: JobArgs, opts?: ComponentResourceOptions);
+}
+
+type CronJobArgs = CommonArgs & {
+    container?: Input<Container>;
+    containers?: InputArray<Container>;
+} & Omit<RequiredKeys<Partial<types.input.batch.v1.CronJobSpec>, "schedule">, "jobTemplate"> & {
+    jobTemplate?: {
+        metadata?: types.input.meta.v1.ObjectMeta;
+        spec?: Omit<types.input.batch.v1.JobSpec, "template"> & {
+            template?: {
+                metadata?: types.input.meta.v1.ObjectMeta;
+                spec?: Partial<types.input.core.v1.PodSpec>;
+            };
+        };
+    };
+};
+declare class CronJob extends ComponentResource {
+    /**
+     * The underlying Kubernetes job.
+     */
+    readonly cronJob: Output<batch.v1.CronJob>;
+    constructor(name: string, args: CronJobArgs, opts?: ComponentResourceOptions);
+}
+
+declare function getChartServiceOutput(chart: helm.v4.Chart, name: string): Output$1<core.v1.Service>;
+declare function getChartService(chart: helm.v4.Chart, name: string): Promise<core.v1.Service>;
+
+export { type CommonArgs, type Container, type ContainerEnvironment, type ContainerEnvironmentSource, type ContainerEnvironmentVariable, type ContainerVolumeMount, CronJob, type CronJobArgs, Deployment, type DeploymentArgs, type FullNetworkPolicyArgs, HttpRoute, type HttpRouteArgs, Job, type JobArgs, type NamespaceLike, NetworkPolicy, type NetworkPolicyArgs, type NetworkPolicyPort, type NormalizedNetworkPolicyArgs, type NormalizedRuleArgs, ScriptBundle, type ScriptBundleArgs, type ScriptContainer, type ScriptDistribution, type ScriptEnvironment, type SelectorLike, Service, type ServiceArgs, StatefulSet, type StatefulSetArgs, type WorkloadVolume, createNamespace, createProvider, createScriptContainer, getChartService, getChartServiceOutput, getServiceHost, mapContainerPortToServicePort, mapMetadata, mapNamespaceLikeToNamespaceName, mapNamespaceNameToSelector, mapSelectorLikeToSelector, mapServiceToLabelSelector, resolveChartPath, useAccessPoint };