k8ts 0.4.19 → 0.4.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "k8ts",
-  "version": "0.4.19",
+  "version": "0.4.21",
   "description": "Powerful framwork for building Kubernetes manifests in TypeScript.",
   "keywords": [
     "kubernetes",
@@ -34,11 +34,11 @@
       "default": "./dist/index.js",
       "types": "./dist/index.d.ts"
     },
-    "./api-versions": {
-      "require": "./dist/api-versions.js",
-      "import": "./dist/api-versions.js",
-      "default": "./dist/api-versions.js",
-      "types": "./dist/api-versions.d.ts"
+    "./kinds": {
+      "require": "./dist/kinds.js",
+      "import": "./dist/kinds.js",
+      "default": "./dist/kinds.js",
+      "types": "./dist/kinds.d.ts"
     }
   },
   "main": "dist/index.js",
@@ -67,6 +67,7 @@
     "doddle": "^5.0.0-beta.16",
     "emittery": "0.13.1",
     "immutable": "^5.0.3",
+    "ip-address": "^10.0.1",
     "js-yaml": "^4.1.0",
     "lodash": "^4.17.21",
     "ora": "5.4.1",
@@ -76,8 +77,8 @@
   },
   "devDependencies": {
     "@datreeio/datree-cdk8s": "^1.3.5",
-    "@k8ts/instruments": "^0.4.4",
-    "@k8ts/metadata": "^0.4.4",
+    "@k8ts/instruments": "^0.4.7",
+    "@k8ts/metadata": "^0.4.6",
     "@swc/core": "^1.11.11",
     "@swc/jest": "^0.2.37",
     "@types/chalk": "^2.2.4",
@@ -97,8 +98,8 @@
     "yamprint": "^0.8.4"
   },
   "peerDependencies": {
-    "@k8ts/instruments": "^0.4.4",
-    "@k8ts/metadata": "^0.4.4"
+    "@k8ts/instruments": "^0.4.7",
+    "@k8ts/metadata": "^0.4.6"
   },
   "packageManager": "yarn@4.1.1",
   "engines": {

package/src/file/exports.ts

@@ -1,6 +1,6 @@
-import { FutureExports, Producer } from "@k8ts/instruments"
+import { FutureExports, LiveRefable, Producer } from "@k8ts/instruments"
 import { seq, type Seq } from "doddle"
-import type { ManifestResource } from "../node"
+import { ManifestResource } from "../node"
 import { k8ts_namespace } from "../runner/exporter/meta"
 import { Factory } from "./factory"
 import type { FileOrigin } from "./origin"
@@ -12,7 +12,7 @@ export namespace FileExports {
     > = Producer.Producer<Factory.FromScope<Scope>, Produced>
     export interface Props<
         Scope extends FileOrigin.Scope = FileOrigin.Scope,
-        Produced extends ManifestResource = ManifestResource
+        Produced extends LiveRefable = LiveRefable
     > {
         origin: FileOrigin<Scope>
         FILE: Producer<Scope, Produced>
@@ -20,7 +20,7 @@ export namespace FileExports {
 
     export class Core {
         #props: Props
-        #produced: Seq<ManifestResource>
+        #produced: Seq<LiveRefable>
         constructor(props: Props) {
             this.#props = props
             const producer = Producer.map(props.FILE, () => {
@@ -31,6 +31,7 @@ export namespace FileExports {
                 }
             })
             this.#produced = seq(() => producer(props.origin))
+                .as<ManifestResource>()
                 .each(x => {
                     x.meta.add(k8ts_namespace, {
                         "#is-exported": "true"
@@ -52,7 +53,7 @@ export namespace FileExports {
         }
     }
 
-    export function make<Scope extends FileOrigin.Scope, Produced extends ManifestResource>(
+    export function make<Scope extends FileOrigin.Scope, Produced extends LiveRefable>(
         props: Props<Scope, Produced>
     ): Core & FutureExports<Produced> {
         const core = new Core(props as any)

package/src/file/factory.ts

@@ -1,5 +1,13 @@
-import { Origin, auto_register, displayers, type LiveRefable } from "@k8ts/instruments"
+import {
+    Origin,
+    Trace,
+    TraceEmbedder,
+    auto_register,
+    displayers,
+    type LiveRefable
+} from "@k8ts/instruments"
 import chalk from "chalk"
+import StackTracey from "stacktracey"
 import {
     ConfigMap,
     DataMode,
@@ -87,37 +95,35 @@ export namespace Factory {
             props: Service.Props<DeployPorts, ExposedPorts>
         ) {
             return new Service.Service(this.origin, this._metaWithName(name), props) as LiveRefable<
-                Service<DeployPorts, ExposedPorts>,
+                Service<ExposedPorts>,
                 Name
             >
         }
 
-        private PrvDeployment<Name extends string, Ports extends string = never>(
-            name: Name,
-            props: Deployment.Props<Ports>
-        ) {
-            return new Deployment.Deployment(
-                this.origin,
-                this._metaWithName(name),
-                props
-            ) as LiveRefable<Deployment<Ports>, Name>
-        }
-
         Deployment<Name extends string>(name: Name, props: Deployment.SmallerProps) {
             const builder = this
+            const traceHere = new Trace(new StackTracey().slice(2))
+
             return {
                 Template(templateProps?: PodTemplate.PodProps) {
                     return {
                         POD<Ports extends string>(
                             producer: PodTemplate.PodContainerProducer<Ports>
                         ) {
-                            return builder.PrvDeployment(name, {
-                                ...props,
-                                template: {
-                                    ...templateProps,
-                                    POD: producer
+                            const dep = new Deployment.Deployment(
+                                builder.origin,
+                                builder._metaWithName(name),
+                                {
+                                    ...props,
+                                    template: {
+                                        ...templateProps,
+                                        POD: producer
+                                    }
                                 }
-                            })
+                            ) as LiveRefable<Deployment<Ports>, Name>
+                            TraceEmbedder.set(dep.node, traceHere)
+                            dep.node.origin["__attach_resource__"]([dep.node])
+                            return dep
                         }
                     }
                 }

package/src/file/file.ts

@@ -1,9 +1,8 @@
-import type { FutureExports, Origin } from "@k8ts/instruments"
-import type { ManifestResource } from "../node"
+import type { FutureExports, LiveRefable, Origin } from "@k8ts/instruments"
 import { FileExports as Exports_ } from "./exports"
 import { Factory as Factory_ } from "./factory"
 import { FileOrigin } from "./origin"
-export type File<T extends ManifestResource = ManifestResource> = File.File<T>
+export type File<T extends LiveRefable = LiveRefable> = File.File<T>
 export namespace File {
     export import Factory = Factory_
 
@@ -11,15 +10,15 @@ export namespace File {
 
     export interface Props<
         Scope extends FileOrigin.Scope = FileOrigin.Scope,
-        Produced extends ManifestResource = ManifestResource
+        Produced extends LiveRefable = LiveRefable
     > extends FileOrigin.Props<Scope> {
         FILE: Exports.Producer<Scope, Produced>
     }
 
-    export type Input = Exports.Core & Iterable<ManifestResource>
-    export type File<T extends ManifestResource> = Exports.Core & FutureExports<T>
+    export type Input = Exports.Core & Iterable<LiveRefable>
+    export type File<T extends LiveRefable> = Exports.Core & FutureExports<T>
 
-    export function make<Scope extends FileOrigin.Scope, Produced extends ManifestResource>(
+    export function make<Scope extends FileOrigin.Scope, Produced extends LiveRefable>(
         name: string,
         props: Props<Scope, Produced>,
         parent: Origin

package/src/file/origin.ts

@@ -1,11 +1,11 @@
-import { BaseOriginEntity, Origin, OriginEntityProps } from "@k8ts/instruments"
+import { BaseOriginEntity, Origin, OriginEntityProps, Refable } from "@k8ts/instruments"
 import { Meta } from "@k8ts/metadata"
 import { k8tsBuildKind } from "../k8ts-sys-kind"
-import type { Namespace } from "../resources"
+import { api } from "../kinds"
 export type FileOrigin<FScope extends FileOrigin.Scope = FileOrigin.Scope> =
     FileOrigin.FileEntity<FScope>
 export namespace FileOrigin {
-    export type Scope = Namespace | "cluster"
+    export type Scope = Refable<api.v1_.Namespace> | "cluster"
 
     export interface SmallerProps extends OriginEntityProps {
         meta?: Meta.Input

package/src/kind-map.ts

@@ -2,8 +2,8 @@ import {
     BaseOriginEntity,
     Kind,
     kinded,
-    MetadataEntity,
-    OriginEntityProps
+    OriginEntityProps,
+    ResourceEntity
 } from "@k8ts/instruments"
 import { k8tsBuildKind } from "./k8ts-sys-kind"
 const ident = k8tsBuildKind.kind("World")
@@ -23,7 +23,9 @@ class K8tsRootOriginEntity extends BaseOriginEntity<OriginEntityProps> {
     }
 
     get decorator() {
-        return <Target extends new (...args: any[]) => MetadataEntity>(kind: Kind.Identifier) => {
+        return <Target extends abstract new (...args: any[]) => ResourceEntity>(
+            kind: Kind.Identifier
+        ) => {
             return (ctor: Target) => {
                 this.node.resourceKinds.add(kind, ctor)
                 kinded(kind)(ctor)
@@ -37,3 +39,4 @@ export const K8tsRootOrigin = new K8tsRootOriginEntity()
 export const K8tsResources = K8tsRootOrigin.node.resourceKinds
 
 export const k8ts = K8tsRootOrigin.decorator
+export const REF_TYPE = Symbol.for("k8ts:ref")

package/src/kinds.ts

@@ -0,0 +1,127 @@
+import { Kind } from "@k8ts/instruments"
+export namespace api {
+    export const v1 = Kind.version("v1")
+    export type v1 = typeof v1
+
+    export namespace v1_ {
+        export function kind_<Name extends string>(name: Name): Kind<Name, typeof v1> {
+            return v1.kind(name)
+        }
+
+        export const ConfigMap = v1.kind("ConfigMap")
+        export type ConfigMap = typeof ConfigMap
+
+        export const Secret = v1.kind("Secret")
+        export type Secret = typeof Secret
+
+        export const Service = v1.kind("Service")
+        export type Service = typeof Service
+
+        export const Pod = v1.kind("Pod")
+        export type Pod = typeof Pod
+
+        export namespace Pod_ {
+            export const Container = Pod.subkind("Container")
+            export type Container = typeof Container
+
+            export const Port = Container.subkind("Port")
+            export type Port = typeof Port
+
+            export const EnvVar = Container.subkind("EnvVar")
+            export type EnvVar = typeof EnvVar
+
+            export const VolumeMount = Container.subkind("VolumeMount")
+            export type VolumeMount = typeof VolumeMount
+
+            export const DeviceMount = Container.subkind("DeviceMount")
+            export type DeviceMount = typeof DeviceMount
+
+            export const Volume = Pod.subkind("Volume")
+            export type Volume = typeof Volume
+
+            export const Device = Volume.subkind("Device")
+            export type Device = typeof Device
+        }
+
+        export const Node = v1.kind("Node")
+        export type Node = typeof Node
+
+        export const Namespace = v1.kind("Namespace")
+        export type Namespace = typeof Namespace
+
+        export const ServiceAccount = v1.kind("ServiceAccount")
+        export type ServiceAccount = typeof ServiceAccount
+
+        export const PersistentVolume = v1.kind("PersistentVolume")
+        export type PersistentVolume = typeof PersistentVolume
+
+        export const PersistentVolumeClaim = v1.kind("PersistentVolumeClaim")
+        export type PersistentVolumeClaim = typeof PersistentVolumeClaim
+
+        export const PodTemplate = v1.kind("PodTemplate")
+        export type PodTemplate = typeof PodTemplate
+    }
+
+    export const apps = Kind.group("apps")
+    export type apps = typeof apps
+
+    export namespace apps_ {
+        export const v1 = apps.version("v1")
+        export type v1 = typeof v1
+
+        export namespace v1_ {
+            export const Deployment = v1.kind("Deployment")
+            export type Deployment = typeof Deployment
+
+            export const StatefulSet = v1.kind("StatefulSet")
+            export type StatefulSet = typeof StatefulSet
+
+            export const DaemonSet = v1.kind("DaemonSet")
+            export type DaemonSet = typeof DaemonSet
+
+            export const ReplicaSet = v1.kind("ReplicaSet")
+            export type ReplicaSet = typeof ReplicaSet
+
+            export const ControllerRevision = v1.kind("ControllerRevision")
+            export type ControllerRevision = typeof ControllerRevision
+        }
+    }
+
+    export const networking = Kind.group("networking.k8s.io")
+    export type networking = typeof networking
+
+    export namespace networking_ {
+        export const v1 = networking.version("v1")
+        export type v1 = typeof v1
+
+        export namespace v1_ {
+            export const NetworkPolicy = v1.kind("NetworkPolicy")
+            export type NetworkPolicy = typeof NetworkPolicy
+        }
+    }
+
+    export const gateway = Kind.group("gateway.networking.k8s.io")
+    export type gateway = typeof gateway
+
+    export namespace gateway_ {
+        export const v1 = gateway.version("v1")
+        export type v1 = typeof v1
+
+        export namespace v1_ {
+            export const Gateway = v1.kind("Gateway")
+            export type Gateway = typeof Gateway
+
+            export const GatewayClass = v1.kind("GatewayClass")
+            export type GatewayClass = typeof GatewayClass
+
+            export const HttpRoute = v1.kind("HTTPRoute")
+            export type HttpRoute = typeof HttpRoute
+
+            export const TcpRoute = v1.kind("TCPRoute")
+            export type TcpRoute = typeof TcpRoute
+
+            export const TlsRoute = v1.kind("TLSRoute")
+            export type TlsRoute = typeof TlsRoute
+        }
+    }
+}

package/src/node/abs-resource.ts

@@ -1,14 +1,15 @@
-import { displayers, Kind, Origin, RefKey, ResourceNode } from "@k8ts/instruments"
+import { displayers, Kind, Origin, RefKey, ResourceEntity, ResourceNode } from "@k8ts/instruments"
 import { Doddle, doddle } from "doddle"
-export interface DependsOn {
-    resource: AbsResource
-    text: string
+
+export interface ResourceIdentBlock {
+    kind: Kind.IdentParent
+    name: string
 }
 @displayers({
     simple: s => s.node,
     pretty: s => s.node
 })
-export abstract class AbsResource<Props extends object = object> {
+export abstract class AbsResource<Props extends object = object> implements ResourceEntity {
     abstract readonly kind: Kind.Identifier<string, Kind.Identifier>
 
     private _node: Doddle<ResourceNode>
@@ -16,7 +17,7 @@ export abstract class AbsResource<Props extends object = object> {
     get node() {
         return this._node.pull()
     }
-    constructor(
+    protected constructor(
         origin: Origin,
         readonly name: string,
         readonly props: Props

package/src/node/equiv-cdk8s.ts

@@ -1,15 +1,14 @@
-import { Embedder } from "@k8ts/instruments"
+import { Embedder, Kinded, LiveRefable } from "@k8ts/instruments"
 import { Construct } from "constructs"
-import { ManifestResource } from "./manifest-resource"
 
 export type Cdk8sCtor = {
     new (parent: Construct, id: string, props: any): Construct
 }
-export type ManifestResourceCtor = new (...args: any[]) => ManifestResource
-export const EquivCdk8s = new Embedder<ManifestResource, Cdk8sCtor>("CDK8S_RESOURCE")
+export type KindedCtor = new (...args: any[]) => Kinded
+export const EquivCdk8s = new Embedder<LiveRefable, Cdk8sCtor>("CDK8S_RESOURCE")
 
 export function equiv_cdk8s(ctor: Cdk8sCtor) {
-    return <F extends ManifestResourceCtor>(target: F) => {
+    return <F extends KindedCtor>(target: F) => {
         const cdk8s = EquivCdk8s.tryGet(target.prototype)
         if (cdk8s) {
             throw new Error(`Target ${target} already has a cdk8s equivalent! ${cdk8s}`)

package/src/node/manifest-resource.ts

@@ -1,7 +1,11 @@
 import { Builder, Kind, type Origin } from "@k8ts/instruments"
 import type { Meta, MutableMeta } from "@k8ts/metadata"
+import { ResourceIdentBlock } from "./abs-resource"
 import { TopResource } from "./top-resource"
 
+export interface ManifestResourceIdent extends ResourceIdentBlock {
+    name: string
+}
 export abstract class ManifestResource<Props extends object = object> extends TopResource<Props> {
     protected async manifest() {
         return Builder.get(this).manifest()

package/src/node/sub-resource.ts

@@ -7,14 +7,14 @@ import type { ManifestResource } from "./manifest-resource"
 })
 export abstract class SubResource<Props extends object = object> extends AbsResource<Props> {
     constructor(
-        readonly parent: ManifestResource,
+        readonly parent: SubResource | ManifestResource,
         name: string,
         props: Props
     ) {
         super(parent.node.origin, name, props)
     }
 
-    get namespace() {
+    get namespace(): string | undefined {
         return this.parent.namespace
     }
 }

package/src/resources/configmap/configmap.ts

@@ -8,8 +8,8 @@ import {
     resolveText
 } from "@k8ts/instruments"
 import { CDK } from "../../_imports"
-import { v1 } from "../../api-versions"
 import { k8ts } from "../../kind-map"
+import { api } from "../../kinds"
 import { equiv_cdk8s } from "../../node/equiv-cdk8s"
 import { ManifestResource } from "../../node/manifest-resource"
 export type ConfigMap = ConfigMap.ConfigMap
@@ -20,8 +20,7 @@ export namespace ConfigMap {
         binaryData?: DataSourceRecord_Binary
     }
 
-    const ident = v1.kind("ConfigMap")
-    @k8ts(ident)
+    @k8ts(api.v1_.ConfigMap)
     @relations("none")
     @equiv_cdk8s(CDK.KubeConfigMap)
     @manifest({
@@ -37,6 +36,6 @@ export namespace ConfigMap {
         }
     })
     export class ConfigMap extends ManifestResource<Props> {
-        override kind = ident
+        override kind = api.v1_.ConfigMap
     }
 }

package/src/resources/deployment/deployment.ts

@@ -1,9 +1,9 @@
-import { manifest, Origin, relations } from "@k8ts/instruments"
+import { manifest, Origin, Refable, relations } from "@k8ts/instruments"
 import { Meta, MutableMeta } from "@k8ts/metadata"
 import { omit } from "lodash"
 import { CDK } from "../../_imports"
-import { apps_v1 } from "../../api-versions"
 import { k8ts } from "../../kind-map"
+import { api } from "../../kinds"
 import { equiv_cdk8s } from "../../node/equiv-cdk8s"
 import { ManifestResource } from "../../node/manifest-resource"
 import { PodTemplate } from "../pod/pod-template"
@@ -14,9 +14,11 @@ export namespace Deployment {
     export type Props<Ports extends string> = SmallerProps & {
         template: PodTemplate.Props<Ports>
     }
+    export type AbsDeployment<Ports extends string> = Refable<api.apps_.v1_.Deployment> & {
+        __PORTS__: Ports
+    }
 
-    const ident = apps_v1.kind("Deployment")
-    @k8ts(ident)
+    @k8ts(api.apps_.v1_.Deployment)
     @equiv_cdk8s(CDK.KubeDeployment)
     @relations({
         kids: s => [s.template]
@@ -39,8 +41,10 @@ export namespace Deployment {
         }
     })
     export class Deployment<Ports extends string = string> extends ManifestResource<Props<Ports>> {
-        kind = ident
+        __PORTS__!: Ports
+        kind = api.apps_.v1_.Deployment
         template: PodTemplate<Ports>
+
         constructor(origin: Origin, meta: Meta | MutableMeta, props: Props<Ports>) {
             super(origin, meta, props)
             this.template = new PodTemplate.PodTemplate(

package/src/resources/http-route/http-route.ts

@@ -1,8 +1,8 @@
 import { manifest, relations } from "@k8ts/instruments"
 import { CDK } from "../../_imports"
-import { gateway_v1 } from "../../api-versions"
 import type { External } from "../../external"
 import { k8ts } from "../../kind-map"
+import { api } from "../../kinds"
 import { ManifestResource } from "../../node"
 import { equiv_cdk8s } from "../../node/equiv-cdk8s"
 import type { Service } from "../service"
@@ -10,15 +10,13 @@ import type { Service } from "../service"
 export type HttpRoute<Ports extends string> = HttpRoute.HttpRoute<Ports>
 
 export namespace HttpRoute {
-    const gwKind = gateway_v1.kind("Gateway")
     export interface Props<Ports extends string> {
-        gateway: External<typeof gwKind>
+        gateway: External<api.gateway_.v1_.Gateway>
         hostname: string
         backend: Service.Port<Ports>
     }
 
-    const kind = gateway_v1.kind("HTTPRoute")
-    @k8ts(kind)
+    @k8ts(api.gateway_.v1_.HttpRoute)
     @relations({
         needs: self => ({
             gateway: self.props.gateway,
@@ -42,6 +40,6 @@ export namespace HttpRoute {
         }
     })
     export class HttpRoute<Ports extends string> extends ManifestResource<Props<Ports>> {
-        kind = gateway_v1.kind("HTTPRoute")
+        kind = api.gateway_.v1_.HttpRoute
     }
 }

package/src/resources/namespace/namespace.ts

@@ -1,15 +1,14 @@
 import { manifest, relations, type Origin } from "@k8ts/instruments"
 import { Meta, MutableMeta } from "@k8ts/metadata"
 import { CDK } from "../../_imports"
-import { v1 } from "../../api-versions"
 import { k8ts } from "../../kind-map"
+import { api } from "../../kinds"
 import { equiv_cdk8s } from "../../node/equiv-cdk8s"
 import { ManifestResource } from "../../node/manifest-resource"
 export type Namespace = Namespace.Namespace
 export namespace Namespace {
     export interface Props {}
-    const ident = v1.kind("Namespace")
-    @k8ts(ident)
+    @k8ts(api.v1_.Namespace)
     @relations("none")
     @equiv_cdk8s(CDK.KubeNamespace)
     @manifest({
@@ -20,7 +19,7 @@ export namespace Namespace {
         }
     })
     export class Namespace extends ManifestResource<Props> {
-        override kind = ident
+        override kind = api.v1_.Namespace
         constructor(origin: Origin, meta: Meta | MutableMeta, props?: Props) {
             super(origin, meta.toMutable(), props ?? {})
         }

package/src/resources/persistent/claim/pvc.ts

@@ -1,7 +1,7 @@
 import { manifest, relations, ResourcesSpec, Unit } from "@k8ts/instruments"
 import { CDK } from "../../../_imports"
-import { v1 } from "../../../api-versions"
 import { k8ts } from "../../../kind-map"
+import { api } from "../../../kinds"
 import { ManifestResource } from "../../../node"
 import { equiv_cdk8s } from "../../../node/equiv-cdk8s"
 import { Access } from "../access-mode"
@@ -18,15 +18,14 @@ export namespace Pvc {
     export interface Props<Mode extends DataMode> extends PvcResources {
         accessModes: Access
         mode?: Mode
-        bind: Pv<Mode>
+        bind: Pv.AbsPv<Mode>
     }
 
-    const ident = v1.kind("PersistentVolumeClaim")
-    @k8ts(ident)
+    @k8ts(api.v1_.PersistentVolumeClaim)
     @equiv_cdk8s(CDK.KubePersistentVolumeClaim)
     @relations({
         needs: self => ({
-            bind: self.props.bind
+            bind: self.bound
         })
     })
     @manifest({
@@ -49,6 +48,10 @@ export namespace Pvc {
         }
     })
     export class Pvc<Mode extends DataMode = DataMode> extends ManifestResource<Props<Mode>> {
-        kind = ident
+        kind = api.v1_.PersistentVolumeClaim
+
+        get bound() {
+            return this.props.bind as Pv<Mode>
+        }
     }
 }

package/src/resources/persistent/volume/pv.ts

@@ -1,8 +1,8 @@
-import { manifest, relations, type Unit } from "@k8ts/instruments"
+import { manifest, Refable, relations, type Unit } from "@k8ts/instruments"
 import { CDK } from "../../../_imports"
-import { v1 } from "../../../api-versions"
 import { MakeError } from "../../../error"
 import { k8ts } from "../../../kind-map"
+import { api } from "../../../kinds"
 import { equiv_cdk8s } from "../../../node/equiv-cdk8s"
 import { ManifestResource } from "../../../node/manifest-resource"
 import { Access } from "../access-mode"
@@ -23,9 +23,9 @@ export namespace Pv {
         nodeAffinity?: CDK.VolumeNodeAffinity
     }
     export type Reclaim = "Retain" | "Delete" | "Recycle"
-
-    const ident = v1.kind("PersistentVolume")
-
+    export type AbsPv<Mode extends DataMode = DataMode> = Refable<api.v1_.PersistentVolume> & {
+        __MODE__: Mode
+    }
     @equiv_cdk8s(CDK.KubePersistentVolume)
     @manifest({
         body(self) {
@@ -59,9 +59,10 @@ export namespace Pv {
             }
         }
     })
-    @k8ts(ident)
+    @k8ts(api.v1_.PersistentVolume)
     @relations("none")
     export class Pv<Mode extends DataMode = DataMode> extends ManifestResource<Props<Mode>> {
-        declare readonly kind: typeof ident
+        __MODE__!: Mode
+        readonly kind = api.v1_.PersistentVolume
     }
 }