puls-dev 0.1.0

package/dist/providers/firebase/functions.d.ts

@@ -0,0 +1,50 @@
+import { BaseBuilder } from '../../core/resource.js';
+export declare const FUNCTIONS_RUNTIME: {
+    readonly NODEJS_22: "nodejs22";
+    readonly NODEJS_20: "nodejs20";
+    readonly NODEJS_18: "nodejs18";
+    readonly PYTHON_312: "python312";
+    readonly PYTHON_311: "python311";
+    readonly GO_122: "go122";
+    readonly JAVA_21: "java21";
+};
+export declare class FirebaseFunctionsBuilder extends BaseBuilder {
+    private _sourcePath?;
+    private _entryPoint;
+    private _runtime;
+    private _region;
+    private _memory;
+    private _timeout;
+    private _maxInstances;
+    private _minInstances;
+    private _env;
+    constructor(functionName: string);
+    source(path: string): this;
+    entryPoint(e: string): this;
+    runtime(r: string): this;
+    region(r: string): this;
+    memory(m: string): this;
+    timeout(seconds: number): this;
+    maxInstances(n: number): this;
+    minInstances(n: number): this;
+    env(vars: Record<string, string>): this;
+    private fnPath;
+    private getExisting;
+    private zipSource;
+    private uploadSource;
+    private pollOperation;
+    deploy(): Promise<{
+        name: string;
+        project: string;
+        region: string;
+        url?: undefined;
+    } | {
+        name: string;
+        url: any;
+        project: string;
+        region: string;
+    }>;
+    destroy(): Promise<{
+        destroyed: string;
+    }>;
+}

package/dist/providers/firebase/functions.js

