@intentius/chant-lexicon-gcp 0.124.31 → 0.124.33

package/dist/actions/index.js

@@ -0,0 +1,45 @@
+/**
+ * GCP IAM role constants for common patterns.
+ */
+export const StorageRoles = {
+    Admin: "roles/storage.admin",
+    ObjectAdmin: "roles/storage.objectAdmin",
+    ObjectViewer: "roles/storage.objectViewer",
+    ObjectCreator: "roles/storage.objectCreator",
+};
+export const ComputeRoles = {
+    Admin: "roles/compute.admin",
+    Viewer: "roles/compute.viewer",
+    NetworkAdmin: "roles/compute.networkAdmin",
+    InstanceAdmin: "roles/compute.instanceAdmin.v1",
+};
+export const ContainerRoles = {
+    Admin: "roles/container.admin",
+    Developer: "roles/container.developer",
+    Viewer: "roles/container.viewer",
+    ClusterAdmin: "roles/container.clusterAdmin",
+};
+export const IAMRoles = {
+    Admin: "roles/iam.serviceAccountAdmin",
+    User: "roles/iam.serviceAccountUser",
+    TokenCreator: "roles/iam.serviceAccountTokenCreator",
+    WorkloadIdentityUser: "roles/iam.workloadIdentityUser",
+};
+export const SQLRoles = {
+    Admin: "roles/cloudsql.admin",
+    Client: "roles/cloudsql.client",
+    Editor: "roles/cloudsql.editor",
+    Viewer: "roles/cloudsql.viewer",
+};
+export const RunRoles = {
+    Admin: "roles/run.admin",
+    Developer: "roles/run.developer",
+    Invoker: "roles/run.invoker",
+    Viewer: "roles/run.viewer",
+};
+export const PubSubRoles = {
+    Admin: "roles/pubsub.admin",
+    Publisher: "roles/pubsub.publisher",
+    Subscriber: "roles/pubsub.subscriber",
+    Viewer: "roles/pubsub.viewer",
+};

package/dist/api/read-client.js

