puls-dev 0.3.6 → 0.3.7

package/dist/providers/cloudflare/r2.js

@@ -0,0 +1,57 @@
+import { BaseBuilder } from "../../core/resource.js";
+import { getCloudflareApi, getCloudflareAccountId } from "./api.js";
+export class R2Builder extends BaseBuilder {
+    bucketName;
+    constructor(bucketName) {
+        super(bucketName);
+        this.bucketName = bucketName;
+        this.discoveryPromise = this.discoverBucket(bucketName);
+    }
+    async discoverBucket(name) {
+        try {
+            const api = getCloudflareApi();
+            const accountId = getCloudflareAccountId();
+            const res = await api.get(`/accounts/${accountId}/r2/buckets`);
+            return (res.result?.buckets ?? []).find((b) => b.name === name) ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async deploy() {
+        const dryRun = this.isDryRunActive();
+        const existing = await this.discoveryPromise;
+        const api = getCloudflareApi();
+        const accountId = getCloudflareAccountId();
+        console.log(`\n🪣  Finalizing Cloudflare R2 Bucket "${this.bucketName}"...`);
+        if (existing) {
+            console.log(`   ✅ R2 Bucket "${this.bucketName}" already exists`);
+            return { bucket: this.bucketName };
+        }
+        if (dryRun) {
+            console.log(`   📝 [PLAN] Create R2 Bucket "${this.bucketName}"`);
+            return { bucket: this.bucketName };
+        }
+        await api.put(`/accounts/${accountId}/r2/buckets/${this.bucketName}`, {});
+        console.log(`🚀 Created R2 Bucket "${this.bucketName}"`);
+        return { bucket: this.bucketName };
+    }
+    async destroy() {
+        const dryRun = this.isDryRunActive();
+        const existing = await this.discoveryPromise;
+        const api = getCloudflareApi();
+        const accountId = getCloudflareAccountId();
+        console.log(`\n🗑️  Destroying Cloudflare R2 Bucket "${this.bucketName}"...`);
+        if (!existing) {
+            console.log(`   ─  R2 Bucket "${this.bucketName}" not found`);
+            return { destroyed: false };
+        }
+        if (dryRun) {
+            console.log(`   📝 [PLAN] Delete R2 Bucket "${this.bucketName}"`);
+            return { destroyed: this.bucketName };
+        }
+        await api.delete(`/accounts/${accountId}/r2/buckets/${this.bucketName}`);
+        console.log(`   🗑️  Removed R2 Bucket "${this.bucketName}"`);
+        return { destroyed: this.bucketName };
+    }
+}

package/dist/providers/cloudflare/r2.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/providers/cloudflare/r2.test.js

@@ -0,0 +1,132 @@
+import { test, describe, beforeEach, afterEach } from "node:test";
+import assert from "node:assert";
+import { R2Builder } from "./r2.js";
+import { Config } from "../../core/config.js";
+describe("R2Builder Unit Tests", () => {
+    let originalFetch;
+    let fetchCalls = [];
+    let mockResponses = {};
+    beforeEach(() => {
+        Config.set({
+            dryRun: false,
+            providers: {
+                cloudflare: { token: "fake-cf-token", accountId: "fake-cf-account" }
+            }
+        });
+        originalFetch = globalThis.fetch;
+        fetchCalls = [];
+        mockResponses = {};
+        globalThis.fetch = async (input, init) => {
+            const url = String(input);
+            const method = init?.method ?? "GET";
+            let body;
+            if (init?.body) {
+                if (typeof init.body === "string") {
+                    try {
+                        body = JSON.parse(init.body);
+                    }
+                    catch {
+                        body = init.body;
+                    }
+                }
+                else {
+                    body = init.body;
+                }
+            }
+            const headers = init?.headers;
+            fetchCalls.push({ url, method, body, headers });
+            const matchKey = Object.keys(mockResponses).find(key => {
+                const [mMethod, mPath] = key.split(" ");
+                return method === mMethod && url.endsWith(mPath);
+            });
+            if (matchKey) {
+                const resp = mockResponses[matchKey];
+                return {
+                    ok: resp.status >= 200 && resp.status < 300,
+                    status: resp.status,
+                    json: async () => resp.body,
+                    text: async () => JSON.stringify(resp.body),
+                };
+            }
+            return {
+                ok: false,
+                status: 404,
+                json: async () => ({ errors: [{ message: "Not found" }] }),
+                text: async () => "Not found",
+            };
+        };
+    });
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
+    });
+    test("discovers bucket successfully if it already exists", async () => {
+        mockResponses["GET /accounts/fake-cf-account/r2/buckets"] = {
+            status: 200,
+            body: {
+                result: {
+                    buckets: [
+                        { name: "my-bucket" }
+                    ]
+                }
+            }
+        };
+        const builder = new R2Builder("my-bucket");
+        const result = await builder.deploy();
+        assert.deepStrictEqual(result, { bucket: "my-bucket" });
+        const puts = fetchCalls.filter(c => c.method === "PUT");
+        assert.strictEqual(puts.length, 0);
+    });
+    test("creates bucket if it does not exist", async () => {
+        mockResponses["GET /accounts/fake-cf-account/r2/buckets"] = {
+            status: 200,
+            body: { result: { buckets: [] } }
+        };
+        mockResponses["PUT /accounts/fake-cf-account/r2/buckets/my-bucket"] = {
+            status: 200,
+            body: {}
+        };
+        const builder = new R2Builder("my-bucket");
+        const result = await builder.deploy();
+        assert.deepStrictEqual(result, { bucket: "my-bucket" });
+        const putCall = fetchCalls.find(c => c.method === "PUT");
+        assert.ok(putCall);
+    });
+    test("does not call fetch during dryRun deploy", async () => {
+        Config.set({
+            dryRun: true,
+            providers: {
+                cloudflare: { token: "fake-cf-token", accountId: "fake-cf-account" }
+            }
+        });
+        mockResponses["GET /accounts/fake-cf-account/r2/buckets"] = {
+            status: 200,
+            body: { result: { buckets: [] } }
+        };
+        const builder = new R2Builder("my-bucket");
+        const result = await builder.deploy();
+        assert.deepStrictEqual(result, { bucket: "my-bucket" });
+        const puts = fetchCalls.filter(c => c.method === "PUT");
+        assert.strictEqual(puts.length, 0);
+    });
+    test("destroys bucket successfully if exists", async () => {
+        mockResponses["GET /accounts/fake-cf-account/r2/buckets"] = {
+            status: 200,
+            body: {
+                result: {
+                    buckets: [
+                        { name: "my-bucket" }
+                    ]
+                }
+            }
+        };
+        mockResponses["DELETE /accounts/fake-cf-account/r2/buckets/my-bucket"] = {
+            status: 200,
+            body: {}
+        };
+        const builder = new R2Builder("my-bucket");
+        const result = await builder.destroy();
+        assert.deepStrictEqual(result, { destroyed: "my-bucket" });
+        const deleteCall = fetchCalls.find(c => c.method === "DELETE");
+        assert.ok(deleteCall);
+    });
+});

