GCP.Apigee reference
AnalyticsDatastore
Section titled “AnalyticsDatastore”Source:
packages/gcp/src/Apigee/AnalyticsDatastore.ts
An Apigee analytics datastore — an export target (Cloud Storage or BigQuery) for organization analytics.
Datastores have no labels field. Alchemy stamps ownership into
displayName so list / nuke can find them. The datastore id is
server-assigned.
AnalyticsDatastore: Creating a Datastore
Section titled “AnalyticsDatastore: Creating a Datastore”GCS export target
const store = yield* GCP.Apigee.AnalyticsDatastore("Exports", { targetType: "gcs", datastoreConfig: { projectId: "my-project", bucketName: "apigee-analytics", path: "exports", },});BigQuery export target
const store = yield* GCP.Apigee.AnalyticsDatastore("BqExports", { targetType: "bigquery", datastoreConfig: { projectId: "my-project", datasetName: "apigee", tablePrefix: "analytics", },});Source:
packages/gcp/src/Apigee/Api.ts
An Apigee API proxy. The proxy is not serving traffic until a revision is deployed to an environment.
Labels (alchemy-stack / alchemy-stage / alchemy-id) stamp
ownership so list / nuke can find proxies. Changing apiId or
organizationId replaces the proxy.
Api: Creating a Proxy
Section titled “Api: Creating a Proxy”Generated name
const proxy = yield* GCP.Apigee.Api("Orders", {});Explicit id and labels
const proxy = yield* GCP.Apigee.Api("Orders", { apiId: "orders-v1", labels: { env: "prod" },});Api: Looking up an existing api
Section titled “Api: Looking up an existing api”Api.lookup references an api Alchemy doesn’t manage (created in the
console or by another stack). It is read during plan/deploy, never
created, updated or deleted, and binds like a declared api.
const api = GCP.Apigee.Api.lookup({ apiId: "my-api" });ApimServiceExtension
Section titled “ApimServiceExtension”Source:
packages/gcp/src/Apigee/ApimServiceExtension.ts
An APIM service extension that routes load-balancer traffic to an existing Apigee X instance.
Service extensions have no labels or description. Alchemy stamps
ownership as a never-matching alchown extension so list / nuke
can find them. Changing the id or organization replaces the resource.
ApimServiceExtension: Creating a Service Extension
Section titled “ApimServiceExtension: Creating a Service Extension”const extension = yield* GCP.Apigee.ApimServiceExtension("Edge", { lbForwardingRule: "projects/my-project/regions/us-central1/forwardingRules/https", network: "projects/my-project/global/networks/default", networkConfigs: [{ region: "us-central1", subnet: "projects/my-project/regions/us-central1/subnetworks/default", }], extensionProcessor: "ext-processor",});ApimServiceExtension: Looking up an existing apim service extension
Section titled “ApimServiceExtension: Looking up an existing apim service extension”ApimServiceExtension.lookup references an apim service extension
Alchemy doesn’t manage (created in the console or by another stack). It
is read during plan/deploy, never created, updated or deleted, and binds
like a declared apim service extension.
const apimServiceExtension = GCP.Apigee.ApimServiceExtension.lookup({ apimServiceExtensionId: "my-apim-service-extension",});Apiproduct
Section titled “Apiproduct”Source:
packages/gcp/src/Apigee/Apiproduct.ts
An Apigee API product — a bundle of proxies, resources, quota, and metadata delivered to developers.
Products have no labels field. Alchemy stamps ownership into
attributes (alchemy-stack / alchemy-stage / alchemy-id) so
list / nuke can find them. The internal name
is immutable.
Apiproduct: Creating an API Product
Section titled “Apiproduct: Creating an API Product”Generated name, auto-approved
const product = yield* GCP.Apigee.Apiproduct("Public", { displayName: "Public APIs", approvalType: "auto",});Bound to proxies and a quota
const product = yield* GCP.Apigee.Apiproduct("Orders", { displayName: "Orders", environments: ["prod"], proxies: ["orders-v1"], approvalType: "auto", quota: "1000", quotaInterval: "1", quotaTimeUnit: "hour",});Apiproduct: Looking up an existing apiproduct
Section titled “Apiproduct: Looking up an existing apiproduct”Apiproduct.lookup references an apiproduct Alchemy doesn’t manage
(created in the console or by another stack). It is read during
plan/deploy, never created, updated or deleted, and binds like a declared
apiproduct.
const apiproduct = GCP.Apigee.Apiproduct.lookup({ apiproductId: "my-apiproduct",});ApiproductsRateplan
Section titled “ApiproductsRateplan”Source:
packages/gcp/src/Apigee/ApiproductsRateplan.ts
An Apigee rate plan attached to an API product for monetization.
Rate plans have no labels field and their text is shown to portal
developers, so Alchemy tracks a plan only by the server-assigned id in
its state; nuke cannot discover plans. Only one plan per product can be PUBLISHED.
ApiproductsRateplan: Creating a Rate Plan
Section titled “ApiproductsRateplan: Creating a Rate Plan”const plan = yield* GCP.Apigee.ApiproductsRateplan("Standard", { apiproduct: product.apiproductId, displayName: "Standard", billingPeriod: "MONTHLY", currencyCode: "USD", state: "DRAFT",});ApisKeyvaluemap
Section titled “ApisKeyvaluemap”Source:
packages/gcp/src/Apigee/ApisKeyvaluemap.ts
An API-proxy-scoped Apigee key value map.
KVMs have no labels and no List API. Alchemy writes an ownership
sentinel entry (__alchemy) so read can distinguish owned maps.
list walks alchemy-labeled API proxies and looks up a map whose id
matches the proxy id plus any map named on the sentinel of that
lookup; maps whose ids cannot be discovered are still deleted with
the parent proxy. Changing mapId, api, or organizationId
replaces the map.
ApisKeyvaluemap: Creating a Map
Section titled “ApisKeyvaluemap: Creating a Map”const map = yield* GCP.Apigee.ApisKeyvaluemap("Config", { api: proxy.apiId,});ApisKeyvaluemap: Looking up an existing apis keyvaluemap
Section titled “ApisKeyvaluemap: Looking up an existing apis keyvaluemap”ApisKeyvaluemap.lookup references an apis keyvaluemap Alchemy doesn’t
manage (created in the console or by another stack). It is read during
plan/deploy, never created, updated or deleted, and binds like a declared
apis keyvaluemap.
const apisKeyvaluemap = GCP.Apigee.ApisKeyvaluemap.lookup({ mapId: "my-map", api: "my-api",});ApisKeyvaluemapsEntry
Section titled “ApisKeyvaluemapsEntry”Source:
packages/gcp/src/Apigee/ApisKeyvaluemapsEntry.ts
A key/value entry in an API-proxy-scoped Apigee key value map.
Entries have no labels. Alchemy treats entries inside a map that
carries the __alchemy sentinel as owned so list / nuke can find
them. Changing entryId, map, api, or organizationId replaces
the entry. The reserved key __alchemy is used for map ownership and
is not a user entry.
ApisKeyvaluemapsEntry: Creating an Entry
Section titled “ApisKeyvaluemapsEntry: Creating an Entry”const entry = yield* GCP.Apigee.ApisKeyvaluemapsEntry("Timeout", { api: proxy.apiId, map: map.mapId, entryId: "timeout-ms", value: "5000",});Appgroup
Section titled “Appgroup”Source:
packages/gcp/src/Apigee/Appgroup.ts
An Apigee AppGroup — a logical grouping of apps that share credentials.
AppGroups have no labels field. Alchemy stamps ownership into
attributes so list / nuke can find them. The name is immutable.
Appgroup: Creating an AppGroup
Section titled “Appgroup: Creating an AppGroup”Generated name
const group = yield* GCP.Apigee.Appgroup("Partners", { displayName: "Partners", email: "partners@example.com",});Inactive group
const group = yield* GCP.Apigee.Appgroup("Partners", { appgroupId: "partners", status: "inactive",});Appgroup: Looking up an existing appgroup
Section titled “Appgroup: Looking up an existing appgroup”Appgroup.lookup references an appgroup Alchemy doesn’t manage (created
in the console or by another stack). It is read during plan/deploy, never
created, updated or deleted, and binds like a declared appgroup.
const appgroup = GCP.Apigee.Appgroup.lookup({ appgroupId: "my-appgroup" });AppgroupsApp
Section titled “AppgroupsApp”Source:
packages/gcp/src/Apigee/AppgroupsApp.ts
An app belonging to an Apigee AppGroup, with auto-generated API keys for the associated API products.
Apps have no labels field. Alchemy stamps ownership into attributes
so list / nuke can find them. The app name is immutable.
AppgroupsApp: Creating an App
Section titled “AppgroupsApp: Creating an App”const app = yield* GCP.Apigee.AppgroupsApp("Mobile", { appgroup: group.appgroupId, apiProducts: [product.apiproductId], callbackUrl: "https://example.com/oauth",});AppgroupsApp: Looking up an existing appgroups app
Section titled “AppgroupsApp: Looking up an existing appgroups app”AppgroupsApp.lookup references an appgroups app Alchemy doesn’t manage
(created in the console or by another stack). It is read during
plan/deploy, never created, updated or deleted, and binds like a declared
appgroups app.
const appgroupsApp = GCP.Apigee.AppgroupsApp.lookup({ appId: "my-app", appgroup: "my-appgroup",});AppgroupsAppsKey
Section titled “AppgroupsAppsKey”Source:
packages/gcp/src/Apigee/AppgroupsAppsKey.ts
A custom consumer key and secret for an Apigee AppGroup app.
Apigee keys have no labels field, so Alchemy stamps ownership into
custom attributes for list / nuke. The consumer key is identity —
changing it replaces the key. Scopes, API products, status, and
attributes update in place.
AppgroupsAppsKey: Creating an AppGroup App Key
Section titled “AppgroupsAppsKey: Creating an AppGroup App Key”Generated key under an AppGroup app
const key = yield* GCP.Apigee.AppgroupsAppsKey("GroupKey", { appGroup: "partners", app: "partner-portal",});Custom key and secret
const key = yield* GCP.Apigee.AppgroupsAppsKey("GroupKey", { appGroup: "partners", app: "partner-portal", consumerKey: "partner-key", consumerSecret: "partner-secret",});Datacollector
Section titled “Datacollector”Source:
packages/gcp/src/Apigee/Datacollector.ts
An Apigee data collector used to capture custom analytics dimensions.
Apigee collectors have no labels field, so Alchemy stamps ownership into
the description for list / nuke. Name and type are identity — changing
dataCollectorId or type replaces the collector. Description updates
in place.
Datacollector: Creating a Data Collector
Section titled “Datacollector: Creating a Data Collector”Generated dc_ name
const collector = yield* GCP.Apigee.Datacollector("Latency", { type: "INTEGER",});Explicit id and description
const collector = yield* GCP.Apigee.Datacollector("Latency", { dataCollectorId: "dc_proxy_latency", type: "INTEGER", description: "proxy latency in milliseconds",});Datacollector: Looking up an existing datacollector
Section titled “Datacollector: Looking up an existing datacollector”Datacollector.lookup references a datacollector Alchemy doesn’t manage
(created in the console or by another stack). It is read during
plan/deploy, never created, updated or deleted, and binds like a declared
datacollector.
const datacollector = GCP.Apigee.Datacollector.lookup({ dataCollectorId: "my-data-collector",});Developer
Section titled “Developer”Source:
packages/gcp/src/Apigee/Developer.ts
An Apigee developer that can register apps and obtain API keys.
Apigee developers have no labels field, so Alchemy stamps ownership into
custom attributes for list / nuke. Email is identity — changing email
replaces the developer. Name, attributes, and access type update in place.
Developer: Creating a Developer
Section titled “Developer: Creating a Developer”Generated email
const developer = yield* GCP.Apigee.Developer("Owner", { firstName: "Ada", lastName: "Lovelace",});Explicit email and attributes
const developer = yield* GCP.Apigee.Developer("Owner", { email: "ada@example.com", firstName: "Ada", lastName: "Lovelace", userName: "ada", attributes: { team: "platform" },});Developer: Looking up an existing developer
Section titled “Developer: Looking up an existing developer”Developer.lookup references a developer Alchemy doesn’t manage (created
in the console or by another stack). It is read during plan/deploy, never
created, updated or deleted, and binds like a declared developer.
const developer = GCP.Apigee.Developer.lookup({ email: "my-email" });DevelopersApp
Section titled “DevelopersApp”Source:
packages/gcp/src/Apigee/DevelopersApp.ts
An Apigee app owned by a developer, used to obtain API keys.
Apigee developer apps have no labels field, so Alchemy stamps ownership
into custom attributes for list / nuke. Name and parent developer are
identity — changing appName or developer replaces the app. Callback
URL, products, scopes, status, and attributes update in place.
DevelopersApp: Creating a Developer App
Section titled “DevelopersApp: Creating a Developer App”App under an existing developer
const app = yield* GCP.Apigee.DevelopersApp("Portal", { developer: developer.email, callbackUrl: "https://example.com/callback",});Named app with attributes
const app = yield* GCP.Apigee.DevelopersApp("Portal", { developer: "ada@example.com", appName: "portal-app", attributes: { team: "platform" },});DevelopersApp: Looking up an existing developers app
Section titled “DevelopersApp: Looking up an existing developers app”DevelopersApp.lookup references a developers app Alchemy doesn’t manage
(created in the console or by another stack). It is read during
plan/deploy, never created, updated or deleted, and binds like a declared
developers app.
const developersApp = GCP.Apigee.DevelopersApp.lookup({ appName: "my-app", developer: "my-developer",});DevelopersAppsKey
Section titled “DevelopersAppsKey”Source:
packages/gcp/src/Apigee/DevelopersAppsKey.ts
A custom consumer key and secret for an Apigee developer app.
Apigee keys have no labels field, so Alchemy stamps ownership into
custom attributes for list / nuke. The consumer key is identity —
changing it replaces the key. Scopes, API products, status, and
attributes update in place.
DevelopersAppsKey: Creating a Developer App Key
Section titled “DevelopersAppsKey: Creating a Developer App Key”Generated key under a developer app
const key = yield* GCP.Apigee.DevelopersAppsKey("PortalKey", { developer: developer.email, app: app.appName,});Custom key and secret
const key = yield* GCP.Apigee.DevelopersAppsKey("PortalKey", { developer: "ada@example.com", app: "portal-app", consumerKey: "portal-key", consumerSecret: "portal-secret", status: "approved",});DnsZone
Section titled “DnsZone”Source:
packages/gcp/src/Apigee/DnsZone.ts
An Apigee DNS peering zone that lets runtime instances resolve hostnames in a peered VPC.
Apigee DNS zones have no labels field, so Alchemy stamps ownership into
the description for list / nuke. Name, domain, and peering config are
identity — changing them replaces the zone. Description updates in place
only if the API later exposes a patch; today the resource is
existence-only besides identity.
DnsZone: Creating a DNS Zone
Section titled “DnsZone: Creating a DNS Zone”const zone = yield* GCP.Apigee.DnsZone("PrivateDns", { domain: "internal.example.com.", peeringConfig: { targetNetworkId: "default", targetProjectId: "my-project", }, description: "runtime DNS peering",});DnsZone: Looking up an existing dns zone
Section titled “DnsZone: Looking up an existing dns zone”DnsZone.lookup references a dns zone Alchemy doesn’t manage (created in
the console or by another stack). It is read during plan/deploy, never
created, updated or deleted, and binds like a declared dns zone.
const dnsZone = GCP.Apigee.DnsZone.lookup({ dnsZoneId: "my-dns-zone" });EndpointAttachment
Section titled “EndpointAttachment”Source:
packages/gcp/src/Apigee/EndpointAttachment.ts
An Apigee endpoint attachment for southbound Private Service Connect.
The API has no labels or description, so Alchemy prefixes generated ids
with alc- so list / nuke can find them. All properties are identity —
changing any of them replaces the attachment.
EndpointAttachment: Creating an Endpoint Attachment
Section titled “EndpointAttachment: Creating an Endpoint Attachment”const attachment = yield* GCP.Apigee.EndpointAttachment("Backend", { location: "us-central1", serviceAttachment: "projects/my-project/regions/us-central1/serviceAttachments/backend",});EndpointAttachment: Looking up an existing endpoint attachment
Section titled “EndpointAttachment: Looking up an existing endpoint attachment”EndpointAttachment.lookup references an endpoint attachment Alchemy
doesn’t manage (created in the console or by another stack). It is read
during plan/deploy, never created, updated or deleted, and binds like a
declared endpoint attachment.
const endpointAttachment = GCP.Apigee.EndpointAttachment.lookup({ endpointAttachmentId: "my-endpoint-attachment",});Envgroup
Section titled “Envgroup”Source:
packages/gcp/src/Apigee/Envgroup.ts
An Apigee environment group that maps hostnames to one or more environments.
The API has no labels or description, so Alchemy identifies its groups
by the generated envgroupId: read reports a group with an explicit
envgroupId as unowned (adopt it with --adopt), and nuke cannot
discover groups. Name is identity — changing envgroupId replaces the
group. Hostnames update in place.
Envgroup: Creating an Environment Group
Section titled “Envgroup: Creating an Environment Group”Group with a hostname
const group = yield* GCP.Apigee.Envgroup("Api", { hostnames: ["api.example.com"],});Named group
const group = yield* GCP.Apigee.Envgroup("Api", { envgroupId: "prod-group", hostnames: ["api.example.com", "api.example.net"],});Envgroup: Looking up an existing envgroup
Section titled “Envgroup: Looking up an existing envgroup”Envgroup.lookup references an envgroup Alchemy doesn’t manage (created
in the console or by another stack). It is read during plan/deploy, never
created, updated or deleted, and binds like a declared envgroup.
const envgroup = GCP.Apigee.Envgroup.lookup({ envgroupId: "my-envgroup" });EnvgroupsAttachment
Section titled “EnvgroupsAttachment”Source:
packages/gcp/src/Apigee/EnvgroupsAttachment.ts
An attachment of an Apigee environment to an environment group.
Existence-only: the identity is the (envgroup, environment) pair. The
API has no labels or description, so list / nuke returns attachments
whose attached environment carries an Alchemy description marker.
EnvgroupsAttachment: Creating an Environment Group Attachment
Section titled “EnvgroupsAttachment: Creating an Environment Group Attachment”const attachment = yield* GCP.Apigee.EnvgroupsAttachment("ProdApi", { envgroup: group.envgroupId, environment: environment.environmentId,});Environment
Section titled “Environment”Source:
packages/gcp/src/Apigee/Environment.ts
An Apigee environment that hosts API proxies and shared flows.
Apigee environments have no labels field, so Alchemy stamps ownership
into the description (and properties) for list / nuke. Name, type,
API proxy type, and deployment type are identity — changing them
replaces the environment. Display name, description, forward proxy,
IP resolution, properties, and node config update in place.
Environment: Creating an Environment
Section titled “Environment: Creating an Environment”Generated name
const environment = yield* GCP.Apigee.Environment("Runtime", { displayName: "runtime",});Named environment with description
const environment = yield* GCP.Apigee.Environment("Runtime", { environmentId: "prod", displayName: "Production", description: "production API runtime", apiProxyType: "PROGRAMMABLE",});Environment: Looking up an existing environment
Section titled “Environment: Looking up an existing environment”Environment.lookup references an environment Alchemy doesn’t manage
(created in the console or by another stack). It is read during
plan/deploy, never created, updated or deleted, and binds like a declared
environment.
const environment = GCP.Apigee.Environment.lookup({ environmentId: "my-environment",});EnvironmentsApisRevisionsDebugsession
Section titled “EnvironmentsApisRevisionsDebugsession”Source:
packages/gcp/src/Apigee/EnvironmentsApisRevisionsDebugsession.ts
An Apigee debug session for a deployed API proxy revision.
Sessions are short-lived (max 15s validity) and have no labels.
Alchemy generates a stable session id from the stack so list can
match it. Delete clears captured data (debugsessions.deleteData);
it does not cancel an already-running session.
EnvironmentsApisRevisionsDebugsession: Creating a Debug Session
Section titled “EnvironmentsApisRevisionsDebugsession: Creating a Debug Session”const session = yield* GCP.Apigee.EnvironmentsApisRevisionsDebugsession("Trace", { environment: "eval", api: "hello", revision: "1", count: 10,});EnvironmentsArchiveDeployment
Section titled “EnvironmentsArchiveDeployment”Source:
packages/gcp/src/Apigee/EnvironmentsArchiveDeployment.ts
An Apigee archive deployment — a zip of API proxies deployed as a unit to an archive-mode environment.
Labels carry Alchemy ownership so list / nuke can find leaked rows.
Name is identity; labels update in place. Creating an archive is a
long-running operation.
EnvironmentsArchiveDeployment: Creating an Archive Deployment
Section titled “EnvironmentsArchiveDeployment: Creating an Archive Deployment”const archive = yield* GCP.Apigee.EnvironmentsArchiveDeployment("Bundle", { environment: "eval", archiveZip: zipBase64, labels: { env: "test" },});EnvironmentsArchiveDeployment: Looking up an existing environments archive deployment
Section titled “EnvironmentsArchiveDeployment: Looking up an existing environments archive deployment”EnvironmentsArchiveDeployment.lookup references an environments archive
deployment Alchemy doesn’t manage (created in the console or by another
stack). It is read during plan/deploy, never created, updated or deleted,
and binds like a declared environments archive deployment.
const environmentsArchiveDeployment = GCP.Apigee.EnvironmentsArchiveDeployment.lookup({ archiveDeploymentId: "my-archive-deployment", environment: "my-environment",});EnvironmentsKeystore
Section titled “EnvironmentsKeystore”Source:
packages/gcp/src/Apigee/EnvironmentsKeystore.ts
An Apigee environment keystore or truststore for TLS certificates.
Keystores have no labels or description, so list enumerates every
keystore in Apigee environments mapped to this GCP project for
pnpm nuke:gcp. Name is identity — changing keystoreId,
organization, or environment replaces the keystore. Aliases are
managed by EnvironmentsKeystoresAlias.
EnvironmentsKeystore: Creating a Keystore
Section titled “EnvironmentsKeystore: Creating a Keystore”Generated name
const keystore = yield* GCP.Apigee.EnvironmentsKeystore("Tls", { environment: "eval",});Named keystore
const keystore = yield* GCP.Apigee.EnvironmentsKeystore("Tls", { environment: "eval", keystoreId: "app-tls",});EnvironmentsKeystore: Looking up an existing environments keystore
Section titled “EnvironmentsKeystore: Looking up an existing environments keystore”EnvironmentsKeystore.lookup references an environments keystore Alchemy
doesn’t manage (created in the console or by another stack). It is read
during plan/deploy, never created, updated or deleted, and binds like a
declared environments keystore.
const environmentsKeystore = GCP.Apigee.EnvironmentsKeystore.lookup({ keystoreId: "my-keystore", environment: "my-environment",});EnvironmentsKeystoresAlias
Section titled “EnvironmentsKeystoresAlias”Source:
packages/gcp/src/Apigee/EnvironmentsKeystoresAlias.ts
An alias in an Apigee environment keystore — a certificate or key/certificate pair used for TLS.
Aliases have no labels or description, so list enumerates every alias
in keystores of Apigee environments mapped to this GCP project.
Name, keystore, organization, and environment are identity. Certificate
material can be rotated with an in-place update.
EnvironmentsKeystoresAlias: Creating a Self-Signed Alias
Section titled “EnvironmentsKeystoresAlias: Creating a Self-Signed Alias”const keystore = yield* GCP.Apigee.EnvironmentsKeystore("Tls", { environment: "eval",});const alias = yield* GCP.Apigee.EnvironmentsKeystoresAlias("Server", { environment: "eval", keystore: keystore.keystoreId, subject: { commonName: "api.example.com" },});EnvironmentsKeystoresAlias: Looking up an existing environments keystores alias
Section titled “EnvironmentsKeystoresAlias: Looking up an existing environments keystores alias”EnvironmentsKeystoresAlias.lookup references an environments keystores
alias Alchemy doesn’t manage (created in the console or by another
stack). It is read during plan/deploy, never created, updated or deleted,
and binds like a declared environments keystores alias.
const environmentsKeystoresAlias = GCP.Apigee.EnvironmentsKeystoresAlias.lookup({ aliasId: "my-alias", environment: "my-environment", keystore: "my-keystore",});EnvironmentsKeyvaluemap
Section titled “EnvironmentsKeyvaluemap”Source:
packages/gcp/src/Apigee/EnvironmentsKeyvaluemap.ts
An environment-scoped Apigee key value map.
Maps have no labels or description, so list enumerates every map in
Apigee environments mapped to this GCP project. Name is identity.
encrypted is create-only (always true on Apigee X); maskedValues
updates in place.
EnvironmentsKeyvaluemap: Creating a Map
Section titled “EnvironmentsKeyvaluemap: Creating a Map”Generated name
const map = yield* GCP.Apigee.EnvironmentsKeyvaluemap("Config", { environment: "eval",});Named map with masked values
const map = yield* GCP.Apigee.EnvironmentsKeyvaluemap("Config", { environment: "eval", keyvaluemapId: "app-config", maskedValues: true,});EnvironmentsKeyvaluemap: Looking up an existing environments keyvaluemap
Section titled “EnvironmentsKeyvaluemap: Looking up an existing environments keyvaluemap”EnvironmentsKeyvaluemap.lookup references an environments keyvaluemap
Alchemy doesn’t manage (created in the console or by another stack). It
is read during plan/deploy, never created, updated or deleted, and binds
like a declared environments keyvaluemap.
const environmentsKeyvaluemap = GCP.Apigee.EnvironmentsKeyvaluemap.lookup({ keyvaluemapId: "my-keyvaluemap", environment: "my-environment",});EnvironmentsKeyvaluemapsEntry
Section titled “EnvironmentsKeyvaluemapsEntry”Source:
packages/gcp/src/Apigee/EnvironmentsKeyvaluemapsEntry.ts
An entry in an environment-scoped Apigee key value map.
Entries have no labels. list walks every map in Apigee environments
mapped to this GCP project. Key, map, organization, and environment are
identity; value updates in place.
EnvironmentsKeyvaluemapsEntry: Creating an Entry
Section titled “EnvironmentsKeyvaluemapsEntry: Creating an Entry”const map = yield* GCP.Apigee.EnvironmentsKeyvaluemap("Config", { environment: "eval",});const entry = yield* GCP.Apigee.EnvironmentsKeyvaluemapsEntry("ApiKey", { environment: "eval", keyvaluemap: map.keyvaluemapId, value: "secret",});EnvironmentsReference
Section titled “EnvironmentsReference”Source:
packages/gcp/src/Apigee/EnvironmentsReference.ts
An Apigee environment reference to a keystore or truststore.
References have no labels, so Alchemy stamps ownership into
description for list / nuke. Name is identity; refers,
resourceType, and description update in place.
EnvironmentsReference: Creating a Reference
Section titled “EnvironmentsReference: Creating a Reference”const keystore = yield* GCP.Apigee.EnvironmentsKeystore("Tls", { environment: "eval",});const reference = yield* GCP.Apigee.EnvironmentsReference("TlsRef", { environment: "eval", refers: keystore.keystoreId, resourceType: "KeyStore",});EnvironmentsReference: Looking up an existing environments reference
Section titled “EnvironmentsReference: Looking up an existing environments reference”EnvironmentsReference.lookup references an environments reference
Alchemy doesn’t manage (created in the console or by another stack). It
is read during plan/deploy, never created, updated or deleted, and binds
like a declared environments reference.
const environmentsReference = GCP.Apigee.EnvironmentsReference.lookup({ referenceId: "my-reference", environment: "my-environment",});EnvironmentsResourcefile
Section titled “EnvironmentsResourcefile”Source:
packages/gcp/src/Apigee/EnvironmentsResourcefile.ts
An environment-scoped Apigee resource file (JavaScript, Java, XSL, …).
Resource files have no labels. list enumerates files in Apigee
environments mapped to this GCP project. Type and name are identity;
content updates in place.
EnvironmentsResourcefile: Creating a JavaScript File
Section titled “EnvironmentsResourcefile: Creating a JavaScript File”const file = yield* GCP.Apigee.EnvironmentsResourcefile("Helper", { environment: "eval", fileType: "js", content: "function helper() { return 1; }",});EnvironmentsResourcefile: Looking up an existing environments resourcefile
Section titled “EnvironmentsResourcefile: Looking up an existing environments resourcefile”EnvironmentsResourcefile.lookup references an environments resourcefile
Alchemy doesn’t manage (created in the console or by another stack). It
is read during plan/deploy, never created, updated or deleted, and binds
like a declared environments resourcefile.
const environmentsResourcefile = GCP.Apigee.EnvironmentsResourcefile.lookup({ fileId: "my-file", environment: "my-environment",});EnvironmentsSecurityAction
Section titled “EnvironmentsSecurityAction”Source:
packages/gcp/src/Apigee/EnvironmentsSecurityAction.ts
An environment-level Apigee SecurityAction — allow, deny, or flag requests that match a condition.
Security actions have no labels, so Alchemy stamps ownership into
description for list / nuke. Name is identity; description, state,
conditions, and the allow/deny/flag payload update in place.
EnvironmentsSecurityAction: Creating a Deny Action
Section titled “EnvironmentsSecurityAction: Creating a Deny Action”const action = yield* GCP.Apigee.EnvironmentsSecurityAction("BlockProbe", { environment: "eval", conditionConfig: { ipAddressRanges: ["192.0.2.1"] }, deny: { responseCode: 403 },});EnvironmentsSecurityAction: Looking up an existing environments security action
Section titled “EnvironmentsSecurityAction: Looking up an existing environments security action”EnvironmentsSecurityAction.lookup references an environments security
action Alchemy doesn’t manage (created in the console or by another
stack). It is read during plan/deploy, never created, updated or deleted,
and binds like a declared environments security action.
const environmentsSecurityAction = GCP.Apigee.EnvironmentsSecurityAction.lookup({ securityActionId: "my-security-action", environment: "my-environment",});EnvironmentsTargetserver
Section titled “EnvironmentsTargetserver”Source:
packages/gcp/src/Apigee/EnvironmentsTargetserver.ts
An Apigee environment TargetServer — a named backend host:port used by proxy TargetEndpoints.
Target servers have no labels, so Alchemy stamps ownership into
description for list / nuke. Name and protocol are identity; host,
port, enabled flag, description, and TLS settings update in place.
EnvironmentsTargetserver: Creating a Target Server
Section titled “EnvironmentsTargetserver: Creating a Target Server”const backend = yield* GCP.Apigee.EnvironmentsTargetserver("Api", { environment: "eval", host: "backend.example.com", port: 443, protocol: "HTTP", sSLInfo: { enabled: true },});EnvironmentsTargetserver: Looking up an existing environments targetserver
Section titled “EnvironmentsTargetserver: Looking up an existing environments targetserver”EnvironmentsTargetserver.lookup references an environments targetserver
Alchemy doesn’t manage (created in the console or by another stack). It
is read during plan/deploy, never created, updated or deleted, and binds
like a declared environments targetserver.
const environmentsTargetserver = GCP.Apigee.EnvironmentsTargetserver.lookup({ targetserverId: "my-targetserver", environment: "my-environment",});EnvironmentsTraceConfigOverride
Section titled “EnvironmentsTraceConfigOverride”Source:
packages/gcp/src/Apigee/EnvironmentsTraceConfigOverride.ts
A distributed-trace configuration override for one API proxy in an Apigee environment.
Overrides have no labels; list enumerates every override in Apigee
environments mapped to this GCP project. The override id is assigned by
Apigee. Organization and environment are identity; apiProxy and
samplingConfig update in place.
EnvironmentsTraceConfigOverride: Creating an Override
Section titled “EnvironmentsTraceConfigOverride: Creating an Override”const override = yield* GCP.Apigee.EnvironmentsTraceConfigOverride("ProxyTrace", { environment: "eval", apiProxy: "hello", samplingConfig: { sampler: "PROBABILITY", samplingRate: 0.1 },});Instance
Section titled “Instance”Source:
packages/gcp/src/Apigee/Instance.ts
An Apigee runtime instance.
Apigee instances have no labels field, so Alchemy stamps ownership into
the description for list / nuke. Name, organization, location,
peering CIDR, IP range, and CMEK are identity — changing them replaces
the instance. Description, display name, consumer accept list, access
logging, and maintenance policy update in place.
Provisioning typically takes 20–40 minutes. Live lifecycle tests are
skipIf-gated (GCP_TEST_APIGEE_INSTANCE).
Instance: Creating an Instance
Section titled “Instance: Creating an Instance”Generated name in us-central1
const runtime = yield* GCP.Apigee.Instance("Runtime", {});Explicit id, description, and access logging
const runtime = yield* GCP.Apigee.Instance("Runtime", { instanceId: "app-runtime", location: "us-central1", description: "production runtime", accessLoggingConfig: { enabled: true, filter: "status_code >= 400", },});Instance: Updating an Instance
Section titled “Instance: Updating an Instance”const runtime = yield* GCP.Apigee.Instance("Runtime", { displayName: "app-runtime-prod", maintenanceUpdatePolicy: { maintenanceWindows: [{ day: "SUNDAY", startTime: { hours: 2, minutes: 0 }, }], },});Instance: Looking up an existing instance
Section titled “Instance: Looking up an existing instance”Instance.lookup references an instance Alchemy doesn’t manage (created
in the console or by another stack). It is read during plan/deploy, never
created, updated or deleted, and binds like a declared instance.
const instance = GCP.Apigee.Instance.lookup({ instanceId: "my-instance" });InstancesAttachment
Section titled “InstancesAttachment”Source:
packages/gcp/src/Apigee/InstancesAttachment.ts
An attachment of an Apigee environment onto a runtime instance.
Attachments have no labels or description. list enumerates
attachments on alchemy-owned instances so pnpm nuke:gcp can find
leaked rows. Organization, instance, and environment are identity —
changing them replaces the attachment. There is nothing else to
update in place.
InstancesAttachment: Creating an Attachment
Section titled “InstancesAttachment: Creating an Attachment”const runtime = yield* GCP.Apigee.Instance("Runtime", {});const attachment = yield* GCP.Apigee.InstancesAttachment("Eval", { instance: runtime.name, environment: "eval",});InstancesNatAddress
Section titled “InstancesNatAddress”Source:
packages/gcp/src/Apigee/InstancesNatAddress.ts
A static NAT address on an Apigee runtime instance.
NAT addresses have no labels or description. list enumerates
addresses on alchemy-owned instances so pnpm nuke:gcp can find
leaked rows. Organization, instance, and name are identity — changing
them replaces the address. activate updates in place (RESERVED →
ACTIVE) and cannot be reversed.
InstancesNatAddress: Creating a NAT Address
Section titled “InstancesNatAddress: Creating a NAT Address”Reserve a NAT address on a runtime instance
const runtime = yield* GCP.Apigee.Instance("Runtime", {});const nat = yield* GCP.Apigee.InstancesNatAddress("Egress", { instance: runtime.name,});Reserve and activate
const nat = yield* GCP.Apigee.InstancesNatAddress("Egress", { instance: runtime.name, natAddressId: "app-egress", activate: true,});InstancesNatAddress: Looking up an existing instances nat address
Section titled “InstancesNatAddress: Looking up an existing instances nat address”InstancesNatAddress.lookup references an instances nat address Alchemy
doesn’t manage (created in the console or by another stack). It is read
during plan/deploy, never created, updated or deleted, and binds like a
declared instances nat address.
const instancesNatAddress = GCP.Apigee.InstancesNatAddress.lookup({ natAddressId: "my-nat-address", instance: "my-instance",});Keyvaluemap
Section titled “Keyvaluemap”Source:
packages/gcp/src/Apigee/Keyvaluemap.ts
An organization-scoped Apigee key value map.
Org-level KVMs have no labels, description, or list API. Alchemy
stamps ownership into a reserved __alchemy entry so read can
detect foreign maps, and list walks maps referenced by that entry
when the parent is known from state. mapId and organization are
identity — changing them replaces the map. maskedValues updates in
place. Entries are always encrypted on Apigee X.
Keyvaluemap: Creating a Map
Section titled “Keyvaluemap: Creating a Map”Generated name
const kv = yield* GCP.Apigee.Keyvaluemap("Config", {});Named map with masked values
const kv = yield* GCP.Apigee.Keyvaluemap("Config", { mapId: "app-config", maskedValues: true,});Keyvaluemap: Looking up an existing keyvaluemap
Section titled “Keyvaluemap: Looking up an existing keyvaluemap”Keyvaluemap.lookup references a keyvaluemap Alchemy doesn’t manage
(created in the console or by another stack). It is read during
plan/deploy, never created, updated or deleted, and binds like a declared
keyvaluemap.
const keyvaluemap = GCP.Apigee.Keyvaluemap.lookup({ mapId: "my-map" });KeyvaluemapsEntry
Section titled “KeyvaluemapsEntry”Source:
packages/gcp/src/Apigee/KeyvaluemapsEntry.ts
An organization-scoped Apigee key value map entry.
Entries have no labels field and the value is read by proxies, so
Alchemy stores it verbatim and identifies its entries by the generated
key: read reports an entry with an explicit entryId as unowned
(adopt it with --adopt). Organization, map, and key are identity —
changing them replaces the entry. value updates in place.
KeyvaluemapsEntry: Creating an Entry
Section titled “KeyvaluemapsEntry: Creating an Entry”Generated key on a map
const kv = yield* GCP.Apigee.Keyvaluemap("Config", {});const entry = yield* GCP.Apigee.KeyvaluemapsEntry("ApiKey", { map: kv.name, value: "secret-value",});Explicit key
const entry = yield* GCP.Apigee.KeyvaluemapsEntry("ApiKey", { map: kv.name, entryId: "api-key", value: "secret-value",});Organization
Section titled “Organization”Source:
packages/gcp/src/Apigee/Organization.ts
An Apigee X organization, 1:1 with a Google Cloud project.
Organizations have no labels field — Alchemy stamps ownership into
the description so list / nuke can find them. Creating an
organization is slow and entitlement-gated; live tests skip unless
GCP_TEST_APIGEE=1.
Changing organizationId, analyticsRegion, runtimeType,
billingType, or CMEK keys replaces the organization.
Organization: Creating an Organization
Section titled “Organization: Creating an Organization”Evaluation org in us-central1
const org = yield* GCP.Apigee.Organization("Org", { analyticsRegion: "us-central1", runtimeType: "CLOUD", billingType: "EVALUATION", disableVpcPeering: true,});Description and add-ons
const org = yield* GCP.Apigee.Organization("Org", { description: "api platform", addonsConfig: { monetizationConfig: { enabled: true } },});Organization: Looking up an existing organization
Section titled “Organization: Looking up an existing organization”Organization.lookup references an organization Alchemy doesn’t manage
(created in the console or by another stack). It is read during
plan/deploy, never created, updated or deleted, and binds like a declared
organization.
const organization = GCP.Apigee.Organization.lookup({});Report
Section titled “Report”Source:
packages/gcp/src/Apigee/Report.ts
An Apigee custom analytics report.
Custom reports have no labels field, so Alchemy stamps ownership into
a leading comments entry ([alchemy …]) for list / nuke. Name and
organization are identity — changing them replaces the report.
Metrics, dimensions, filter, chart type, and comments update in
place.
Report: Creating a Report
Section titled “Report: Creating a Report”Generated name, message count by proxy
const report = yield* GCP.Apigee.Report("Traffic", { metrics: [{ name: "message_count", function: "sum" }], dimensions: ["apiproxy"],});Named report with a filter
const report = yield* GCP.Apigee.Report("Errors", { reportId: "app-errors", displayName: "application errors", metrics: [{ name: "error_count", function: "sum" }], dimensions: ["apiproxy"], filter: "response_status_code ge 400",});Report: Looking up an existing report
Section titled “Report: Looking up an existing report”Report.lookup references a report Alchemy doesn’t manage (created in
the console or by another stack). It is read during plan/deploy, never
created, updated or deleted, and binds like a declared report.
const report = GCP.Apigee.Report.lookup({ reportId: "my-report" });SecurityFeedback
Section titled “SecurityFeedback”Source:
packages/gcp/src/Apigee/SecurityFeedback.ts
An Advanced API Security customer feedback report.
Feedback reports have no labels field, so Alchemy stamps ownership
into the comment for list / nuke. Name and organization are
identity — changing them replaces the report. Display name, type,
reason, contexts, and comment update in place.
SecurityFeedback: Creating Feedback
Section titled “SecurityFeedback: Creating Feedback”const feedback = yield* GCP.Apigee.SecurityFeedback("PenTest", { reason: "PENETRATION_TEST", feedbackContexts: [{ attribute: "ATTRIBUTE_ENVIRONMENTS", values: ["eval"], }],});SecurityFeedback: Looking up an existing security feedback
Section titled “SecurityFeedback: Looking up an existing security feedback”SecurityFeedback.lookup references a security feedback Alchemy doesn’t
manage (created in the console or by another stack). It is read during
plan/deploy, never created, updated or deleted, and binds like a declared
security feedback.
const securityFeedback = GCP.Apigee.SecurityFeedback.lookup({ securityFeedbackId: "my-security-feedback",});SecurityMonitoringCondition
Section titled “SecurityMonitoringCondition”Source:
packages/gcp/src/Apigee/SecurityMonitoringCondition.ts
An Advanced API Security monitoring condition (risk assessment v2).
Conditions have no labels or description. Generated ids are prefixed
alc- so list / nuke can distinguish Alchemy rows from
Google-defined conditions. Organization and id are identity —
changing them replaces the condition. Profile, scope, include, and
include-all update in place.
SecurityMonitoringCondition: Creating a Condition
Section titled “SecurityMonitoringCondition: Creating a Condition”const profile = yield* GCP.Apigee.SecurityProfilesV2("Default", {});const condition = yield* GCP.Apigee.SecurityMonitoringCondition("Eval", { profile: profile.name, scope: "eval", includeAllResources: true,});SecurityMonitoringCondition: Looking up an existing security monitoring condition
Section titled “SecurityMonitoringCondition: Looking up an existing security monitoring condition”SecurityMonitoringCondition.lookup references a security monitoring
condition Alchemy doesn’t manage (created in the console or by another
stack). It is read during plan/deploy, never created, updated or deleted,
and binds like a declared security monitoring condition.
const securityMonitoringCondition = GCP.Apigee.SecurityMonitoringCondition.lookup({ securityMonitoringConditionId: "my-security-monitoring-condition",});SecurityProfile
Section titled “SecurityProfile”Source:
packages/gcp/src/Apigee/SecurityProfile.ts
An Advanced API Security profile (v1).
Profiles have no labels field, so Alchemy stamps ownership into the
description for list / nuke. Name and organization are identity —
changing them replaces the profile. Description and profile config
update in place (each update creates a new revision).
SecurityProfile: Creating a Profile
Section titled “SecurityProfile: Creating a Profile”Generated name with authorization and threat categories
const profile = yield* GCP.Apigee.SecurityProfile("Baseline", { profileConfig: { categories: [{ authorization: true, threat: true }], },});Named profile
const profile = yield* GCP.Apigee.SecurityProfile("Baseline", { securityProfileId: "app-baseline", description: "default scoring", profileConfig: { categories: [{ authorization: true, cors: true, threat: true }], },});SecurityProfile: Looking up an existing security profile
Section titled “SecurityProfile: Looking up an existing security profile”SecurityProfile.lookup references a security profile Alchemy doesn’t
manage (created in the console or by another stack). It is read during
plan/deploy, never created, updated or deleted, and binds like a declared
security profile.
const securityProfile = GCP.Apigee.SecurityProfile.lookup({ securityProfileId: "my-security-profile",});SecurityProfilesV2
Section titled “SecurityProfilesV2”Source:
packages/gcp/src/Apigee/SecurityProfilesV2.ts
An Advanced API Security profile (risk assessment v2).
Profiles have no labels field, so Alchemy stamps ownership into the
description for list / nuke. Google-defined profiles are ignored by
list. Name and organization are identity — changing them replaces
the profile. Description and assessment configs update in place.
SecurityProfilesV2: Creating a Profile
Section titled “SecurityProfilesV2: Creating a Profile”Generated name with default assessments
const profile = yield* GCP.Apigee.SecurityProfilesV2("Baseline", {});Named profile with explicit weights
const profile = yield* GCP.Apigee.SecurityProfilesV2("Baseline", { securityProfileV2Id: "app-baseline", description: "production scoring", profileAssessmentConfigs: { authorization: { weight: "MAJOR" }, threat: { weight: "MODERATE" }, cors: { weight: "MINOR" }, },});SecurityProfilesV2: Looking up an existing security profiles v2
Section titled “SecurityProfilesV2: Looking up an existing security profiles v2”SecurityProfilesV2.lookup references a security profiles v2 Alchemy
doesn’t manage (created in the console or by another stack). It is read
during plan/deploy, never created, updated or deleted, and binds like a
declared security profiles v2.
const securityProfilesV2 = GCP.Apigee.SecurityProfilesV2.lookup({ securityProfileV2Id: "my-security-profile-v2",});Sharedflow
Section titled “Sharedflow”Source:
packages/gcp/src/Apigee/Sharedflow.ts
An Apigee shared flow — a reusable sequence of policies that API proxies (or other shared flows) invoke with a FlowCallout.
Shared flows have no labels field, so Alchemy stamps ownership into
the bundle Description for list / nuke. sharedflowId and
organization are identity — changing either replaces the shared
flow. Uploading a bundle or changing description creates a new
revision. space is moved in place.
Sharedflow: Creating a Shared Flow
Section titled “Sharedflow: Creating a Shared Flow”Generated empty bundle
const flow = yield* GCP.Apigee.Sharedflow("Traffic", { description: "rate limit and spike arrest",});Explicit id and space
const flow = yield* GCP.Apigee.Sharedflow("Traffic", { sharedflowId: "traffic-management", space: team.spaceId, description: "rate limit and spike arrest",});Sharedflow: Updating a Shared Flow
Section titled “Sharedflow: Updating a Shared Flow”const flow = yield* GCP.Apigee.Sharedflow("Traffic", { description: "rate limit only",});Sharedflow: Looking up an existing sharedflow
Section titled “Sharedflow: Looking up an existing sharedflow”Sharedflow.lookup references a sharedflow Alchemy doesn’t manage
(created in the console or by another stack). It is read during
plan/deploy, never created, updated or deleted, and binds like a declared
sharedflow.
const sharedflow = GCP.Apigee.Sharedflow.lookup({ sharedflowId: "my-sharedflow",});SitesApicategory
Section titled “SitesApicategory”Source:
packages/gcp/src/Apigee/SitesApicategory.ts
An API category on an Apigee integrated portal. Catalog items can be tagged with categories so portal users can browse by topic.
API categories have no labels field and the name is shown to portal
users, so Alchemy finds its category by name: read reports a
category as owned only when it carries the generated name (an explicit
name is reported as unowned — adopt it with --adopt), and nuke
cannot discover categories. siteId and organization are identity —
changing either replaces the category. The display name updates in
place.
SitesApicategory: Creating an API Category
Section titled “SitesApicategory: Creating an API Category”const category = yield* GCP.Apigee.SitesApicategory("Payments", { siteId: portal.siteId, name: "Payments",});SitesApicategory: Updating an API Category
Section titled “SitesApicategory: Updating an API Category”const category = yield* GCP.Apigee.SitesApicategory("Payments", { siteId: portal.siteId, name: "Billing",});SitesApidoc
Section titled “SitesApidoc”Source:
packages/gcp/src/Apigee/SitesApidoc.ts
An Apigee integrated-portal catalog item (apidoc). Catalog items
present API documentation and link a portal to a backing API product.
API docs have no labels field and every text field is shown to portal
users, so Alchemy finds its item by API product: read reports an item
as owned only when it carries the generated title (an explicit title
is reported as unowned — adopt it with --adopt), and nuke cannot
discover items. siteId, organization, and
apiProductName are identity — changing any of them replaces the item.
Title, description, publish flags, image, and categories update in
place.
SitesApidoc: Creating a Catalog Item
Section titled “SitesApidoc: Creating a Catalog Item”const doc = yield* GCP.Apigee.SitesApidoc("Checkout", { siteId: portal.siteId, apiProductName: product.name, title: "Checkout API", description: "place orders",});SitesApidoc: Updating a Catalog Item
Section titled “SitesApidoc: Updating a Catalog Item”const doc = yield* GCP.Apigee.SitesApidoc("Checkout", { siteId: portal.siteId, apiProductName: product.name, title: "Checkout API", description: "place orders", published: true, categoryIds: [payments.categoryId],});SitesApidoc: Looking up an existing sites apidoc
Section titled “SitesApidoc: Looking up an existing sites apidoc”SitesApidoc.lookup references a sites apidoc Alchemy doesn’t manage
(created in the console or by another stack). It is read during
plan/deploy, never created, updated or deleted, and binds like a declared
sites apidoc.
const sitesApidoc = GCP.Apigee.SitesApidoc.lookup({ siteId: "my-site", apiProductName: "my-api-product",});Source:
packages/gcp/src/Apigee/Space.ts
An Apigee organization space used to group API proxies, shared flows, and products for IAM.
Spaces have no labels field, so Alchemy stamps ownership into
displayName for list / nuke. spaceId and organization are
identity — changing either replaces the space. displayName updates
in place.
Space: Creating a Space
Section titled “Space: Creating a Space”Generated id
const space = yield* GCP.Apigee.Space("Payments", { displayName: "payments team",});Explicit id
const space = yield* GCP.Apigee.Space("Payments", { spaceId: "payments", displayName: "payments team",});Space: Updating a Space
Section titled “Space: Updating a Space”const space = yield* GCP.Apigee.Space("Payments", { displayName: "payments and billing",});Space: Looking up an existing space
Section titled “Space: Looking up an existing space”Space.lookup references a space Alchemy doesn’t manage (created in the
console or by another stack). It is read during plan/deploy, never
created, updated or deleted, and binds like a declared space.
const space = GCP.Apigee.Space.lookup({ spaceId: "my-space" });