@@ -0,0 +1,163 @@
+import { execSync } from 'node:child_process';
+import { mkdtempSync, readFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { BaseBuilder } from '../../core/resource.js';
+import { cloudFetch, getProjectId } from './api.js';
+const CF_BASE = 'https://cloudfunctions.googleapis.com/v2';
+export const FUNCTIONS_RUNTIME = {
+    NODEJS_22: 'nodejs22',
+    NODEJS_20: 'nodejs20',
+    NODEJS_18: 'nodejs18',
+    PYTHON_312: 'python312',
+    PYTHON_311: 'python311',
+    GO_122: 'go122',
+    JAVA_21: 'java21',
+};
+export class FirebaseFunctionsBuilder extends BaseBuilder {
+    _sourcePath;
+    _entryPoint = 'handler';
+    _runtime = FUNCTIONS_RUNTIME.NODEJS_20;
+    _region = 'us-central1';
+    _memory = '256M';
+    _timeout = 60;
+    _maxInstances = 100;
+    _minInstances = 0;
+    _env = {};
+    constructor(functionName) {
+        super(functionName);
+        // Discovery runs lazily in deploy() because we need _region, which may not be set at construction time
+        this.discoveryPromise = Promise.resolve(null);
+    }
+    source(path) { this._sourcePath = path; return this; }
+    entryPoint(e) { this._entryPoint = e; return this; }
+    runtime(r) { this._runtime = r; return this; }
+    region(r) { this._region = r; return this; }
+    memory(m) { this._memory = m; return this; }
+    timeout(seconds) { this._timeout = seconds; return this; }
+    maxInstances(n) { this._maxInstances = n; return this; }
+    minInstances(n) { this._minInstances = n; return this; }
+    env(vars) { this._env = vars; return this; }
+    fnPath() {
+        return `/projects/${getProjectId()}/locations/${this._region}/functions/${this.name}`;
+    }
+    async getExisting() {
+        try {
+            return await cloudFetch(CF_BASE, this.fnPath());
+        }
+        catch (e) {
+            if (e.message?.includes('404'))
+                return null;
+            throw e;
+        }
+    }
+    zipSource() {
+        if (!this._sourcePath)
+            throw new Error(`[Firebase.Functions:${this.name}] .source() is required`);
+        const tmp = mkdtempSync(join(tmpdir(), 'puls-fn-'));
+        const zipPath = join(tmp, 'function.zip');
+        execSync(`cd "${this._sourcePath}" && zip -r "${zipPath}" .`, { stdio: 'pipe' });
+        return readFileSync(zipPath);
+    }
+    async uploadSource() {
+        const { uploadUrl, storageSource } = await cloudFetch(CF_BASE, `/projects/${getProjectId()}/locations/${this._region}/functions:generateUploadUrl`, { method: 'POST', body: '{}' });
+        const zipBuffer = this.zipSource();
+        const res = await fetch(uploadUrl, {
+            method: 'PUT',
+            headers: { 'Content-Type': 'application/zip' },
+            body: new Uint8Array(zipBuffer),
+        });
+        if (!res.ok)
+            throw new Error(`Source upload failed: ${res.status}`);
+        return storageSource;
+    }
+    async pollOperation(operationName) {
+        const start = Date.now();
+        const timeout = 5 * 60 * 1000;
+        while (Date.now() - start < timeout) {
+            await new Promise(r => setTimeout(r, 4000));
+            const op = await cloudFetch(CF_BASE, `/${operationName}`);
+            if (op.done) {
+                if (op.error)
+                    throw new Error(`Operation failed: ${JSON.stringify(op.error)}`);
+                return;
+            }
+        }
+        throw new Error(`[Firebase.Functions:${this.name}] Operation timed out after 5 minutes`);
+    }
+    async deploy() {
+        const dryRun = this.isDryRunActive();
+        const project = getProjectId();
+        console.log(`\n⚡ Finalizing Firebase Function "${this.name}"...`);
+        if (!this._sourcePath)
+            throw new Error(`[Firebase.Functions:${this.name}] .source() is required`);
+        if (dryRun) {
+            const existing = await this.getExisting();
+            if (existing) {
+                console.log(`   ✅ Function "${this.name}" exists (${existing.state ?? 'ACTIVE'})`);
+                console.log(`   📝 [PLAN] Update → ${this._runtime}, ${this._memory}, ${this._timeout}s timeout`);
+            }
+            else {
+                console.log(`   📝 [PLAN] Create function "${this.name}"`);
+                console.log(`      └─ runtime: ${this._runtime}`);
+                console.log(`      └─ entry point: ${this._entryPoint}`);
+                console.log(`      └─ region: ${this._region}`);
+                console.log(`      └─ memory: ${this._memory}, timeout: ${this._timeout}s`);
+                console.log(`      └─ source: ${this._sourcePath}`);
+            }
+            return { name: this.name, project, region: this._region };
+        }
+        const storageSource = await this.uploadSource();
+        console.log(`   📦 Source uploaded`);
+        const body = {
+            name: `projects/${project}/locations/${this._region}/functions/${this.name}`,
+            buildConfig: {
+                runtime: this._runtime,
+                entryPoint: this._entryPoint,
+                source: { storageSource },
+                environmentVariables: this._env,
+            },
+            serviceConfig: {
+                availableMemory: this._memory,
+                timeoutSeconds: this._timeout,
+                maxInstanceCount: this._maxInstances,
+                minInstanceCount: this._minInstances,
+                environmentVariables: this._env,
+                ingressSettings: 'ALLOW_ALL',
+            },
+        };
+        const existing = await this.getExisting();
+        let op;
+        if (!existing) {
+            op = await cloudFetch(CF_BASE, `/projects/${project}/locations/${this._region}/functions?functionId=${this.name}`, { method: 'POST', body: JSON.stringify(body) });
+            console.log(`   🚀 Creating function...`);
+        }
+        else {
+            const mask = 'buildConfig.source,buildConfig.runtime,buildConfig.entryPoint,buildConfig.environmentVariables,serviceConfig.availableMemory,serviceConfig.timeoutSeconds,serviceConfig.maxInstanceCount,serviceConfig.minInstanceCount,serviceConfig.environmentVariables';
+            op = await cloudFetch(CF_BASE, `${this.fnPath()}?updateMask=${mask}`, { method: 'PATCH', body: JSON.stringify(body) });
+            console.log(`   🔄 Updating function...`);
+        }
+        await this.pollOperation(op.name);
+        const fn = await this.getExisting();
+        const url = fn?.serviceConfig?.uri ?? `https://${this._region}-${project}.cloudfunctions.net/${this.name}`;
+        console.log(`   ✅ Function live → ${url}`);
+        return { name: this.name, url, project, region: this._region };
+    }
+    async destroy() {
+        const dryRun = this.isDryRunActive();
+        console.log(`\n🗑️  Destroying Firebase Function "${this.name}"...`);
+        const existing = await this.getExisting();
+        if (!existing) {
+            console.log(`   ✅ Function "${this.name}" does not exist — nothing to do`);
+            return { destroyed: this.name };
+        }
+        if (dryRun) {
+            console.log(`   📝 [PLAN] Delete function "${this.name}" in ${this._region}`);
+            return { destroyed: this.name };
+        }
+        const op = await cloudFetch(CF_BASE, this.fnPath(), { method: 'DELETE' });
+        await this.pollOperation(op.name);
+        console.log(`   ✅ Function "${this.name}" deleted`);
+        return { destroyed: this.name };
+    }
+}

package/dist/providers/firebase/hosting.d.ts

@@ -0,0 +1,14 @@
+import { BaseBuilder } from '../../core/resource.js';
+export declare class FirebaseHostingBuilder extends BaseBuilder {
+    private _sourcePath?;
+    constructor(siteId: string);
+    source(path: string): this;
+    private discoverSite;
+    deploy(): Promise<{
+        siteId: string;
+        url: string;
+    }>;
+    destroy(): Promise<{
+        destroyed: string;
+    }>;
+}

package/dist/providers/firebase/hosting.js

@@ -0,0 +1,144 @@
+import { createHash } from 'node:crypto';
+import { readdirSync, statSync, readFileSync } from 'node:fs';
+import { join, relative, extname } from 'node:path';
+import { BaseBuilder } from '../../core/resource.js';
+import { getProjectId, hostingFetch, getFirebaseToken } from './api.js';
+const CONTENT_TYPES = {
+    '.html': 'text/html',
+    '.css': 'text/css',
+    '.js': 'application/javascript',
+    '.json': 'application/json',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.svg': 'image/svg+xml',
+    '.ico': 'image/x-icon',
+    '.woff2': 'font/woff2',
+    '.woff': 'font/woff',
+    '.ttf': 'font/ttf',
+    '.txt': 'text/plain',
+    '.xml': 'application/xml',
+};
+function walkDir(dir) {
+    const results = [];
+    for (const entry of readdirSync(dir)) {
+        const full = join(dir, entry);
+        if (statSync(full).isDirectory()) {
+            results.push(...walkDir(full));
+        }
+        else {
+            results.push(full);
+        }
+    }
+    return results;
+}
+function sha256(filePath) {
+    const content = readFileSync(filePath);
+    return createHash('sha256').update(content).digest('hex');
+}
+export class FirebaseHostingBuilder extends BaseBuilder {
+    _sourcePath;
+    constructor(siteId) {
+        super(siteId);
+        // Discovery: check if the site has any releases (confirms it exists and is active)
+        this.discoveryPromise = this.discoverSite(siteId);
+    }
+    source(path) { this._sourcePath = path; return this; }
+    async discoverSite(siteId) {
+        try {
+            const result = await hostingFetch(`/sites/${siteId}/releases?pageSize=1`);
+            return result ?? null;
+        }
+        catch (e) {
+            // Site doesn't exist yet or credentials not set yet — not an error at construction time
+            if (e.message?.includes('403') || e.message?.includes('404'))
+                return null;
+            if (e.message?.includes('Firebase not configured'))
+                return null;
+            throw e;
+        }
+    }
+    async deploy() {
+        const dryRun = this.isDryRunActive();
+        const projectId = getProjectId();
+        const siteId = this.name;
+        console.log(`\n⚡ Finalizing Firebase Hosting "${siteId}"...`);
+        if (!this._sourcePath)
+            throw new Error(`[Firebase.Hosting:${siteId}] .source("./dist") is required`);
+        const files = walkDir(this._sourcePath);
+        if (files.length === 0)
+            throw new Error(`[Firebase.Hosting:${siteId}] No files found in "${this._sourcePath}"`);
+        if (dryRun) {
+            console.log(`   📝 [PLAN] Deploy ${files.length} file(s) to https://${siteId}.web.app`);
+            for (const f of files.slice(0, 5)) {
+                console.log(`      └─ /${relative(this._sourcePath, f)}`);
+            }
+            if (files.length > 5)
+                console.log(`      └─ ... and ${files.length - 5} more`);
+            return { siteId, url: `https://${siteId}.web.app` };
+        }
+        // 1. Create a new version
+        const version = await hostingFetch(`/sites/${siteId}/versions`, {
+            method: 'POST',
+            body: JSON.stringify({ config: { headers: [{ glob: '**', headers: { 'Cache-Control': 'max-age=3600' } }] } }),
+        });
+        const versionId = version.name.split('/').pop();
+        console.log(`   📦 Version created: ${versionId}`);
+        // 2. Build file hash map — keys are URL paths, values are SHA256 hashes
+        const fileMap = {};
+        const absoluteToUrl = {};
+        for (const absPath of files) {
+            const urlPath = '/' + relative(this._sourcePath, absPath).replace(/\\/g, '/');
+            const hash = sha256(absPath);
+            fileMap[urlPath] = hash;
+            absoluteToUrl[hash] = absPath;
+        }
+        // 3. Populate files — API tells us which hashes need uploading
+        const populate = await hostingFetch(`/sites/${siteId}/versions/${versionId}/populateFiles`, {
+            method: 'POST',
+            body: JSON.stringify({ files: fileMap }),
+        });
+        const uploadUrl = populate.uploadUrl;
+        const required = populate.uploadRequiredHashes ?? [];
+        console.log(`   📤 Uploading ${required.length} file(s) (${files.length - required.length} cached)`);
+        // 4. Upload each required file
+        const token = await getFirebaseToken(['https://www.googleapis.com/auth/firebase.hosting']);
+        for (const hash of required) {
+            const absPath = absoluteToUrl[hash];
+            const content = readFileSync(absPath);
+            const contentType = CONTENT_TYPES[extname(absPath).toLowerCase()] ?? 'application/octet-stream';
+            const res = await fetch(`${uploadUrl}/${hash}`, {
+                method: 'POST',
+                headers: { 'Authorization': `Bearer ${token}`, 'Content-Type': contentType },
+                body: content,
+            });
+            if (!res.ok)
+                throw new Error(`Upload failed for ${absPath}: ${res.status}`);
+        }
+        // 5. Finalize the version
+        await hostingFetch(`/sites/${siteId}/versions/${versionId}`, {
+            method: 'PATCH',
+            body: JSON.stringify({ status: 'FINALIZED' }),
+        });
+        // 6. Create a release
+        await hostingFetch(`/sites/${siteId}/releases?versionName=sites/${siteId}/versions/${versionId}`, {
+            method: 'POST',
+            body: JSON.stringify({}),
+        });
+        const url = `https://${siteId}.web.app`;
+        console.log(`🚀 Deployed ${files.length} file(s) → ${url}`);
+        return { siteId, url };
+    }
+    async destroy() {
+        const dryRun = this.isDryRunActive();
+        console.log(`\n🗑️  Destroying Firebase Hosting site "${this.name}"...`);
+        if (dryRun) {
+            console.log(`   📝 [PLAN] Delete all releases for site "${this.name}"`);
+            return { destroyed: this.name };
+        }
+        // Firebase doesn't support deleting the default site — we can only roll back releases.
+        // For non-default sites, the Sites API supports deletion (requires Blaze plan).
+        console.log(`   ℹ️  Firebase Hosting sites cannot be deleted via API (default site is permanent).`);
+        console.log(`      To unpublish, go to the Firebase console and disable Hosting.`);
+        return { destroyed: this.name };
+    }
+}

package/dist/providers/firebase/index.d.ts

@@ -0,0 +1,15 @@
+import { FirebaseHostingBuilder } from './hosting.js';
+import { FirebaseFunctionsBuilder, FUNCTIONS_RUNTIME } from './functions.js';
+import { FirebaseFirestoreBuilder } from './firestore.js';
+import { FirebaseStorageBuilder } from './storage.js';
+import { FirebaseAuthBuilder } from './auth.js';
+import { FirebaseRemoteConfigBuilder } from './remoteconfig.js';
+export { FUNCTIONS_RUNTIME };
+export declare const Firebase: {
+    Hosting: (siteId: string) => FirebaseHostingBuilder;
+    Functions: (functionName: string) => FirebaseFunctionsBuilder;
+    Firestore: (database?: string) => FirebaseFirestoreBuilder;
+    Storage: (bucket?: string) => FirebaseStorageBuilder;
+    Auth: () => FirebaseAuthBuilder;
+    RemoteConfig: () => FirebaseRemoteConfigBuilder;
+};

package/dist/providers/firebase/index.js

@@ -0,0 +1,15 @@
+import { FirebaseHostingBuilder } from './hosting.js';
+import { FirebaseFunctionsBuilder, FUNCTIONS_RUNTIME } from './functions.js';
+import { FirebaseFirestoreBuilder } from './firestore.js';
+import { FirebaseStorageBuilder } from './storage.js';
+import { FirebaseAuthBuilder } from './auth.js';
+import { FirebaseRemoteConfigBuilder } from './remoteconfig.js';
+export { FUNCTIONS_RUNTIME };
+export const Firebase = {
+    Hosting: (siteId) => new FirebaseHostingBuilder(siteId),
+    Functions: (functionName) => new FirebaseFunctionsBuilder(functionName),
+    Firestore: (database = '(default)') => new FirebaseFirestoreBuilder(database),
+    Storage: (bucket) => new FirebaseStorageBuilder(bucket),
+    Auth: () => new FirebaseAuthBuilder(),
+    RemoteConfig: () => new FirebaseRemoteConfigBuilder(),
+};

package/dist/providers/firebase/remoteconfig.d.ts

@@ -0,0 +1,22 @@
+import { BaseBuilder } from '../../core/resource.js';
+type ParamValue = string | number | boolean | object;
+export declare class FirebaseRemoteConfigBuilder extends BaseBuilder {
+    private _params;
+    private _conditions;
+    constructor();
+    string(key: string, value: string, description?: string): this;
+    bool(key: string, value: boolean, description?: string): this;
+    number(key: string, value: number, description?: string): this;
+    json(key: string, value: object, description?: string): this;
+    param(key: string, value: ParamValue, description?: string): this;
+    condition(name: string, expression: string): this;
+    override(paramKey: string, conditionName: string, value: ParamValue): this;
+    private rcFetch;
+    deploy(): Promise<{
+        project: string;
+    }>;
+    destroy(): Promise<{
+        destroyed: string;
+    }>;
+}
+export {};

package/dist/providers/firebase/remoteconfig.js

@@ -0,0 +1,135 @@
+import { BaseBuilder } from '../../core/resource.js';
+import { getFirebaseToken, getProjectId } from './api.js';
+const RC_BASE = 'https://firebaseremoteconfig.googleapis.com/v1';
+const RC_SCOPE = 'https://www.googleapis.com/auth/firebase.remoteconfig';
+function inferType(v) {
+    if (typeof v === 'boolean')
+        return 'BOOLEAN';
+    if (typeof v === 'number')
+        return 'NUMBER';
+    if (typeof v === 'object')
+        return 'JSON';
+    return 'STRING';
+}
+function serialize(v) {
+    return typeof v === 'object' ? JSON.stringify(v) : String(v);
+}
+export class FirebaseRemoteConfigBuilder extends BaseBuilder {
+    _params = [];
+    _conditions = [];
+    constructor() {
+        super('remoteconfig');
+        this.discoveryPromise = Promise.resolve(null);
+    }
+    string(key, value, description) {
+        this._params.push({ key, value, type: 'STRING', description });
+        return this;
+    }
+    bool(key, value, description) {
+        this._params.push({ key, value, type: 'BOOLEAN', description });
+        return this;
+    }
+    number(key, value, description) {
+        this._params.push({ key, value, type: 'NUMBER', description });
+        return this;
+    }
+    json(key, value, description) {
+        this._params.push({ key, value, type: 'JSON', description });
+        return this;
+    }
+    // Generic param — type inferred from value
+    param(key, value, description) {
+        this._params.push({ key, value, type: inferType(value), description });
+        return this;
+    }
+    condition(name, expression) {
+        this._conditions.push({ name, expression });
+        return this;
+    }
+    // Override a param's value for a specific condition
+    override(paramKey, conditionName, value) {
+        const p = this._params.find(p => p.key === paramKey);
+        if (!p)
+            throw new Error(`[RemoteConfig] param "${paramKey}" not defined — call .param()/.bool()/etc. first`);
+        p.conditionalValues ??= {};
+        p.conditionalValues[conditionName] = value;
+        return this;
+    }
+    // ── Internal fetch with ETag support ─────────────────────────────────────
+    async rcFetch(path, opts = {}) {
+        const token = await getFirebaseToken([RC_SCOPE]);
+        const headers = {
+            'Authorization': `Bearer ${token}`,
+            'Content-Type': 'application/json',
+        };
+        if (opts.etag)
+            headers['If-Match'] = opts.etag;
+        const res = await fetch(`${RC_BASE}${path}`, { ...opts, headers });
+        if (!res.ok) {
+            const body = await res.text();
+            throw new Error(`RemoteConfig API ${opts.method ?? 'GET'} ${path} → ${res.status}: ${body}`);
+        }
+        const text = await res.text();
+        return { data: text ? JSON.parse(text) : null, etag: res.headers.get('etag') };
+    }
+    // ── Deploy ────────────────────────────────────────────────────────────────
+    async deploy() {
+        const dryRun = this.isDryRunActive();
+        const project = getProjectId();
+        console.log(`\n🎛️  Finalizing Firebase RemoteConfig...`);
+        if (dryRun) {
+            console.log(`   📝 [PLAN] Set ${this._params.length} parameter(s):`);
+            for (const p of this._params) {
+                const overrides = p.conditionalValues ? ` + ${Object.keys(p.conditionalValues).length} override(s)` : '';
+                console.log(`      └─ ${p.key} (${p.type}): ${serialize(p.value)}${overrides}`);
+            }
+            if (this._conditions.length) {
+                console.log(`   📝 [PLAN] Set ${this._conditions.length} condition(s):`);
+                for (const c of this._conditions)
+                    console.log(`      └─ "${c.name}": ${c.expression}`);
+            }
+            return { project };
+        }
+        // Fetch current template + ETag
+        const { data: current, etag } = await this.rcFetch(`/projects/${project}/remoteConfig`);
+        // Merge our params into the existing template (non-destructive — preserves params we didn't define)
+        const parameters = { ...(current?.parameters ?? {}) };
+        for (const p of this._params) {
+            const entry = {
+                defaultValue: { value: serialize(p.value) },
+                valueType: p.type,
+            };
+            if (p.description)
+                entry.description = p.description;
+            if (p.conditionalValues) {
+                entry.conditionalValues = {};
+                for (const [cond, val] of Object.entries(p.conditionalValues)) {
+                    entry.conditionalValues[cond] = { value: serialize(val) };
+                }
+            }
+            parameters[p.key] = entry;
+        }
+        // Merge conditions (add new ones, preserve existing)
+        const existingConditions = current?.conditions ?? [];
+        const existingNames = new Set(existingConditions.map((c) => c.name));
+        const conditions = [
+            ...existingConditions,
+            ...this._conditions.filter(c => !existingNames.has(c.name)),
+        ];
+        const body = { parameters, conditions, parameterGroups: current?.parameterGroups ?? {} };
+        await this.rcFetch(`/projects/${project}/remoteConfig`, {
+            method: 'PUT',
+            body: JSON.stringify(body),
+            etag: etag ?? '*',
+        });
+        console.log(`   ✅ ${this._params.length} parameter(s) published`);
+        if (this._conditions.length)
+            console.log(`   ✅ ${this._conditions.length} condition(s) set`);
+        return { project };
+    }
+    async destroy() {
+        console.log(`\n🗑️  Destroying Firebase RemoteConfig...`);
+        console.log(`   ℹ️  RemoteConfig templates cannot be deleted via API — clear parameters in the Firebase console`);
+        return { destroyed: 'remoteconfig' };
+    }
+}

package/dist/providers/firebase/storage.d.ts

@@ -0,0 +1,34 @@
+import { BaseBuilder } from '../../core/resource.js';
+interface CorsRule {
+    origin: string[];
+    method: string[];
+    responseHeader?: string[];
+    maxAge?: number;
+}
+interface LifecycleRule {
+    deleteAfterDays?: number;
+    matchesPrefix?: string[];
+}
+export declare class FirebaseStorageBuilder extends BaseBuilder {
+    private _rulesPath?;
+    private _cors;
+    private _lifecycle?;
+    private _resolvedBucket?;
+    constructor(bucket?: string);
+    rules(filePath: string): this;
+    cors(rules: CorsRule[]): this;
+    lifecycle(rule: LifecycleRule): this;
+    private bucket;
+    private releaseName;
+    private deployRules;
+    private deployCors;
+    private deployLifecycle;
+    deploy(): Promise<{
+        bucket: string;
+        project: string;
+    }>;
+    destroy(): Promise<{
+        destroyed: string;
+    }>;
+}
+export {};