package/dist/providers/cloudflare/worker.d.ts

@@ -0,0 +1,28 @@
+import { BaseBuilder } from "../../core/resource.js";
+import { Output } from "../../core/output.js";
+import { KVBuilder } from "./kv.js";
+import { R2Builder } from "./r2.js";
+export declare class WorkerBuilder extends BaseBuilder {
+    scriptName: string;
+    private _scriptPath?;
+    private _routes;
+    private _kvs;
+    private _r2s;
+    private _envs;
+    constructor(scriptName: string);
+    script(filePath: string): this;
+    route(pattern: string): this;
+    kv(bindingName: string, kvNamespace: KVBuilder): this;
+    r2(bindingName: string, r2Bucket: R2Builder): this;
+    env(bindingName: string, value: string | Output<string>): this;
+    deploy(): Promise<{
+        scriptName: string;
+        routes?: undefined;
+    } | {
+        scriptName: string;
+        routes: string[];
+    }>;
+    destroy(): Promise<{
+        destroyed: string;
+    }>;
+}

package/dist/providers/cloudflare/worker.js

@@ -0,0 +1,172 @@
+import { readFileSync } from "node:fs";
+import { BaseBuilder } from "../../core/resource.js";
+import { Output } from "../../core/output.js";
+import { getCloudflareApi, getCloudflareAccountId } from "./api.js";
+async function getZoneIdForPattern(pattern, api) {
+    let host = pattern.split("/")[0];
+    const parts = host.split(".");
+    for (let i = 0; i < parts.length - 1; i++) {
+        const possibleZone = parts.slice(i).join(".");
+        try {
+            const res = await api.get(`/zones?name=${possibleZone}`);
+            if (res.result && res.result.length > 0) {
+                return res.result[0].id;
+            }
+        }
+        catch {
+            // Ignore and try next parent domain
+        }
+    }
+    throw new Error(`Could not find Cloudflare DNS Zone for route pattern "${pattern}"`);
+}
+export class WorkerBuilder extends BaseBuilder {
+    scriptName;
+    _scriptPath;
+    _routes = [];
+    _kvs = new Map();
+    _r2s = new Map();
+    _envs = new Map();
+    constructor(scriptName) {
+        super(scriptName);
+        this.scriptName = scriptName;
+    }
+    script(filePath) {
+        this._scriptPath = filePath;
+        return this;
+    }
+    route(pattern) {
+        this._routes.push(pattern);
+        return this;
+    }
+    kv(bindingName, kvNamespace) {
+        this._kvs.set(bindingName, kvNamespace);
+        this.dependsOn(kvNamespace);
+        return this;
+    }
+    r2(bindingName, r2Bucket) {
+        this._r2s.set(bindingName, r2Bucket);
+        this.dependsOn(r2Bucket);
+        return this;
+    }
+    env(bindingName, value) {
+        this._envs.set(bindingName, value);
+        return this;
+    }
+    async deploy() {
+        if (!this._scriptPath) {
+            throw new Error(`Worker script path is not configured for "${this.name}". Call .script("filePath")`);
+        }
+        const dryRun = this.isDryRunActive();
+        const api = getCloudflareApi();
+        const accountId = getCloudflareAccountId();
+        console.log(`\n⚡ Finalizing Cloudflare Worker "${this.scriptName}"...`);
+        const metadata = {
+            main_module: "index.js",
+            bindings: [],
+        };
+        // Resolve KV Bindings
+        for (const [binding, kv] of this._kvs.entries()) {
+            const kvId = dryRun ? "mock-kv-id" : await kv.out.id.get();
+            metadata.bindings.push({
+                type: "kv_namespace",
+                name: binding,
+                namespace_id: kvId,
+            });
+        }
+        // Resolve R2 Bindings
+        for (const [binding, r2] of this._r2s.entries()) {
+            metadata.bindings.push({
+                type: "r2_bucket",
+                name: binding,
+                bucket_name: r2.bucketName,
+            });
+        }
+        // Resolve Env Bindings
+        for (const [binding, val] of this._envs.entries()) {
+            const resolvedVal = val instanceof Output ? await val.get() : val;
+            metadata.bindings.push({
+                type: "plain_text",
+                name: binding,
+                text: resolvedVal,
+            });
+        }
+        if (dryRun) {
+            console.log(`   📝 [PLAN] Upload Worker script "${this.scriptName}"`);
+            for (const r of this._routes) {
+                console.log(`      └─ Route: ${r}`);
+            }
+            return { scriptName: this.scriptName };
+        }
+        // Load and build FormData
+        const scriptContent = readFileSync(this._scriptPath, "utf8");
+        const form = new FormData();
+        form.append("metadata", JSON.stringify(metadata));
+        form.append("script", new Blob([scriptContent], { type: "application/javascript+module" }), "index.js");
+        await api.put(`/accounts/${accountId}/workers/scripts/${this.scriptName}`, form);
+        console.log(`🚀 Uploaded Worker script "${this.scriptName}"`);
+        // Reconcile Routes
+        for (const pattern of this._routes) {
+            const zoneId = await getZoneIdForPattern(pattern, api);
+            const routesRes = await api.get(`/zones/${zoneId}/workers/routes`);
+            const existingRoute = (routesRes.result ?? []).find((r) => r.pattern === pattern);
+            if (existingRoute) {
+                if (existingRoute.script !== this.scriptName) {
+                    await api.put(`/zones/${zoneId}/workers/routes/${existingRoute.id}`, {
+                        pattern,
+                        script: this.scriptName,
+                    });
+                    console.log(`   🔄 Updated route ${pattern} → ${this.scriptName}`);
+                }
+                else {
+                    console.log(`   ✅ Route ${pattern} is up to date`);
+                }
+            }
+            else {
+                await api.post(`/zones/${zoneId}/workers/routes`, {
+                    pattern,
+                    script: this.scriptName,
+                });
+                console.log(`   🚀 Created route ${pattern} → ${this.scriptName}`);
+            }
+        }
+        return { scriptName: this.scriptName, routes: this._routes };
+    }
+    async destroy() {
+        const dryRun = this.isDryRunActive();
+        const api = getCloudflareApi();
+        const accountId = getCloudflareAccountId();
+        console.log(`\n🗑️  Destroying Cloudflare Worker "${this.scriptName}"...`);
+        if (dryRun) {
+            console.log(`   📝 [PLAN] Delete Worker script "${this.scriptName}"`);
+            return { destroyed: this.scriptName };
+        }
+        // Clean up routes pointing to this script
+        if (this._routes.length > 0) {
+            for (const pattern of this._routes) {
+                try {
+                    const zoneId = await getZoneIdForPattern(pattern, api);
+                    const routesRes = await api.get(`/zones/${zoneId}/workers/routes`);
+                    const match = (routesRes.result ?? []).find((r) => r.pattern === pattern && r.script === this.scriptName);
+                    if (match) {
+                        await api.delete(`/zones/${zoneId}/workers/routes/${match.id}`);
+                        console.log(`   🗑️  Removed route ${pattern}`);
+                    }
+                }
+                catch {
+                    // Ignore if zone or route is already gone
+                }
+            }
+        }
+        try {
+            await api.delete(`/accounts/${accountId}/workers/scripts/${this.scriptName}`);
+            console.log(`   🗑️  Removed Worker script "${this.scriptName}"`);
+        }
+        catch (err) {
+            // Ignore if already deleted
+            if (!err.message.includes("404"))
+                throw err;
+        }
+        await this.destroySidecars();
+        return { destroyed: this.scriptName };
+    }
+}

