@intentius/chant-lexicon-k8s 0.1.14 → 0.1.16

package/src/crd/parser.ts

@@ -12,12 +12,24 @@ import type { CRDSpec } from "./types";
 import type { PropertyConstraints } from "@intentius/chant/codegen/json-schema";
 import { loadAll } from "js-yaml";
 
+/**
+ * Group names whose first segment doesn't yield the conventional namespace.
+ * "argoproj.io" → "Argo" (not "Argoproj") to match the Argo CD vocabulary
+ * and the ArgoAppFor / ArgoAppSetForRegions composites.
+ */
+const GROUP_NAMESPACE_OVERRIDES: Record<string, string> = {
+  "argoproj.io": "Argo",
+};
+
 /**
  * Normalize a CRD group to a PascalCase namespace segment.
  * "cert-manager.io" → "CertManager"
  * "monitoring.coreos.com" → "Monitoring"
+ * "argoproj.io" → "Argo" (override)
  */
 function normalizeGroupName(group: string): string {
+  const override = GROUP_NAMESPACE_OVERRIDES[group];
+  if (override) return override;
   // Take the first segment before the first dot
   const firstSegment = group.split(".")[0];
   // Convert kebab-case to PascalCase
@@ -165,10 +177,33 @@ function extractPropertyTypes(schema: OpenAPISchema, parentTypeName: string): Pa
   // "K8s::Ray::RayCluster::AutoscalerOptions".
   const shortName = parentTypeName.split("::").pop()!;
 
+  // Property-type identifiers must be unique within a resource. Singularizing
+  // array names can collide a sibling scalar object — e.g. Argo Application has
+  // both `source` (object) and `sources` (array), which both reduce to
+  // `Application_Source`. Track emitted names and fall back to the raw
+  // (un-singularized) name, then a numeric suffix, on collision.
+  const usedNames = new Set<string>();
+  const uniqueName = (base: string, raw: string): string => {
+    if (!usedNames.has(base)) {
+      usedNames.add(base);
+      return base;
+    }
+    const rawCandidate = `${shortName}_${pascalCase(raw)}`;
+    if (!usedNames.has(rawCandidate)) {
+      usedNames.add(rawCandidate);
+      return rawCandidate;
+    }
+    let i = 2;
+    while (usedNames.has(`${base}${i}`)) i++;
+    const suffixed = `${base}${i}`;
+    usedNames.add(suffixed);
+    return suffixed;
+  };
+
   for (const [name, prop] of Object.entries(specSchema.properties)) {
     // Extract inline object definitions as property types
     if (prop.type === "object" && prop.properties) {
-      const ptName = `${shortName}_${pascalCase(name)}`;
+      const ptName = uniqueName(`${shortName}_${pascalCase(name)}`, name);
       const requiredSet = new Set<string>(prop.required ?? []);
 
       results.push({
@@ -189,7 +224,7 @@ function extractPropertyTypes(schema: OpenAPISchema, parentTypeName: string): Pa
     if (prop.type === "array" && prop.items?.type === "object" && prop.items.properties) {
       const itemSchema = prop.items;
       const itemProps = itemSchema.properties!;
-      const ptName = `${shortName}_${pascalCase(singularize(name))}`;
+      const ptName = uniqueName(`${shortName}_${pascalCase(singularize(name))}`, name);
       const requiredSet = new Set<string>(itemSchema.required ?? []);
 
       results.push({

package/src/describe-resources.ts

@@ -15,6 +15,7 @@
 import { exec } from "node:child_process";
 import { promisify } from "node:util";
 import type { ResourceMetadata } from "@intentius/chant/lexicon";
+import { hasOwnershipMarker, classifyOwnership } from "@intentius/chant/ownership";
 
 const execAsync = promisify(exec);
 
@@ -22,7 +23,7 @@ const execAsync = promisify(exec);
  * Map chant entity types to `kubectl get` resource names. Add entries here
  * as new types are needed.
  */
-const KUBECTL_RESOURCE: Record<string, string> = {
+export const KUBECTL_RESOURCE: Record<string, string> = {
   "K8s::Apps::Deployment": "deployment.apps",
   "K8s::Apps::StatefulSet": "statefulset.apps",
   "K8s::Apps::DaemonSet": "daemonset.apps",
@@ -85,6 +86,7 @@ export async function describeResources(options: {
   buildOutput: string;
   entityNames: string[];
   entities: Map<string, { entityType: string; props: Record<string, unknown> }>;
+  owned?: boolean;
 }): Promise<Record<string, ResourceMetadata>> {
   const result: Record<string, ResourceMetadata> = {};
   const skippedTypes = new Set<string>();
@@ -106,11 +108,16 @@ export async function describeResources(options: {
     try {
       const { stdout } = await execAsync(cmd);
       const obj: KubectlResponse = JSON.parse(stdout);
+      // owned filter: skip resources not carrying chant's marker label.
+      if (options.owned && !hasOwnershipMarker(obj.metadata?.labels, "label")) {
+        continue;
+      }
       result[entityName] = {
         type: entityType,
         physicalId: obj.metadata?.uid,
         status: statusFromKubectl(obj),
         lastUpdated: obj.metadata?.creationTimestamp,
+        ownership: classifyOwnership(obj.metadata?.labels, "label"),
         attributes: pruneUndefined({
           namespace: obj.metadata?.namespace,
           labels: obj.metadata?.labels,

package/src/export-resources-io.test.ts

@@ -0,0 +1,72 @@
+import { describe, test, expect, vi, beforeEach } from "vitest";
+
+// Synchronous delivery (value, or Error for skipped kinds) avoids dangling
+// unhandled rejections when a kind is missing / RBAC-denied.
+const execMock = vi.fn();
+vi.mock("node:child_process", async () => {
+  const actual = await vi.importActual<typeof import("node:child_process")>("node:child_process");
+  return {
+    ...actual,
+    exec: (
+      cmd: string,
+      cb: (err: Error | null, out: { stdout: string; stderr: string }) => void,
+    ) => {
+      const r = execMock(cmd);
+      queueMicrotask(() =>
+        r instanceof Error
+          ? cb(r, { stdout: "", stderr: "" })
+          : cb(null, r as { stdout: string; stderr: string }),
+      );
+    },
+  };
+});
+
+const { exportResources } = await import("./export-resources");
+
+const liveDeployment = {
+  apiVersion: "apps/v1",
+  kind: "Deployment",
+  metadata: { name: "web", namespace: "default", uid: "d-1" },
+  spec: { replicas: 3, selector: { matchLabels: { app: "web" } } },
+};
+
+const emptyList = { stdout: JSON.stringify({ items: [] }), stderr: "" };
+
+describe("k8s exportResources I/O glue (#160)", () => {
+  beforeEach(() => execMock.mockReset());
+
+  test("sweeps known kinds via `kubectl get <kind> -A -o json` and maps to IR", async () => {
+    execMock.mockImplementation((cmd?: string) =>
+      cmd?.includes("get deployment.apps")
+        ? { stdout: JSON.stringify({ items: [liveDeployment] }), stderr: "" }
+        : emptyList,
+    );
+    const ir = await exportResources({ environment: "prod" });
+    const cmds = execMock.mock.calls.map((c) => c[0] as string).filter(Boolean);
+    expect(cmds.every((c) => c.startsWith("kubectl get ") && c.endsWith("-A -o json"))).toBe(true);
+    expect(cmds).toContain("kubectl get deployment.apps -A -o json");
+    expect(ir.resources.map((r) => r.type)).toContain("K8s::Apps::Deployment");
+  });
+
+  test("a kind that errors is skipped; the rest of the sweep still maps", async () => {
+    execMock.mockImplementation((cmd?: string) => {
+      if (cmd?.includes("get secret ")) return new Error("Error from server (Forbidden)");
+      if (cmd?.includes("get deployment.apps")) {
+        return { stdout: JSON.stringify({ items: [liveDeployment] }), stderr: "" };
+      }
+      return emptyList;
+    });
+    const ir = await exportResources({ environment: "prod" });
+    expect(ir.resources.map((r) => r.type)).toContain("K8s::Apps::Deployment");
+  });
+
+  test("a type selector narrows the sweep to a single kubectl get", async () => {
+    execMock.mockImplementation(() => ({
+      stdout: JSON.stringify({ items: [liveDeployment] }),
+      stderr: "",
+    }));
+    await exportResources({ environment: "prod", selector: { type: "K8s::Apps::Deployment" } });
+    expect(execMock.mock.calls.length).toBe(1);
+    expect(execMock.mock.calls[0][0]).toBe("kubectl get deployment.apps -A -o json");
+  });
+});

package/src/export-resources.ts

@@ -0,0 +1,60 @@
+/**
+ * Live export for the Kubernetes lexicon — implements
+ * LexiconPlugin.exportResources() so `chant import --from <cluster-env>`
+ * regenerates live objects as chant TypeScript.
+ *
+ * Reads live objects with `kubectl get <kinds> -A -o json`, strips
+ * server-managed noise to reach the declared shape (kept under `verbatim`),
+ * and maps to the import IR via the shared K8sParser. All I/O lives here; the
+ * cleaning and IR-building logic is pure in `./import/live-export`.
+ */
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import type { ExportedTemplate, ResourceSelector } from "@intentius/chant/lexicon";
+import { KUBECTL_RESOURCE } from "./describe-resources";
+import { buildExportFromObjects } from "./import/live-export";
+
+const execAsync = promisify(exec);
+
+interface KubectlList {
+  items?: unknown[];
+}
+
+export async function exportResources(options: {
+  environment: string;
+  selector?: ResourceSelector;
+  owned?: boolean;
+  verbatim?: boolean;
+}): Promise<ExportedTemplate> {
+  // Resolve which kinds to query. A type selector narrows to one kind;
+  // otherwise sweep every kind chant knows how to map.
+  const kinds = options.selector?.type
+    ? [KUBECTL_RESOURCE[options.selector.type]].filter(Boolean)
+    : Array.from(new Set(Object.values(KUBECTL_RESOURCE)));
+
+  if (kinds.length === 0) {
+    return { resources: [], parameters: [] };
+  }
+
+  // One List per kind keeps parsing simple and isolates a missing-kind error
+  // to that kind rather than failing the whole export.
+  const objects: unknown[] = [];
+  for (const kind of kinds) {
+    try {
+      const { stdout } = await execAsync(
+        ["kubectl", "get", kind, "-A", "-o", "json"].join(" "),
+      );
+      const list = JSON.parse(stdout) as KubectlList;
+      if (Array.isArray(list.items)) objects.push(...list.items);
+    } catch {
+      // Kind not present in the cluster / RBAC denied — skip it, don't fail
+      // the whole export.
+    }
+  }
+
+  return buildExportFromObjects(objects, {
+    verbatim: options.verbatim,
+    selector: options.selector,
+    owned: options.owned,
+  });
+}

package/src/generated/index.d.ts

@@ -76,6 +76,40 @@ export declare class APIVersions {
   readonly uid: string;
 }
 
+export declare class Application {
+  constructor(props: {
+    metadata: Record<string, unknown>;
+    /** ApplicationSpec represents desired application state. Contains link to repository with application definition and additional parameters link definition revision. */
+    spec: Record<string, unknown>;
+    /** Operation contains information about a requested or running operation */
+    operation?: Record<string, unknown>;
+  });
+  readonly name: string;
+  readonly namespace: string;
+  readonly uid: string;
+}
+
+export declare class ApplicationSet {
+  constructor(props: {
+    metadata: Record<string, unknown>;
+    spec: Record<string, unknown>;
+  });
+  readonly name: string;
+  readonly namespace: string;
+  readonly uid: string;
+}
+
+export declare class AppProject {
+  constructor(props: {
+    metadata: Record<string, unknown>;
+    /** AppProjectSpec is the specification of an AppProject */
+    spec: Record<string, unknown>;
+  });
+  readonly name: string;
+  readonly namespace: string;
+  readonly uid: string;
+}
+
 export declare class BatchJob {
   constructor(props: {
     /** Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata */

package/src/generated/index.ts

@@ -7,6 +7,9 @@ export const APIResourceList = createResource("K8s::Core::APIResourceList", "k8s
 export const APIService = createResource("K8s::Apiregistration::APIService", "k8s", {"name":"name","namespace":"namespace","uid":"uid"});
 export const APIServiceList = createResource("K8s::Apiregistration::APIServiceList", "k8s", {"name":"name","namespace":"namespace","uid":"uid"});
 export const APIVersions = createResource("K8s::Core::APIVersions", "k8s", {"name":"name","namespace":"namespace","uid":"uid"});
+export const Application = createResource("K8s::Argo::Application", "k8s", {"name":"name","namespace":"namespace","uid":"uid"});
+export const ApplicationSet = createResource("K8s::Argo::ApplicationSet", "k8s", {"name":"name","namespace":"namespace","uid":"uid"});
+export const AppProject = createResource("K8s::Argo::AppProject", "k8s", {"name":"name","namespace":"namespace","uid":"uid"});
 export const BatchJob = createResource("K8s::Batch::Job", "k8s", {"name":"name","namespace":"namespace","uid":"uid"});
 export const Binding = createResource("K8s::Core::Binding", "k8s", {"name":"name","namespace":"namespace","uid":"uid"});
 export const CertificateSigningRequest = createResource("K8s::Certificates::CertificateSigningRequest", "k8s", {"name":"name","namespace":"namespace","uid":"uid"});
@@ -153,6 +156,28 @@ export const VolumeAttributesClassList = createResource("K8s::Storage::VolumeAtt
 export const WatchEvent = createResource("K8s::Core::WatchEvent", "k8s", {"name":"name","namespace":"namespace","uid":"uid"});
 
 export const Affinity = createProperty("K8s::Core::Affinity", "k8s");
+export const Application_Destination = createProperty("K8s::Argo::Application.destination", "k8s");
+export const Application_IgnoreDifference = createProperty("K8s::Argo::Application.ignoreDifferences", "k8s");
+export const Application_Info = createProperty("K8s::Argo::Application.info", "k8s");
+export const Application_Source = createProperty("K8s::Argo::Application.source", "k8s");
+export const Application_Sources = createProperty("K8s::Argo::Application.sources", "k8s");
+export const Application_SyncPolicy = createProperty("K8s::Argo::Application.syncPolicy", "k8s");
+export const ApplicationSet_Generator = createProperty("K8s::Argo::ApplicationSet.generators", "k8s");
+export const ApplicationSet_IgnoreApplicationDifference = createProperty("K8s::Argo::ApplicationSet.ignoreApplicationDifferences", "k8s");
+export const ApplicationSet_PreservedFields = createProperty("K8s::Argo::ApplicationSet.preservedFields", "k8s");
+export const ApplicationSet_Strategy = createProperty("K8s::Argo::ApplicationSet.strategy", "k8s");
+export const ApplicationSet_SyncPolicy = createProperty("K8s::Argo::ApplicationSet.syncPolicy", "k8s");
+export const ApplicationSet_Template = createProperty("K8s::Argo::ApplicationSet.template", "k8s");
+export const AppProject_ClusterResourceBlacklist = createProperty("K8s::Argo::AppProject.clusterResourceBlacklist", "k8s");
+export const AppProject_ClusterResourceWhitelist = createProperty("K8s::Argo::AppProject.clusterResourceWhitelist", "k8s");
+export const AppProject_Destination = createProperty("K8s::Argo::AppProject.destinations", "k8s");
+export const AppProject_DestinationServiceAccount = createProperty("K8s::Argo::AppProject.destinationServiceAccounts", "k8s");
+export const AppProject_NamespaceResourceBlacklist = createProperty("K8s::Argo::AppProject.namespaceResourceBlacklist", "k8s");
+export const AppProject_NamespaceResourceWhitelist = createProperty("K8s::Argo::AppProject.namespaceResourceWhitelist", "k8s");
+export const AppProject_OrphanedResources = createProperty("K8s::Argo::AppProject.orphanedResources", "k8s");
+export const AppProject_Role = createProperty("K8s::Argo::AppProject.roles", "k8s");
+export const AppProject_SignatureKey = createProperty("K8s::Argo::AppProject.signatureKeys", "k8s");
+export const AppProject_SyncWindow = createProperty("K8s::Argo::AppProject.syncWindows", "k8s");
 export const Capabilities = createProperty("K8s::Core::Capabilities", "k8s");
 export const ConfigMapKeySelector = createProperty("K8s::Core::ConfigMapKeySelector", "k8s");
 export const Container = createProperty("K8s::Core::Container", "k8s");

package/src/generated/lexicon-k8s.json

@@ -46,6 +46,137 @@
     "kind": "property",
     "lexicon": "k8s"
   },
+  "AppProject": {
+    "resourceType": "K8s::Argo::AppProject",
+    "kind": "resource",
+    "lexicon": "k8s",
+    "apiVersion": "argoproj.io/v1alpha1",
+    "gvkKind": "AppProject"
+  },
+  "AppProject_ClusterResourceBlacklist": {
+    "resourceType": "K8s::Argo::AppProject.clusterResourceBlacklist",
+    "kind": "property",
+    "lexicon": "k8s"
+  },
+  "AppProject_ClusterResourceWhitelist": {
+    "resourceType": "K8s::Argo::AppProject.clusterResourceWhitelist",
+    "kind": "property",
+    "lexicon": "k8s"
+  },
+  "AppProject_Destination": {
+    "resourceType": "K8s::Argo::AppProject.destinations",
+    "kind": "property",
+    "lexicon": "k8s"
+  },
+  "AppProject_DestinationServiceAccount": {
+    "resourceType": "K8s::Argo::AppProject.destinationServiceAccounts",
+    "kind": "property",
+    "lexicon": "k8s"
+  },
+  "AppProject_NamespaceResourceBlacklist": {
+    "resourceType": "K8s::Argo::AppProject.namespaceResourceBlacklist",
+    "kind": "property",
+    "lexicon": "k8s"
+  },
+  "AppProject_NamespaceResourceWhitelist": {
+    "resourceType": "K8s::Argo::AppProject.namespaceResourceWhitelist",
+    "kind": "property",
+    "lexicon": "k8s"
+  },
+  "AppProject_OrphanedResources": {
+    "resourceType": "K8s::Argo::AppProject.orphanedResources",
+    "kind": "property",
+    "lexicon": "k8s"
+  },
+  "AppProject_Role": {
+    "resourceType": "K8s::Argo::AppProject.roles",
+    "kind": "property",
+    "lexicon": "k8s"
+  },
+  "AppProject_SignatureKey": {
+    "resourceType": "K8s::Argo::AppProject.signatureKeys",
+    "kind": "property",
+    "lexicon": "k8s"
+  },
+  "AppProject_SyncWindow": {
+    "resourceType": "K8s::Argo::AppProject.syncWindows",
+    "kind": "property",
+    "lexicon": "k8s"
+  },
+  "Application": {
+    "resourceType": "K8s::Argo::Application",
+    "kind": "resource",
+    "lexicon": "k8s",
+    "apiVersion": "argoproj.io/v1alpha1",
+    "gvkKind": "Application"
+  },
+  "ApplicationSet": {
+    "resourceType": "K8s::Argo::ApplicationSet",
+    "kind": "resource",
+    "lexicon": "k8s",
+    "apiVersion": "argoproj.io/v1alpha1",
+    "gvkKind": "ApplicationSet"
+  },
+  "ApplicationSet_Generator": {
+    "resourceType": "K8s::Argo::ApplicationSet.generators",
+    "kind": "property",
+    "lexicon": "k8s"
+  },
+  "ApplicationSet_IgnoreApplicationDifference": {
+    "resourceType": "K8s::Argo::ApplicationSet.ignoreApplicationDifferences",
+    "kind": "property",
+    "lexicon": "k8s"
+  },
+  "ApplicationSet_PreservedFields": {
+    "resourceType": "K8s::Argo::ApplicationSet.preservedFields",
+    "kind": "property",
+    "lexicon": "k8s"
+  },
+  "ApplicationSet_Strategy": {
+    "resourceType": "K8s::Argo::ApplicationSet.strategy",
+    "kind": "property",
+    "lexicon": "k8s"
+  },
+  "ApplicationSet_SyncPolicy": {
+    "resourceType": "K8s::Argo::ApplicationSet.syncPolicy",
+    "kind": "property",
+    "lexicon": "k8s"
+  },
+  "ApplicationSet_Template": {
+    "resourceType": "K8s::Argo::ApplicationSet.template",
+    "kind": "property",
+    "lexicon": "k8s"
+  },
+  "Application_Destination": {
+    "resourceType": "K8s::Argo::Application.destination",
+    "kind": "property",
+    "lexicon": "k8s"
+  },
+  "Application_IgnoreDifference": {
+    "resourceType": "K8s::Argo::Application.ignoreDifferences",
+    "kind": "property",
+    "lexicon": "k8s"
+  },
+  "Application_Info": {
+    "resourceType": "K8s::Argo::Application.info",
+    "kind": "property",
+    "lexicon": "k8s"
+  },
+  "Application_Source": {
+    "resourceType": "K8s::Argo::Application.source",
+    "kind": "property",
+    "lexicon": "k8s"
+  },
+  "Application_Sources": {
+    "resourceType": "K8s::Argo::Application.sources",
+    "kind": "property",
+    "lexicon": "k8s"
+  },
+  "Application_SyncPolicy": {
+    "resourceType": "K8s::Argo::Application.syncPolicy",
+    "kind": "property",
+    "lexicon": "k8s"
+  },
   "AutoscalerOptions": {
     "resourceType": "K8s::Ray::RayCluster.autoscalerOptions",
     "kind": "property",
@@ -133,6 +264,16 @@
     "apiVersion": "certificates.k8s.io/v1",
     "gvkKind": "CertificateSigningRequestList"
   },
+  "ClusterResourceBlacklist": {
+    "resourceType": "K8s::Argo::AppProject.clusterResourceBlacklist",
+    "kind": "property",
+    "lexicon": "k8s"
+  },
+  "ClusterResourceWhitelist": {
+    "resourceType": "K8s::Argo::AppProject.clusterResourceWhitelist",
+    "kind": "property",
+    "lexicon": "k8s"
+  },
   "ClusterRole": {
     "resourceType": "K8s::Rbac::ClusterRole",
     "kind": "resource",
@@ -325,6 +466,11 @@
     "kind": "property",
     "lexicon": "k8s"
   },
+  "DestinationServiceAccount": {
+    "resourceType": "K8s::Argo::AppProject.destinationServiceAccounts",
+    "kind": "property",
+    "lexicon": "k8s"
+  },
   "DeviceClass": {
     "resourceType": "K8s::Resource::DeviceClass",
     "kind": "resource",
@@ -449,6 +595,11 @@
     "kind": "property",
     "lexicon": "k8s"
   },
+  "Generator": {
+    "resourceType": "K8s::Argo::ApplicationSet.generators",
+    "kind": "property",
+    "lexicon": "k8s"
+  },
   "HPA": {
     "resourceType": "K8s::Autoscaling::HorizontalPodAutoscaler",
     "kind": "resource",
@@ -509,6 +660,21 @@
     "apiVersion": "networking.k8s.io/v1beta1",
     "gvkKind": "IPAddressList"
   },
+  "IgnoreApplicationDifference": {
+    "resourceType": "K8s::Argo::ApplicationSet.ignoreApplicationDifferences",
+    "kind": "property",
+    "lexicon": "k8s"
+  },
+  "IgnoreDifference": {
+    "resourceType": "K8s::Argo::Application.ignoreDifferences",
+    "kind": "property",
+    "lexicon": "k8s"
+  },
+  "Info": {
+    "resourceType": "K8s::Argo::Application.info",
+    "kind": "property",
+    "lexicon": "k8s"
+  },
   "Ing": {
     "resourceType": "K8s::Networking::Ingress",
     "kind": "resource",
@@ -678,6 +844,16 @@
     "apiVersion": "v1",
     "gvkKind": "NamespaceList"
   },
+  "NamespaceResourceBlacklist": {
+    "resourceType": "K8s::Argo::AppProject.namespaceResourceBlacklist",
+    "kind": "property",
+    "lexicon": "k8s"
+  },
+  "NamespaceResourceWhitelist": {
+    "resourceType": "K8s::Argo::AppProject.namespaceResourceWhitelist",
+    "kind": "property",
+    "lexicon": "k8s"
+  },
   "NetPol": {
     "resourceType": "K8s::Networking::NetworkPolicy",
     "kind": "resource",
@@ -756,6 +932,11 @@
     "kind": "property",
     "lexicon": "k8s"
   },
+  "OrphanedResources": {
+    "resourceType": "K8s::Argo::AppProject.orphanedResources",
+    "kind": "property",
+    "lexicon": "k8s"
+  },
   "PDB": {
     "resourceType": "K8s::Policy::PodDisruptionBudget",
     "kind": "resource",
@@ -899,6 +1080,11 @@
     "kind": "property",
     "lexicon": "k8s"
   },
+  "PreservedFields": {
+    "resourceType": "K8s::Argo::ApplicationSet.preservedFields",
+    "kind": "property",
+    "lexicon": "k8s"
+  },
   "PriorityClass": {
     "resourceType": "K8s::Scheduling::PriorityClass",
     "kind": "resource",
@@ -1330,6 +1516,21 @@
       }
     }
   },
+  "SignatureKey": {
+    "resourceType": "K8s::Argo::AppProject.signatureKeys",
+    "kind": "property",
+    "lexicon": "k8s"
+  },
+  "Source": {
+    "resourceType": "K8s::Argo::Application.source",
+    "kind": "property",
+    "lexicon": "k8s"
+  },
+  "Sources": {
+    "resourceType": "K8s::Argo::Application.sources",
+    "kind": "property",
+    "lexicon": "k8s"
+  },
   "StatefulSet": {
     "resourceType": "K8s::Apps::StatefulSet",
     "kind": "resource",
@@ -1370,6 +1571,11 @@
     "apiVersion": "storage.k8s.io/v1",
     "gvkKind": "StorageClassList"
   },
+  "Strategy": {
+    "resourceType": "K8s::Argo::ApplicationSet.strategy",
+    "kind": "property",
+    "lexicon": "k8s"
+  },
   "Subject": {
     "resourceType": "K8s::Rbac::Subject",
     "kind": "property",
@@ -1392,11 +1598,21 @@
     "kind": "property",
     "lexicon": "k8s"
   },
+  "SyncWindow": {
+    "resourceType": "K8s::Argo::AppProject.syncWindows",
+    "kind": "property",
+    "lexicon": "k8s"
+  },
   "TCPSocketAction": {
     "resourceType": "K8s::Core::TCPSocketAction",
     "kind": "property",
     "lexicon": "k8s"
   },
+  "Template": {
+    "resourceType": "K8s::Argo::ApplicationSet.template",
+    "kind": "property",
+    "lexicon": "k8s"
+  },
   "TokenRequest": {
     "resourceType": "K8s::Authentication::TokenRequest",
     "kind": "resource",