alchemy 0.1.17 → 0.2.0

package/lib/cloudflare/kv-namespace.d.ts

@@ -1,4 +1,6 @@
-import type { Resolved } from "../output";
+import type { Context } from "../context";
+import { Resource } from "../resource";
+export declare function isKVNamespace(resource: any): resource is KVNamespace;
 /**
  * Properties for creating or updating a KV Namespace
  */
@@ -41,12 +43,12 @@ export interface KVPair {
 /**
  * Output returned after KV Namespace creation/update
  */
-export interface KVNamespaceOutput extends KVNamespaceProps {
+export interface KVNamespace extends Resource<"cloudflare::KVNamespace">, KVNamespaceProps {
     type: "kv_namespace";
     /**
      * The ID of the namespace
      */
-    id: string;
+    namespaceId: string;
     /**
      * Time at which the namespace was created
      */
@@ -56,9 +58,4 @@ export interface KVNamespaceOutput extends KVNamespaceProps {
      */
     modifiedAt: number;
 }
-export declare function isKVNamespace(resource: any): resource is Resolved<KVNamespace>;
-declare const KVNamespace_base: import("../resource").Provider<"cloudflare::KVNamespace", [props: KVNamespaceProps], KVNamespaceOutput>;
-export declare class KVNamespace extends KVNamespace_base {
-}
-export {};
-//# sourceMappingURL=kv-namespace.d.ts.map
+export declare const KVNamespace: ((this: Context<KVNamespace>, id: string, props: KVNamespaceProps) => Promise<KVNamespace>) | (((this: any, id: string, props: KVNamespaceProps) => never) & (new (_: never) => never));

package/lib/cloudflare/kv-namespace.js

@@ -1,15 +1,15 @@
 import { Resource } from "../resource";
-import { withExponentialBackoff } from "../utils/retry";
+import { withExponentialBackoff } from "../util/retry";
 import { createCloudflareApi } from "./api";
 export function isKVNamespace(resource) {
     return (resource && typeof resource === "object" && resource.type === "kv_namespace");
 }
-export class KVNamespace extends Resource("cloudflare::KVNamespace", async (ctx, props) => {
+export const KVNamespace = Resource("cloudflare::KVNamespace", async function (id, props) {
     // Create Cloudflare API client with automatic account discovery
     const api = await createCloudflareApi();
-    if (ctx.event === "delete") {
+    if (this.phase === "delete") {
         // For delete operations, we need to check if the namespace ID exists in the output
-        const namespaceId = ctx.output?.id;
+        const namespaceId = this.output?.namespaceId;
         if (namespaceId) {
             // Delete KV namespace
             const deleteResponse = await api.delete(`/accounts/${api.accountId}/storage/kv/namespaces/${namespaceId}`);
@@ -21,19 +21,20 @@ export class KVNamespace extends Resource("cloudflare::KVNamespace", async (ctx,
             }
         }
         // Return minimal output for deleted state
-        return;
+        return this.destroy();
     }
     else {
         // For create or update operations
-        // If ctx.event is "update", we expect ctx.output to exist
-        let namespaceId = ctx.event === "update" ? ctx.output?.id || "" : "";
-        let createdAt = ctx.event === "update"
-            ? ctx.output?.createdAt || Date.now()
+        // If this.phase is "update", we expect this.output to exist
+        let namespaceId = this.phase === "update" ? this.output?.namespaceId || "" : "";
+        let createdAt = this.phase === "update"
+            ? this.output?.createdAt || Date.now()
             : Date.now();
-        if (ctx.event === "update" && namespaceId) {
+        if (this.phase === "update" && namespaceId) {
             // Can't update a KV namespace title directly, just work with existing ID
         }
         else {
+            // TODO: if it already exists, then check the tags to see if we own it and continue
             // Create new KV namespace
             const createResponse = await api.post(`/accounts/${api.accountId}/storage/kv/namespaces`, {
                 title: props.title,
@@ -97,18 +98,13 @@ export class KVNamespace extends Resource("cloudflare::KVNamespace", async (ctx,
                 }
             }
         }
-        const now = Date.now();
-        // Construct the output
-        const output = {
+        return this({
             type: "kv_namespace",
-            id: namespaceId,
+            namespaceId: namespaceId,
             title: props.title,
             values: props.values,
             createdAt: createdAt,
-            modifiedAt: now,
-        };
-        return output;
+            modifiedAt: Date.now(),
+        });
     }
-}) {
-}
-//# sourceMappingURL=kv-namespace.js.map
+});

package/lib/cloudflare/state.d.ts

@@ -80,4 +80,3 @@ export declare class CloudflareStateStore implements StateStore {
      */
     private getNamespacedKey;
 }
-//# sourceMappingURL=state.d.ts.map

package/lib/cloudflare/state.js

@@ -106,4 +106,3 @@ export class CloudflareStateStore {
         return `${this.prefix}${key}`;
     }
 }
-//# sourceMappingURL=state.js.map

package/lib/cloudflare/static-site-router.d.ts

@@ -16,4 +16,3 @@ declare const _default: {
     fetch(request: Request, env: Env): Promise<Response>;
 };
 export default _default;
-//# sourceMappingURL=static-site-router.d.ts.map

package/lib/cloudflare/static-site-router.js

@@ -7,14 +7,12 @@ export default {
             isInit = true;
             for (const [key, value] of Object.entries(env)) {
                 if (key.startsWith("ROUTE_")) {
-                    console.log(key, value);
                     const service = value;
                     const patternKey = `__${key}`;
                     if (!(patternKey in env)) {
                         throw new Error(`Missing pattern key: ${patternKey}`);
                     }
                     const pattern = env[`__${key}`];
-                    console.log("pattern", pattern);
                     // TODO(sam): we should support narrowing down METHOD
                     app.all(pattern, (ctx) => service.fetch(ctx.req.raw));
                 }
@@ -25,7 +23,6 @@ export default {
 };
 // fall back to assuming the request is a static file
 app.notFound(async (ctx) => {
-    console.log("not found");
     const request = ctx.req;
     const env = ctx.env;
     const url = new URL(request.url);
@@ -107,4 +104,3 @@ app.notFound(async (ctx) => {
         return response;
     }
 });
-//# sourceMappingURL=static-site-router.js.map

package/lib/cloudflare/static-site.d.ts

@@ -1,4 +1,6 @@
-import type { BundleProps } from "../esbuild";
+import type { Context } from "../context";
+import type { BundleProps } from "../esbuild/bundle";
+import { Resource } from "../resource";
 import { Worker } from "./worker";
 /**
  * Idea of using KV with timeout inspired by SST: https://github.com/sst/sst/blob/dev/platform/src/components/cloudflare/static-site.ts
@@ -98,11 +100,7 @@ export interface StaticSiteProps {
 /**
  * Output returned after StaticSite creation/update
  */
-export interface StaticSiteOutput {
-    /**
-     * The ID of the site
-     */
-    id: string;
+export interface StaticSite extends Resource<"cloudflare::StaticSite"> {
     /**
      * The ID of the worker
      */
@@ -159,8 +157,4 @@ export interface StaticSiteOutput {
      */
     routes?: Record<string, string>;
 }
-declare const StaticSite_base: import("../resource").Provider<string, [props: StaticSiteProps], StaticSiteOutput>;
-export declare class StaticSite extends StaticSite_base {
-}
-export {};
-//# sourceMappingURL=static-site.d.ts.map
+export declare const StaticSite: ((this: Context<StaticSite>, id: string, props: StaticSiteProps) => Promise<StaticSite>) | (((this: any, id: string, props: StaticSiteProps) => never) & (new (_: never) => never));

package/lib/cloudflare/static-site.js

@@ -2,7 +2,6 @@ import { exec } from "child_process";
 import { promises as fs } from "fs";
 import path from "path";
 import { promisify } from "util";
-import { apply } from "../apply";
 import { Resource } from "../resource";
 import { createCloudflareApi } from "./api";
 import { generateAssetManifest } from "./generate-asset-manifest";
@@ -10,13 +9,13 @@ import { KVNamespace } from "./kv-namespace";
 import { uploadAssetManifest } from "./upload-asset-manifest";
 import { Worker } from "./worker";
 const __dirname = import.meta.dirname;
-export class StaticSite extends Resource("cloudflare::StaticSite", {
+export const StaticSite = Resource("cloudflare::StaticSite", {
     alwaysUpdate: true,
-}, async (ctx, props) => {
-    if (ctx.event === "delete") {
+}, async function (id, props) {
+    if (this.phase === "delete") {
         // For delete operations, we'll rely on the Worker delete to clean up
         // Return empty output for deleted state
-        return;
+        return this.destroy();
     }
     // Validate that a name is provided
     if (!props.name) {
@@ -38,14 +37,14 @@ export class StaticSite extends Resource("cloudflare::StaticSite", {
     // Run build command if provided
     if (props.build?.command) {
         try {
-            if (!ctx.quiet) {
+            if (!this.quiet) {
                 console.log(props.build.command);
             }
             const execAsync = promisify(exec);
             const { stdout, stderr } = await execAsync(props.build.command, {
                 cwd: process.cwd(),
             });
-            if (stdout && !ctx.quiet)
+            if (stdout && !this.quiet)
                 console.log(stdout);
         }
         catch (error) {
@@ -65,17 +64,14 @@ export class StaticSite extends Resource("cloudflare::StaticSite", {
     // Create Cloudflare API client with automatic account discovery
     const api = await createCloudflareApi();
     // Step 1: Create or get the KV namespace for assets
-    const kv = new KVNamespace("assets", {
-        title: `${siteName}-assets`,
-    });
-    const [{ id: kvNamespaceId }, assetManifest] = await Promise.all([
-        apply(kv, {
-            quiet: ctx.quiet,
+    const [kv, assetManifest] = await Promise.all([
+        KVNamespace("assets", {
+            title: `${siteName}-assets`,
         }),
         generateAssetManifest(props.dir),
     ]);
     // Step 3: Upload assets to KV
-    await uploadAssetManifest(api, kvNamespaceId, assetManifest);
+    await uploadAssetManifest(api, kv.namespaceId, assetManifest);
     // Prepare the bindings for the worker
     const bindings = {
         ASSETS: kv,
@@ -115,7 +111,7 @@ export class StaticSite extends Resource("cloudflare::StaticSite", {
     catch (error) {
         // TypeScript file doesn't exist, use JavaScript (default)
     }
-    const worker = new Worker("worker", {
+    const worker = await Worker("worker", {
         name: siteName,
         url: true,
         format: props.format || "esm",
@@ -133,14 +129,9 @@ export class StaticSite extends Resource("cloudflare::StaticSite", {
                 key,
             ])),
         },
-    }, 
-    // place a dependency on the namespace
-    kv.id);
-    // Get current timestamp
+    });
     const now = Date.now();
-    // Construct the output
-    const output = {
-        id: siteName,
+    return this({
         workerId: worker.id,
         name: siteName,
         directory: props.dir,
@@ -148,14 +139,11 @@ export class StaticSite extends Resource("cloudflare::StaticSite", {
         errorPage: props.errorPage,
         indexPage,
         assets: assetManifest.map((item) => item.key),
-        createdAt: ctx.output?.createdAt || now,
+        createdAt: this.output?.createdAt || now,
         updatedAt: now,
         domain: props.domain,
         production: props.production !== false,
         url: worker.url,
         routes,
-    };
-    return output;
-}) {
-}
-//# sourceMappingURL=static-site.js.map
+    });
+});

package/lib/cloudflare/types.d.ts

@@ -49,4 +49,3 @@ export interface CloudflareApiError {
  * @returns Formatted error message
  */
 export declare function extractCloudflareError(response: Response): Promise<string>;
-//# sourceMappingURL=types.d.ts.map

package/lib/cloudflare/types.js

@@ -18,4 +18,3 @@ export async function extractCloudflareError(response) {
         return `HTTP ${response.status}: ${response.statusText}`;
     }
 }
-//# sourceMappingURL=types.js.map

package/lib/cloudflare/upload-asset-manifest.d.ts

@@ -9,4 +9,3 @@ type UploadResult = {
 };
 export declare function uploadAssetManifest(api: CloudflareApi, namespaceId: string, manifest: AssetManifest): Promise<UploadResult[]>;
 export {};
-//# sourceMappingURL=upload-asset-manifest.d.ts.map

package/lib/cloudflare/upload-asset-manifest.js

@@ -52,4 +52,3 @@ export async function uploadAssetManifest(api, namespaceId, manifest) {
         }
     }
 }
-//# sourceMappingURL=upload-asset-manifest.js.map

package/lib/cloudflare/worker-metadata.d.ts

@@ -127,4 +127,3 @@ export interface WorkerDefaultEnvironment extends WorkerEnvironment {
      */
     script: WorkerScriptInfo;
 }
-//# sourceMappingURL=worker-metadata.d.ts.map

package/lib/cloudflare/worker-metadata.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=worker-metadata.js.map

package/lib/cloudflare/worker-migration.d.ts

@@ -107,4 +107,3 @@ export interface MigrationStep {
      */
     transferred_classes?: TransferredClass[];
 }
-//# sourceMappingURL=worker-migration.d.ts.map

package/lib/cloudflare/worker-migration.js

@@ -8,4 +8,3 @@ export function isSingleStepMigration(migration) {
 export function isMultiStepMigration(migration) {
     return "steps" in migration;
 }
-//# sourceMappingURL=worker-migration.js.map

package/lib/cloudflare/worker.d.ts

@@ -1,11 +1,13 @@
-import { type BundleProps } from "../esbuild";
-import type { Resolved } from "../output";
-import type { Bindings } from "./bindings";
+import type { Context } from "../context";
+import { type BundleProps } from "../esbuild/bundle";
+import { Resource } from "../resource";
+import { type Bindings } from "./bindings";
+import type { Bound } from "./bound";
 import type { SingleStepMigration } from "./worker-migration";
 /**
  * Properties for creating or updating a Worker
  */
-export interface WorkerProps {
+export interface WorkerProps<B extends Bindings = Bindings> {
     /**
      * The worker script content (JavaScript or WASM)
      * One of script, entryPoint, or bundle must be provided
@@ -42,7 +44,7 @@ export interface WorkerProps {
     /**
      * Bindings to attach to the worker
      */
-    bindings?: Bindings;
+    bindings?: B;
     /**
      * Environment variables to attach to the worker
      * These will be converted to plain_text bindings
@@ -76,7 +78,7 @@ export interface WorkerProps {
 /**
  * Output returned after Worker creation/update
  */
-export interface WorkerOutput extends Omit<WorkerProps, "url"> {
+export interface Worker<B extends Bindings = Bindings> extends Resource<"cloudflare::Worker">, Omit<WorkerProps<B>, "url"> {
     type: "service";
     /**
      * The ID of the worker
@@ -98,11 +100,9 @@ export interface WorkerOutput extends Omit<WorkerProps, "url"> {
     /**
      * The bindings that were created
      */
-    bindings: Bindings;
-}
-export declare function isWorker(resource: any): resource is Resolved<Worker>;
-declare const Worker_base: import("../resource").Provider<string, [props: WorkerProps], WorkerOutput>;
-export declare class Worker extends Worker_base {
+    bindings: B | undefined;
+    Env: {
+        [bindingName in keyof B]: Bound<B[bindingName]>;
+    };
 }
-export {};
-//# sourceMappingURL=worker.d.ts.map
+export declare const Worker: (<const B extends Bindings>(this: Context<Worker<NoInfer<B>>>, id: string, props: WorkerProps<B>) => Promise<Worker<B>>) | (((this: any, id: string, props: WorkerProps<Bindings>) => never) & (new (_: never) => never));

package/lib/cloudflare/worker.js

@@ -1,18 +1,15 @@
 import * as fs from "fs/promises";
-import { apply } from "../apply";
-import { Bundle } from "../esbuild";
+import { Bundle } from "../esbuild/bundle";
 import { Resource } from "../resource";
-import { withExponentialBackoff } from "../utils/retry";
+import { isSecret } from "../secret";
+import { withExponentialBackoff } from "../util/retry";
+import { slugify } from "../util/slugify";
 import { createCloudflareApi } from "./api";
-import { isBucket } from "./bucket";
-import { isDurableObjectNamespace } from "./durable-object-namespace";
+import { isDurableObjectNamespace, } from "./bindings";
 import { isKVNamespace } from "./kv-namespace";
-export function isWorker(resource) {
-    return resource && typeof resource === "object" && resource.type === "worker";
-}
-export class Worker extends Resource("cloudflare::Worker", {
+export const Worker = Resource("cloudflare::Worker", {
     alwaysUpdate: true,
-}, async (ctx, props) => {
+}, async function (id, props) {
     // Create Cloudflare API client with automatic account discovery
     const api = await createCloudflareApi();
     // Use the provided name
@@ -21,30 +18,31 @@ export class Worker extends Resource("cloudflare::Worker", {
     if (!props.script && !props.entrypoint) {
         throw new Error("One of script or entryPoint must be provided");
     }
-    if (ctx.event === "delete") {
-        return deleteWorker(ctx, api, workerName);
+    if (this.phase === "delete") {
+        await deleteWorker(this, api, workerName);
+        return this.destroy();
     }
-    else if (ctx.event === "create") {
-        await assertWorkerDoesNotExist(ctx, api, workerName);
+    else if (this.phase === "create") {
+        await assertWorkerDoesNotExist(this, api, workerName);
     }
-    const oldBindings = await ctx.get("bindings");
-    const scriptMetadata = await prepareWorkerMetadata(ctx, oldBindings, props);
+    const oldBindings = await this.get("bindings");
+    const scriptMetadata = await prepareWorkerMetadata(this, oldBindings, props);
     // Get the script content - either from props.script, or by bundling
-    const scriptContent = props.script ?? (await bundleWorkerScript(ctx, props));
+    const scriptContent = props.script ?? (await bundleWorkerScript(props));
     // Upload the worker script
-    await putWorker(ctx, api, workerName, scriptContent, scriptMetadata);
+    await putWorker(api, workerName, scriptContent, scriptMetadata);
     // TODO: it is less than ideal that this can fail, resulting in state problem
-    await ctx.set("bindings", props.bindings);
+    await this.set("bindings", props.bindings);
     // Handle routes if requested
     await setupRoutes(api, workerName, props.routes || []);
     // Handle worker URL if requested
-    const workerUrl = await configureURL(ctx, api, workerName, props.url ?? false);
+    const workerUrl = await configureURL(this, api, workerName, props.url ?? false);
     // Get current timestamp
     const now = Date.now();
     // Construct the output
-    const output = {
+    return this({
         type: "service",
-        id: workerName,
+        id,
         name: workerName,
         script: scriptContent,
         format: props.format || "esm", // Include format in the output
@@ -55,10 +53,10 @@ export class Worker extends Resource("cloudflare::Worker", {
         createdAt: now,
         updatedAt: now,
         url: workerUrl,
-    };
-    return output;
-}) {
-}
+        // phantom property
+        Env: undefined,
+    });
+});
 async function deleteWorker(ctx, api, workerName) {
     // Delete worker
     const deleteResponse = await api.delete(`/accounts/${api.accountId}/workers/scripts/${workerName}`);
@@ -102,7 +100,7 @@ async function deleteWorker(ctx, api, workerName) {
     // Return minimal output for deleted state
     return;
 }
-async function putWorker(ctx, api, workerName, scriptContent, scriptMetadata) {
+async function putWorker(api, workerName, scriptContent, scriptMetadata) {
     return withExponentialBackoff(async () => {
         const scriptName = scriptMetadata.main_module ?? scriptMetadata.body_part;
         // Create FormData for the upload
@@ -113,7 +111,6 @@ async function putWorker(ctx, api, workerName, scriptContent, scriptMetadata) {
                 ? "application/javascript+module"
                 : "application/javascript",
         }), scriptName);
-        // console.log("Script Metadata:", JSON.stringify(scriptMetadata, null, 2));
         // Add metadata as JSON
         formData.append("metadata", new Blob([JSON.stringify(scriptMetadata)], {
             type: "application/json",
@@ -153,7 +150,8 @@ async function prepareWorkerMetadata(ctx, oldBindings, props) {
         observability: {
             enabled: props.observability?.enabled !== false,
         },
-        tags: [`alchemy:id:${ctx.resourceFQN}`],
+        // TODO(sam): base64 encode instead? 0 collision risk vs readability.
+        tags: [`alchemy:id:${slugify(ctx.fqn)}`],
         migrations: {
             new_classes: props.migrations?.new_classes ?? [],
             deleted_classes: props.migrations?.deleted_classes ?? [],
@@ -170,7 +168,7 @@ async function prepareWorkerMetadata(ctx, oldBindings, props) {
             meta.bindings.push({
                 type: "kv_namespace",
                 name: bindingName,
-                namespace_id: binding.id,
+                namespace_id: binding.namespaceId,
             });
         }
         else if (typeof binding === "string") {
@@ -187,7 +185,7 @@ async function prepareWorkerMetadata(ctx, oldBindings, props) {
                 service: binding.id,
             });
         }
-        else if (isDurableObjectNamespace(binding)) {
+        else if (binding.type === "durable_object_namespace") {
             const stableId = binding.id;
             const className = binding.className;
             meta.bindings.push({
@@ -216,11 +214,18 @@ async function prepareWorkerMetadata(ctx, oldBindings, props) {
                 });
             }
         }
-        else if (isBucket(binding)) {
+        else if (binding.type === "r2_bucket") {
             meta.bindings.push({
                 type: "r2_bucket",
                 name: bindingName,
-                bucket_name: binding.name || binding.id,
+                bucket_name: binding.name,
+            });
+        }
+        else if (isSecret(binding)) {
+            meta.bindings.push({
+                type: "secret_text",
+                name: bindingName,
+                text: binding.unencrypted,
             });
         }
         else {
@@ -261,7 +266,7 @@ async function assertWorkerDoesNotExist(ctx, api, workerName) {
         if (!metadata) {
             throw new Error(`Worker exists but failed to fetch metadata: ${response.status} ${response.statusText}`);
         }
-        if (metadata.default_environment?.script.tags.includes(`alchemy:id:${ctx.resourceFQN}`)) {
+        if (metadata.default_environment?.script.tags.includes(`alchemy:id:${slugify(ctx.fqn)}`)) {
             return true;
         }
         throw new Error(`Worker with name '${workerName}' already exists. Please use a unique name.`);
@@ -270,7 +275,7 @@ async function assertWorkerDoesNotExist(ctx, api, workerName) {
         throw new Error(`Error checking if worker exists: ${response.status} ${response.statusText}`);
     }
 }
-async function bundleWorkerScript(ctx, props) {
+async function bundleWorkerScript(props) {
     // Get the script content - either from props.script, or by bundling
     // Create and use a Bundle resource with worker-optimized configuration
     const defaultBundleOptions = {
@@ -288,17 +293,13 @@ async function bundleWorkerScript(ctx, props) {
         ...(props.bundle || {}),
     };
     // Create the bundle
-    const bundle = new Bundle("bundle", {
+    const bundle = await Bundle("bundle", {
         entryPoint: props.entrypoint,
         ...bundleOptions,
         external: [...(bundleOptions.external ?? []), "cloudflare:workers"],
     });
-    // Get the bundled content
-    const bundleOutput = await apply(bundle, {
-        quiet: ctx.quiet,
-    });
     try {
-        return await fs.readFile(bundleOutput.path, "utf-8");
+        return await fs.readFile(bundle.path, "utf-8");
     }
     catch (error) {
         console.error("Error reading bundle:", error);
@@ -362,7 +363,7 @@ async function configureURL(ctx, api, workerName, url) {
             // Add a delay when the subdomain is first created.
             // This is to prevent an issue where a negative cache-hit
             // causes the subdomain to be unavailable for 30 seconds.
-            if (ctx.event === "create" || !ctx.output?.url) {
+            if (ctx.phase === "create" || !ctx.output?.url) {
                 await new Promise((resolve) => setTimeout(resolve, 3000));
             }
         }
@@ -404,4 +405,3 @@ async function getWorkerBindings(api, workerName, environment = "production") {
     const data = await response.json();
     return data.result;
 }
-//# sourceMappingURL=worker.js.map

package/lib/context.d.ts

@@ -0,0 +1,58 @@
+import type { Resource, ResourceFQN, ResourceID, ResourceKind, ResourceProps } from "./resource";
+import type { Scope } from "./scope";
+import type { State } from "./state";
+export type Context<Out extends Resource> = CreateContext<Out> | UpdateContext<Out> | DeleteContext<Out>;
+export interface CreateContext<Out extends Resource> extends BaseContext<Out> {
+    phase: "create";
+    output?: undefined;
+}
+export interface UpdateContext<Out extends Resource> extends BaseContext<Out> {
+    phase: "update";
+    output: Out;
+}
+export interface DeleteContext<Out extends Resource> extends BaseContext<Out> {
+    phase: "delete";
+    output: Out;
+}
+export interface BaseContext<Out extends Resource> {
+    quiet: boolean;
+    stage: string;
+    id: ResourceID;
+    fqn: ResourceFQN;
+    scope: Scope;
+    get<T>(key: string): Promise<T | undefined>;
+    set<T>(key: string, value: T): Promise<void>;
+    delete<T>(key: string): Promise<T | undefined>;
+    /**
+     * Indicate that this resource is being replaced.
+     * This will cause the resource to be deleted at the end of the stack's CREATE phase.
+     */
+    replace(): void;
+    /**
+     * Terminate the resource lifecycle handler and destroy the resource.
+     *
+     * This is the final operation performed during a delete operation.
+     *
+     * It is so that the resource lifecycle handler can "return never" instead of
+     * "return undefined" so that `await MyResource()` always returns a value.
+     */
+    destroy(): never;
+    /**
+     * Create the Resource envelope (with Alchemy + User properties)
+     */
+    create(props: Omit<Out, keyof Resource>): Out;
+    /**
+     * Create the Resource envelope (with Alchemy + User properties)
+     */
+    (props: Omit<Out, keyof Resource>): Out;
+}
+export declare function context<Kind extends string, Props extends ResourceProps, Out extends Resource>({ scope, phase, kind, id, fqn, seq, state, replace, }: {
+    scope: Scope;
+    phase: "create" | "update" | "delete";
+    kind: ResourceKind;
+    id: ResourceID;
+    fqn: ResourceFQN;
+    seq: number;
+    state: State<Kind, Props, Out>;
+    replace: () => void;
+}): Context<Out>;