package/dist/providers/cloudflare/worker.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/providers/cloudflare/worker.test.js

@@ -0,0 +1,220 @@
+import { test, describe, beforeEach, afterEach } from "node:test";
+import assert from "node:assert";
+import fs from "node:fs";
+import path from "node:path";
+import { WorkerBuilder } from "./worker.js";
+import { KVBuilder } from "./kv.js";
+import { R2Builder } from "./r2.js";
+import { Config } from "../../core/config.js";
+describe("WorkerBuilder Unit Tests", () => {
+    let originalFetch;
+    let fetchCalls = [];
+    let mockResponses = {};
+    const tempScriptPath = path.resolve(process.cwd(), "temp-worker.js");
+    beforeEach(() => {
+        Config.set({
+            dryRun: false,
+            providers: {
+                cloudflare: { token: "fake-cf-token", accountId: "fake-cf-account" }
+            }
+        });
+        originalFetch = globalThis.fetch;
+        fetchCalls = [];
+        mockResponses = {};
+        fs.writeFileSync(tempScriptPath, "export default { fetch() { return new Response('hello'); } };", "utf8");
+        globalThis.fetch = async (input, init) => {
+            const url = String(input);
+            const method = init?.method ?? "GET";
+            let body;
+            if (init?.body) {
+                if (init.body instanceof FormData) {
+                    body = init.body;
+                }
+                else if (typeof init.body === "string") {
+                    try {
+                        body = JSON.parse(init.body);
+                    }
+                    catch {
+                        body = init.body;
+                    }
+                }
+                else {
+                    body = init.body;
+                }
+            }
+            const headers = init?.headers;
+            fetchCalls.push({ url, method, body, headers });
+            const matchKey = Object.keys(mockResponses).find(key => {
+                const [mMethod, mPath] = key.split(" ");
+                return method === mMethod && url.endsWith(mPath);
+            });
+            if (matchKey) {
+                const resp = mockResponses[matchKey];
+                return {
+                    ok: resp.status >= 200 && resp.status < 300,
+                    status: resp.status,
+                    json: async () => resp.body,
+                    text: async () => JSON.stringify(resp.body),
+                };
+            }
+            return {
+                ok: false,
+                status: 404,
+                json: async () => ({ errors: [{ message: "Not found" }] }),
+                text: async () => "Not found",
+            };
+        };
+    });
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
+        if (fs.existsSync(tempScriptPath)) {
+            fs.unlinkSync(tempScriptPath);
+        }
+    });
+    test("throws if script path is not configured", async () => {
+        const builder = new WorkerBuilder("my-worker");
+        await assert.rejects(async () => {
+            await builder.deploy();
+        }, /Worker script path is not configured/);
+    });
+    test("deploys worker script with bindings and reconciles routes", async () => {
+        // KV namespace mock response for builder dependency discovery
+        mockResponses["GET /accounts/fake-cf-account/workers/namespaces?per_page=100"] = {
+            status: 200,
+            body: {
+                result: [{ id: "kv-id-999", title: "my-kv" }]
+            }
+        };
+        // R2 mock response for discovery
+        mockResponses["GET /accounts/fake-cf-account/r2/buckets"] = {
+            status: 200,
+            body: {
+                result: { buckets: [{ name: "my-bucket" }] }
+            }
+        };
+        // Worker upload mock response
+        mockResponses["PUT /accounts/fake-cf-account/workers/scripts/my-worker"] = {
+            status: 200,
+            body: { result: { id: "my-worker" } }
+        };
+        // Route resolution: zone matching
+        mockResponses["GET /zones?name=api.example.com"] = {
+            status: 200,
+            body: { result: [] }
+        };
+        mockResponses["GET /zones?name=example.com"] = {
+            status: 200,
+            body: { result: [{ id: "zone-123", name: "example.com" }] }
+        };
+        // Get routes mock response (1 existing route to update, 1 new route to create)
+        mockResponses["GET /zones/zone-123/workers/routes"] = {
+            status: 200,
+            body: {
+                result: [
+                    { id: "route-existing", pattern: "api.example.com/*", script: "old-worker" }
+                ]
+            }
+        };
+        mockResponses["PUT /zones/zone-123/workers/routes/route-existing"] = {
+            status: 200,
+            body: { result: { id: "route-existing" } }
+        };
+        mockResponses["POST /zones/zone-123/workers/routes"] = {
+            status: 200,
+            body: { result: { id: "route-new" } }
+        };
+        const kv = new KVBuilder("my-kv");
+        const r2 = new R2Builder("my-bucket");
+        // Initialize/deploy dependencies first
+        await kv.deploy();
+        await r2.deploy();
+        const worker = new WorkerBuilder("my-worker")
+            .script(tempScriptPath)
+            .kv("MY_KV", kv)
+            .r2("MY_BUCKET", r2)
+            .env("ENV_VAR", "my-env-value")
+            .route("api.example.com/*")
+            .route("example.com/*");
+        const result = await worker.deploy();
+        assert.strictEqual(result.scriptName, "my-worker");
+        assert.deepStrictEqual(result.routes, ["api.example.com/*", "example.com/*"]);
+        // Verify multipart request body contains metadata with bindings
+        const uploadCall = fetchCalls.find(c => c.method === "PUT" && c.url.endsWith("/workers/scripts/my-worker"));
+        assert.ok(uploadCall);
+        assert.ok(uploadCall.body instanceof FormData);
+        const metadataStr = uploadCall.body.get("metadata");
+        assert.ok(typeof metadataStr === "string");
+        const metadata = JSON.parse(metadataStr);
+        assert.deepStrictEqual(metadata, {
+            main_module: "index.js",
+            bindings: [
+                { type: "kv_namespace", name: "MY_KV", namespace_id: "kv-id-999" },
+                { type: "r2_bucket", name: "MY_BUCKET", bucket_name: "my-bucket" },
+                { type: "plain_text", name: "ENV_VAR", text: "my-env-value" }
+            ]
+        });
+        // Verify route updates & creations
+        const putRouteCall = fetchCalls.find(c => c.method === "PUT" && c.url.includes("/workers/routes/"));
+        assert.ok(putRouteCall);
+        assert.ok(putRouteCall.url.endsWith("/zones/zone-123/workers/routes/route-existing"));
+        assert.deepStrictEqual(putRouteCall.body, {
+            pattern: "api.example.com/*",
+            script: "my-worker"
+        });
+        const postRouteCall = fetchCalls.find(c => c.method === "POST" && c.url.endsWith("/zones/zone-123/workers/routes"));
+        assert.ok(postRouteCall);
+        assert.deepStrictEqual(postRouteCall.body, {
+            pattern: "example.com/*",
+            script: "my-worker"
+        });
+    });
+    test("does not call fetch during dryRun deploy", async () => {
+        Config.set({
+            dryRun: true,
+            providers: {
+                cloudflare: { token: "fake-cf-token", accountId: "fake-cf-account" }
+            }
+        });
+        const worker = new WorkerBuilder("my-worker")
+            .script(tempScriptPath)
+            .route("example.com/*");
+        const result = await worker.deploy();
+        assert.strictEqual(result.scriptName, "my-worker");
+        const puts = fetchCalls.filter(c => c.method === "PUT");
+        assert.strictEqual(puts.length, 0);
+    });
+    test("destroys routes and script successfully", async () => {
+        // Mock zone resolution for route cleanup
+        mockResponses["GET /zones?name=example.com"] = {
+            status: 200,
+            body: { result: [{ id: "zone-123", name: "example.com" }] }
+        };
+        mockResponses["GET /zones/zone-123/workers/routes"] = {
+            status: 200,
+            body: {
+                result: [
+                    { id: "route-existing", pattern: "example.com/*", script: "my-worker" }
+                ]
+            }
+        };
+        mockResponses["DELETE /zones/zone-123/workers/routes/route-existing"] = {
+            status: 200,
+            body: {}
+        };
+        mockResponses["DELETE /accounts/fake-cf-account/workers/scripts/my-worker"] = {
+            status: 200,
+            body: {}
+        };
+        const worker = new WorkerBuilder("my-worker")
+            .script(tempScriptPath)
+            .route("example.com/*");
+        const result = await worker.destroy();
+        assert.deepStrictEqual(result, { destroyed: "my-worker" });
+        const deleteRouteCall = fetchCalls.find(c => c.method === "DELETE" && c.url.includes("/workers/routes/"));
+        assert.ok(deleteRouteCall);
+        assert.ok(deleteRouteCall.url.endsWith("/zones/zone-123/workers/routes/route-existing"));
+        const deleteScriptCall = fetchCalls.find(c => c.method === "DELETE" && c.url.includes("/workers/scripts/"));
+        assert.ok(deleteScriptCall);
+        assert.ok(deleteScriptCall.url.endsWith("/accounts/fake-cf-account/workers/scripts/my-worker"));
+    });
+});