@@ -0,0 +1,105 @@
+/**
+ * GCP read transport (#1209) — the applier's own REST client, pointed at the
+ * read side.
+ *
+ * GCP applies cluster-free over direct REST (#706) and, until this, observed
+ * through a Config Connector cluster: `kubectl get <cnrm-gvk> -o json` per
+ * entity, on both the thin and the deep path. That split is what #1085's
+ * principle forbids — a lexicon should be observed on the transport it is
+ * applied with, or the two can disagree about what a resource even is — and it
+ * is what made GCP the heaviest of the three O slots.
+ *
+ * ## The URL comes from the applier, not from here
+ *
+ * Every GET is built by the same `ResourceMapper.plan()` the applier uses, and
+ * this module reads `plan().getUrl` rather than composing its own URL. That is
+ * deliberate: a reader that builds its own paths is a second, silently
+ * divergent opinion about where a resource lives, and the first symptom is a
+ * read that reports absent for something the applier just wrote. Reusing the
+ * mapper makes the two structurally incapable of disagreeing.
+ *
+ * ## What that bounds
+ *
+ * Coverage is exactly the applier's dispatch table (`MAPPERS`) — StorageBucket,
+ * PubSubTopic, PubSubSubscription, SecretManagerSecret, IAMServiceAccount,
+ * RunService. The kubectl path could fetch any CNRM kind the cluster knew
+ * about, so this is narrower on paper. It is not narrower in practice for
+ * anything chant can act on: a kind with no mapper cannot be applied either, so
+ * observing it produced a live tree nothing could ever reconcile against.
+ *
+ * A kind outside the table reports NOT-OBSERVED with `unsupported-kind` rather
+ * than being dropped, so the estate says "chant did not look at this" instead of
+ * quietly implying it is not there. Widening the table is #1209's stated
+ * non-goal and belongs with the applier.
+ */
+import { MAPPERS } from "../op/activities/gcp-apply.js";
+const defaultHttp = async (method, url) => {
+    const res = await fetch(url, { method });
+    return { status: res.status, text: await res.text() };
+};
+/**
+ * A read that failed for a reason the caller must classify — carries the HTTP
+ * status so a 404 (absent) is told apart from a 401/403 (no credentials) and a
+ * 5xx/network error (could not look). Mirrors `AzureReadError`.
+ */
+export class GcpReadError extends Error {
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+        this.name = "GcpReadError";
+    }
+}
+/** A 404 — the resource is genuinely absent, which is an answer, not a failure. */
+export function isNotFound(err) {
+    return err instanceof GcpReadError && err.status === 404;
+}
+/** The mapper for a CNRM kind, or undefined when chant cannot act on it. */
+export function mapperForKind(kind) {
+    return MAPPERS[kind];
+}
+/**
+ * GET one resource on the applier's transport.
+ *
+ * `declared` is the entity's own declared spec, which is what `plan()` needs to
+ * build a URL — the same input the applier hands it. Returns the parsed body,
+ * or throws {@link GcpReadError} carrying the status.
+ */
+export async function getResource(client, kind, name, declared) {
+    const mapper = mapperForKind(kind);
+    if (!mapper)
+        throw new GcpReadError(`no REST mapper for kind ${kind}`);
+    const base = (client.endpoint ?? mapper.defaultHost).replace(/\/$/, "");
+    const resource = {
+        kind,
+        metadata: { name },
+        spec: declared?.spec ?? declared ?? {},
+    };
+    let getUrl;
+    try {
+        getUrl = mapper.plan(resource, { base, project: client.project }).getUrl;
+    }
+    catch (err) {
+        // A mapper that cannot plan from the declared spec cannot produce a URL, so
+        // there is nothing to read — a hole, never an absence.
+        throw new GcpReadError(`could not build a read URL for ${kind}/${name}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const http = client.http ?? defaultHttp;
+    let res;
+    try {
+        res = await http("GET", getUrl);
+    }
+    catch (err) {
+        throw new GcpReadError(err instanceof Error ? err.message : String(err));
+    }
+    if (res.status === 404)
+        throw new GcpReadError(`${kind}/${name} not found`, 404);
+    if (res.status < 200 || res.status >= 300) {
+        throw new GcpReadError(`GET ${kind}/${name} failed with ${res.status}: ${res.text.slice(0, 200)}`, res.status);
+    }
+    try {
+        return JSON.parse(res.text);
+    }
+    catch {
+        throw new GcpReadError(`GET ${kind}/${name} returned a non-JSON body`, res.status);
+    }
+}

package/dist/codegen/docs-cli.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env tsx
+import { generateDocs } from "./docs.js";
+generateDocs({ verbose: true }).catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/codegen/docs.js

@@ -0,0 +1,115 @@
+/**
+ * GCP Config Connector documentation generator.
+ *
+ * writeDocsSite puts the pages in the main docs site under
+ * docs/src/content/docs/lexicons/gcp/ (chant #3993).
+ */
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { docsPipeline, writeDocsSite } from "@intentius/chant/codegen/docs";
+/**
+ * Extract service name from GCP resource type: "GCP::Compute::Instance" → "Compute"
+ */
+function serviceFromType(resourceType) {
+    const parts = resourceType.split("::");
+    return parts.length >= 2 ? parts[1] : "Other";
+}
+const overview = `The **GCP Config Connector** lexicon provides full support for defining Google Cloud infrastructure using chant's declarative TypeScript syntax. Resources are serialized to Config Connector YAML manifests.
+
+This lexicon is generated from the official [Config Connector CRDs](https://github.com/GoogleCloudPlatform/k8s-config-connector) and includes coverage for 300+ resource types across 80+ GCP services.
+
+New? Start with the [Getting Started](/chant/lexicons/gcp/getting-started/) guide.
+
+Install it with:
+
+\`\`\`bash
+npm install --save-dev @intentius/chant-lexicon-gcp
+\`\`\`
+
+## Quick Start
+
+\`\`\`typescript
+import { StorageBucket, IAMPolicyMember, GCP } from "@intentius/chant-lexicon-gcp";
+import { defaultAnnotations } from "@intentius/chant-lexicon-gcp";
+
+export const annotations = defaultAnnotations({
+  "cnrm.cloud.google.com/project-id": GCP.ProjectId,
+});
+
+export const bucket = new StorageBucket({
+  location: "US",
+  storageClass: "STANDARD",
+  uniformBucketLevelAccess: true,
+  versioning: { enabled: true },
+});
+\`\`\`
+
+The lexicon provides **300+ resource types** across Compute, Storage, IAM, Networking, Container, SQL, PubSub, and more, plus composites (GkeCluster, CloudRunService, CloudSqlInstance, GcsBucket, VpcNetwork, PubSubPipeline, CloudFunctionWithTrigger, PrivateService, ManagedCertificate, SecureProject) for common patterns.
+`;
+const outputFormat = `The GCP lexicon serializes resources into **Config Connector YAML manifests** (Kubernetes CRDs).
+
+## Building
+
+Run \`chant build\` to produce Config Connector YAML from your declarations:
+
+\`\`\`bash
+chant build
+# Writes dist/manifests.yaml
+\`\`\`
+
+The generated manifests include:
+
+- \`apiVersion\` and \`kind\` (Config Connector CRD)
+- \`metadata\` with name, labels, and annotations
+- \`spec\` with the resource configuration
+
+## Key conversions
+
+| Chant (TypeScript) | YAML output | Rule |
+|--------------------|-------------|------|
+| \`export const myBucket = new StorageBucket({...})\` | \`metadata.name: my-bucket\` | Export name → kebab-case |
+| \`defaultLabels({...})\` | Merged into all resources | Project-wide label injection |
+| \`defaultAnnotations({...})\` | Merged into all resources | Project-wide annotation injection |
+
+## Applying
+
+Apply to a Kubernetes cluster with Config Connector installed:
+
+\`\`\`bash
+# Dry run
+kubectl apply -f dist/manifests.yaml --dry-run=server
+
+# Apply
+kubectl apply -f dist/manifests.yaml
+\`\`\`
+
+## Compatibility
+
+The output is compatible with:
+- kubectl apply/diff
+- Config Connector controller on GKE
+- ArgoCD / Flux GitOps controllers
+- Kustomize (as a base)`;
+/**
+ * Generate documentation for the GCP Config Connector lexicon.
+ */
+export async function generateDocs(opts) {
+    const pkgDir = dirname(dirname(dirname(fileURLToPath(import.meta.url))));
+    const config = {
+        name: "gcp",
+        displayName: "GCP Config Connector",
+        description: "Typed constructors for GCP Config Connector resource manifests",
+        distDir: join(pkgDir, "dist"),
+        outDir: join(pkgDir, "docs"),
+        overview,
+        outputFormat,
+        serviceFromType,
+        srcDir: join(pkgDir, "src"),
+        basePath: "/chant/lexicons/gcp/",
+    };
+    const result = docsPipeline(config);
+    writeDocsSite(config, result);
+    if (opts?.verbose) {
+        console.error(`Generated docs: ${result.stats.resources} resources, ${result.stats.properties} properties, ${result.stats.services} services, ${result.stats.rules} rules`);
+    }
+}

package/dist/codegen/generate-cli.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env tsx
+/**
+ * CLI entry point for GCP lexicon generation.
+ */
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+import { generate, writeGeneratedFiles } from "./generate.js";
+// src/codegen/generate-cli.ts → dirname x3 → package root
+const pkgDir = dirname(dirname(dirname(fileURLToPath(import.meta.url))));
+const verbose = process.argv.includes("--verbose") || !process.argv.includes("--quiet");
+const force = process.argv.includes("--force");
+const result = await generate({ verbose, force });
+writeGeneratedFiles(result, pkgDir);
+console.error(`Generated ${result.resources} resources, ${result.properties} property types, ${result.enums} enums`);
+if (result.warnings.length > 0) {
+    console.error(`${result.warnings.length} warnings`);
+}

package/dist/codegen/generate.js

@@ -0,0 +1,218 @@
+/**
+ * GCP Config Connector generation pipeline — uses core generatePipeline
+ * with GCP-specific fetch, parse, naming, and generation callbacks.
+ */
+import { generatePipeline, writeGeneratedArtifacts, } from "@intentius/chant/codegen/generate";
+import { fetchCRDBundle } from "../spec/fetch.js";
+import { parseGcpCRD } from "../spec/parse.js";
+import { NamingStrategy, propertyTypeName } from "./naming.js";
+import { generateRuntimeIndex as coreGenerateRuntimeIndex, } from "@intentius/chant/codegen/generate-runtime-index";
+const gcpPipelineConfig = {
+    fetchSchemas: async (opts) => {
+        return fetchCRDBundle(opts.force);
+    },
+    parseSchema: (_typeName, data) => {
+        const results = parseGcpCRD(data);
+        // Each CRD file may contain one or more resources
+        // We return the first one; additional ones get collected in augmentResults
+        if (results.length === 0)
+            return null;
+        return results[0];
+    },
+    createNaming: (results) => new NamingStrategy(results),
+    augmentResults: (results, _opts, log) => {
+        const warnings = [];
+        log(`Total: ${results.length} GCP Config Connector resource schemas`);
+        return { results, warnings };
+    },
+    generateRegistry: (results, naming) => {
+        return generateLexiconJSON(results, naming);
+    },
+    generateTypes: (results, naming) => {
+        return generateTypeScriptDeclarations(results, naming);
+    },
+    generateRuntimeIndex: (results, naming) => {
+        return generateRuntimeIndex(results, naming);
+    },
+};
+/**
+ * Run the full GCP generation pipeline.
+ */
+export async function generate(opts = {}) {
+    return generatePipeline(gcpPipelineConfig, opts);
+}
+/**
+ * Write generated artifacts to disk.
+ */
+export function writeGeneratedFiles(result, baseDir) {
+    writeGeneratedArtifacts({
+        baseDir,
+        files: {
+            "lexicon-gcp.json": result.lexiconJSON,
+            "index.d.ts": result.typesDTS,
+            "index.ts": result.indexTS,
+            "runtime.ts": [
+                "/**",
+                " * Runtime factory constructors — re-exported from core.",
+                " */",
+                'export { createResource, createProperty } from "@intentius/chant/runtime";',
+                "",
+            ].join("\n"),
+        },
+    });
+}
+/**
+ * Extract the property-type suffix from a GCP `::` name and flatten to valid TS identifier.
+ * "GCP::Alloydb::Backup::EncryptionConfig", "GCP::Alloydb::Backup" → "EncryptionConfig"
+ * "GCP::Acm::AccessLevel::Custom::Expr", "GCP::Acm::AccessLevel" → "Custom_Expr"
+ */
+function gcpDefName(ptName, resourceType) {
+    const prefix = `${resourceType}::`;
+    const raw = ptName.startsWith(prefix) ? ptName.slice(prefix.length) : ptName.split("::").pop();
+    return raw.replace(/::/g, "_");
+}
+// ── Lexicon JSON generation ─────────────────────────────────────────
+function generateLexiconJSON(results, naming) {
+    const entries = {};
+    for (const r of results) {
+        const cfnType = r.resource.typeName;
+        const tsName = naming.resolve(cfnType);
+        if (!tsName)
+            continue;
+        const apiVersion = `${r.gvk.group}/${r.gvk.version}`;
+        entries[tsName] = {
+            resourceType: cfnType,
+            kind: "resource",
+            apiVersion,
+            gvkKind: r.gvk.kind,
+            group: r.gvk.group,
+            properties: r.resource.properties.length,
+            schema: {
+                fields: Object.fromEntries(r.resource.properties.map((p) => [p.name, {
+                        type: p.tsType,
+                        required: p.required,
+                        ...(p.enum && { enum: p.enum }),
+                        ...(p.isResourceRef && { ref: true }),
+                    }])),
+                required: r.resource.properties.filter((p) => p.required).map((p) => p.name),
+            },
+            attrs: Object.fromEntries(r.resource.attributes.map((a) => [attrKey(a.name), a.tsType])),
+        };
+        // Add property types
+        for (const pt of r.propertyTypes) {
+            const defName = gcpDefName(pt.name, cfnType);
+            const ptName = propertyTypeName(tsName, defName);
+            entries[ptName] = {
+                resourceType: `${cfnType}.${pt.specType}`,
+                kind: "property",
+            };
+        }
+    }
+    return JSON.stringify(entries, null, 2);
+}
+// ── TypeScript declarations generation ──────────────────────────────
+function generateTypeScriptDeclarations(results, naming) {
+    const lines = [
+        "/**",
+        " * GCP Config Connector resource type declarations.",
+        " *",
+        " * Auto-generated — do not edit.",
+        " */",
+        "",
+    ];
+    const emittedTypes = new Set();
+    for (const r of results) {
+        const cfnType = r.resource.typeName;
+        const tsName = naming.resolve(cfnType);
+        if (!tsName)
+            continue;
+        // Resource class interface
+        const desc = (r.resource.description ?? cfnType).replace(/\*\//g, "*\\/");
+        lines.push(`/** ${desc} */`);
+        lines.push(`export declare class ${tsName} {`);
+        lines.push(`  constructor(props: ${tsName}Props);`);
+        // Attributes
+        for (const attr of r.resource.attributes) {
+            lines.push(`  readonly ${attrKey(attr.name)}: ${attr.tsType};`);
+        }
+        lines.push(`}`);
+        lines.push("");
+        // Props interface
+        lines.push(`export interface ${tsName}Props {`);
+        for (const prop of r.resource.properties) {
+            const optional = prop.required ? "" : "?";
+            const safeName = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(prop.name) ? prop.name : JSON.stringify(prop.name);
+            const propDesc = prop.description ? `  /** ${prop.description.replace(/\*\//g, "*\\/")} */\n` : "";
+            lines.push(`${propDesc}  ${safeName}${optional}: ${prop.tsType};`);
+        }
+        lines.push(`}`);
+        lines.push("");
+        // Aliases
+        for (const alias of naming.aliases(cfnType)) {
+            lines.push(`/** Alias for ${tsName} */`);
+            lines.push(`export declare const ${alias}: typeof ${tsName};`);
+            lines.push("");
+        }
+        // Property types (skip duplicates from singularization collisions)
+        for (const pt of r.propertyTypes) {
+            const defName = gcpDefName(pt.name, cfnType);
+            const ptName = propertyTypeName(tsName, defName);
+            if (emittedTypes.has(ptName))
+                continue;
+            emittedTypes.add(ptName);
+            lines.push(`export declare class ${ptName} {`);
+            lines.push(`  constructor(props: ${ptName}Props);`);
+            lines.push(`}`);
+            lines.push("");
+            lines.push(`export interface ${ptName}Props {`);
+            for (const prop of pt.properties) {
+                const optional = prop.required ? "" : "?";
+                const safeName = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(prop.name) ? prop.name : JSON.stringify(prop.name);
+                lines.push(`  ${safeName}${optional}: ${prop.tsType};`);
+            }
+            lines.push(`}`);
+            lines.push("");
+        }
+    }
+    return lines.join("\n");
+}
+// ── Runtime index generation ────────────────────────────────────────
+/** The property an attribute is read through: `status.uri` is `status_uri`, as AWS's `Endpoint.Address` is `Endpoint_Address`. */
+function attrKey(name) {
+    return name.replace(/\./g, "_");
+}
+function generateRuntimeIndex(results, naming) {
+    const resourceEntries = [];
+    const propertyEntries = [];
+    const emittedProperties = new Set();
+    for (const r of results) {
+        const cfnType = r.resource.typeName;
+        const tsName = naming.resolve(cfnType);
+        if (!tsName)
+            continue;
+        const attrs = {};
+        for (const a of r.resource.attributes) {
+            attrs[attrKey(a.name)] = a.name;
+        }
+        resourceEntries.push({ tsName, resourceType: cfnType, attrs });
+        for (const alias of naming.aliases(cfnType)) {
+            resourceEntries.push({ tsName: alias, resourceType: cfnType, attrs });
+        }
+        for (const pt of r.propertyTypes) {
+            const defName = gcpDefName(pt.name, cfnType);
+            const ptName = propertyTypeName(tsName, defName);
+            if (emittedProperties.has(ptName))
+                continue;
+            emittedProperties.add(ptName);
+            const ptCfnType = `${cfnType}.${pt.specType}`;
+            propertyEntries.push({ tsName: ptName, resourceType: ptCfnType });
+        }
+    }
+    return coreGenerateRuntimeIndex(resourceEntries, propertyEntries, {
+        lexiconName: "gcp",
+        pseudoReExports: {
+            names: ["GCP", "ProjectId", "Region", "Zone"],
+            from: "../pseudo",
+        },
+    });
+}

package/dist/codegen/naming.js

@@ -0,0 +1,164 @@
+/**
+ * GCP-specific naming configuration for the core NamingStrategy.
+ *
+ * Maps Config Connector resource types to concise TypeScript class names.
+ */
+import { NamingStrategy as CoreNamingStrategy, } from "@intentius/chant/codegen/naming";
+export { propertyTypeName, extractDefName } from "@intentius/chant/codegen/naming";
+import { gcpShortName } from "../spec/parse.js";
+/**
+ * Fixed TypeScript class names for key GCP resources.
+ */
+const priorityNames = {
+    "GCP::Compute::Instance": "ComputeInstance",
+    "GCP::Compute::Network": "VPCNetwork",
+    "GCP::Compute::Subnetwork": "Subnetwork",
+    "GCP::Compute::Firewall": "Firewall",
+    "GCP::Compute::Address": "ComputeAddress",
+    "GCP::Compute::Disk": "ComputeDisk",
+    "GCP::Compute::ForwardingRule": "ForwardingRule",
+    "GCP::Compute::HealthCheck": "ComputeHealthCheck",
+    "GCP::Compute::Router": "Router",
+    "GCP::Compute::RouterNAT": "RouterNAT",
+    "GCP::Compute::BackendService": "BackendService",
+    "GCP::Compute::TargetHTTPProxy": "TargetHTTPProxy",
+    "GCP::Compute::URLMap": "URLMap",
+    "GCP::Compute::SSLCertificate": "SSLCertificate",
+    "GCP::Storage::Bucket": "StorageBucket",
+    "GCP::Sql::Instance": "SQLInstance",
+    "GCP::Sql::Database": "SQLDatabase",
+    "GCP::Sql::User": "SQLUser",
+    "GCP::Container::Cluster": "GKECluster",
+    "GCP::Container::NodePool": "NodePool",
+    "GCP::Iam::ServiceAccount": "GCPServiceAccount",
+    "GCP::Iam::PolicyMember": "IAMPolicyMember",
+    "GCP::Iam::Policy": "IAMPolicy",
+    "GCP::Iam::AuditConfig": "IAMAuditConfig",
+    "GCP::Run::Service": "CloudRunService",
+    "GCP::Run::Job": "CloudRunJob",
+    "GCP::Pubsub::Topic": "PubSubTopic",
+    "GCP::Pubsub::Subscription": "PubSubSubscription",
+    "GCP::Bigquery::Dataset": "BigQueryDataset",
+    "GCP::Bigquery::Table": "BigQueryTable",
+    "GCP::Dns::ManagedZone": "DNSManagedZone",
+    "GCP::Dns::RecordSet": "DNSRecordSet",
+    "GCP::Logging::Metric": "LoggingMetric",
+    "GCP::Monitoring::AlertPolicy": "AlertPolicy",
+    "GCP::Secretmanager::Secret": "SecretManagerSecret",
+    "GCP::Secretmanager::SecretVersion": "SecretManagerSecretVersion",
+    "GCP::Artifactregistry::Repository": "ArtifactRegistryRepository",
+    "GCP::Cloudfunctions::Function": "CloudFunction",
+    "GCP::Kms::KeyRing": "KMSKeyRing",
+    "GCP::Kms::CryptoKey": "KMSCryptoKey",
+    "GCP::Redis::Instance": "RedisInstance",
+    "GCP::Memcache::Instance": "MemcacheInstance",
+    "GCP::Spanner::Instance": "SpannerInstance",
+    "GCP::Spanner::Database": "SpannerDatabase",
+    "GCP::Dataflow::Job": "DataflowJob",
+    "GCP::Bigtable::Instance": "BigtableInstance",
+    "GCP::Bigtable::Table": "BigtableTable",
+};
+/**
+ * Additional TypeScript names beyond the primary priority name.
+ */
+const priorityAliases = {
+    "GCP::Compute::Network": ["VPC"],
+    "GCP::Container::Cluster": ["GKE"],
+    "GCP::Storage::Bucket": ["GCSBucket"],
+    "GCP::Sql::Instance": ["CloudSQL"],
+    "GCP::Iam::ServiceAccount": ["GSA"],
+    "GCP::Run::Service": ["CloudRun"],
+};
+/**
+ * Service name abbreviations for collision-resolved names.
+ */
+const serviceAbbreviations = {
+    Compute: "Compute",
+    Storage: "Gcs",
+    Container: "Gke",
+    Sql: "Sql",
+    Iam: "Iam",
+    Bigquery: "BQ",
+    Pubsub: "PubSub",
+    Dns: "Dns",
+    Logging: "Log",
+    Monitoring: "Mon",
+    Secretmanager: "Sm",
+    Artifactregistry: "Ar",
+    Cloudfunctions: "Gcf",
+    Kms: "Kms",
+    Redis: "Redis",
+    Run: "Run",
+    Spanner: "Spanner",
+    Dataflow: "Df",
+    Bigtable: "Bt",
+    Memcache: "Mc",
+};
+const gcpNamingConfig = {
+    priorityNames,
+    priorityAliases,
+    priorityPropertyAliases: {
+        "GCP::Compute::Instance": {
+            NetworkInterface: "InstanceNetworkInterface",
+            AccessConfig: "InstanceAccessConfig",
+            AttachedDisk: "InstanceAttachedDisk",
+            Metadata: "InstanceMetadata",
+            Scheduling: "InstanceScheduling",
+            ServiceAccount: "InstanceServiceAccount",
+            ShieldedInstanceConfig: "InstanceShieldedConfig",
+        },
+        "GCP::Container::Cluster": {
+            NetworkConfig: "ClusterNetworkConfig",
+            NodeConfig: "ClusterNodeConfig",
+            IpAllocationPolicy: "ClusterIpAllocationPolicy",
+            MasterAuth: "ClusterMasterAuth",
+            PrivateClusterConfig: "ClusterPrivateConfig",
+            AddonsConfig: "ClusterAddonsConfig",
+        },
+        "GCP::Container::NodePool": {
+            NodeConfig: "NodePoolNodeConfig",
+            AutoScaling: "NodePoolAutoScaling",
+            Management: "NodePoolManagement",
+            UpgradeSettings: "NodePoolUpgradeSettings",
+        },
+        "GCP::Sql::Instance": {
+            IpConfiguration: "SqlIpConfiguration",
+            BackupConfiguration: "SqlBackupConfiguration",
+            DatabaseFlags: "SqlDatabaseFlags",
+            Settings: "SqlSettings",
+        },
+        "GCP::Storage::Bucket": {
+            Encryption: "BucketEncryption",
+            Versioning: "BucketVersioning",
+            Lifecycle: "BucketLifecycle",
+            LifecycleRule: "BucketLifecycleRule",
+            Logging: "BucketLogging",
+            RetentionPolicy: "BucketRetentionPolicy",
+        },
+        "GCP::Compute::Network": {
+            RoutingConfig: "NetworkRoutingConfig",
+        },
+        "GCP::Compute::Subnetwork": {
+            LogConfig: "SubnetworkLogConfig",
+            SecondaryIpRange: "SubnetworkSecondaryIpRange",
+        },
+    },
+    serviceAbbreviations,
+    shortName: gcpShortName,
+    serviceName: (typeName) => {
+        const parts = typeName.split("::");
+        return parts.length >= 2 ? parts[1] : "Other";
+    },
+};
+/**
+ * GCP-specific NamingStrategy — wraps the core algorithm with GCP data tables.
+ */
+export class NamingStrategy extends CoreNamingStrategy {
+    constructor(results) {
+        const inputs = results.map((r) => ({
+            typeName: r.resource.typeName,
+            propertyTypes: r.propertyTypes,
+        }));
+        super(inputs, gcpNamingConfig);
+    }
+}