package/dist/providers/cloudflare/zone.d.ts

@@ -0,0 +1,42 @@
+import { BaseBuilder } from "../../core/resource.js";
+import { Output } from "../../core/output.js";
+export interface CFDNSRecord {
+    type: "A" | "CNAME" | "TXT" | "MX" | "AAAA" | "SRV" | "CAA";
+    name: string;
+    value: string | BaseBuilder | Output<string>;
+    ttl?: number;
+    priority?: number;
+    port?: number;
+    weight?: number;
+    flags?: number;
+    tag?: string;
+    proxied?: boolean;
+}
+export declare class ZoneBuilder extends BaseBuilder {
+    domainName: string;
+    readonly out: {
+        id: Output<string>;
+    };
+    resolvedId: string | null;
+    private records;
+    constructor(domainName: string);
+    private discoverZone;
+    record(filePath: string): this;
+    record(name: string, type: CFDNSRecord["type"], value: string | BaseBuilder | Output<string>, ttl?: number, priority?: number, port?: number, weight?: number, flags?: number, tag?: string, proxied?: boolean): this;
+    pointer(name: string, target: BaseBuilder | Output<string> | string, proxied?: boolean): this;
+    cname(name: string, target: string, proxied?: boolean): this;
+    aaaa(name: string, target: string | Output<string>, proxied?: boolean): this;
+    txt(name: string, target: string): this;
+    mx(name: string, target: string, priority?: number): this;
+    srv(name: string, target: string, port: number, priority?: number, weight?: number): this;
+    caa(name: string, tag: string, target: string, flags?: number): this;
+    deploy(): Promise<{
+        zone: string;
+        zoneId: string | null;
+    }>;
+    destroy(): Promise<{
+        destroyed: boolean;
+    } | {
+        destroyed: string;
+    }>;
+}