@unstablestudios/terraform 0.0.0

package/dist/index.d.mts

@@ -0,0 +1,970 @@
+/**
+ * Terraform value types that can be serialized to HCL
+ */
+type HclValue = string | number | boolean | null | HclValue[] | {
+    [key: string]: HclValue;
+} | HclExpression;
+/**
+ * Raw HCL expression (not quoted in output)
+ */
+interface HclExpression {
+    __hclExpression: true;
+    value: string;
+}
+/**
+ * Create a raw HCL expression
+ */
+declare function expr(value: string): HclExpression;
+/**
+ * Check if a value is an HCL expression
+ */
+declare function isHclExpression(value: unknown): value is HclExpression;
+/**
+ * Terraform block type
+ */
+type BlockType = 'terraform' | 'provider' | 'resource' | 'data' | 'variable' | 'output' | 'locals' | 'module';
+/**
+ * Terraform block definition
+ */
+interface TerraformBlock {
+    type: BlockType;
+    labels: string[];
+    body: Record<string, HclValue>;
+    nestedBlocks?: TerraformBlock[];
+}
+/**
+ * Terraform variable definition
+ */
+interface VariableConfig {
+    type?: string;
+    description?: string;
+    default?: HclValue;
+    sensitive?: boolean;
+    nullable?: boolean;
+    validation?: {
+        condition: HclExpression;
+        error_message: string;
+    };
+}
+/**
+ * Terraform output definition
+ */
+interface OutputConfig {
+    value: HclValue;
+    description?: string;
+    sensitive?: boolean;
+    depends_on?: HclExpression[];
+}
+/**
+ * Terraform provider configuration
+ */
+interface ProviderConfig {
+    provider: string;
+    alias?: string;
+    config: Record<string, HclValue>;
+}
+/**
+ * Terraform backend configuration
+ */
+interface BackendConfig {
+    type: string;
+    config: Record<string, HclValue>;
+}
+/**
+ * Terraform required providers configuration
+ */
+interface RequiredProvider {
+    source: string;
+    version?: string;
+}
+/**
+ * Terraform resource configuration
+ */
+interface ResourceConfig {
+    type: string;
+    name: string;
+    config: Record<string, HclValue>;
+    depends_on?: HclExpression[];
+    count?: HclValue;
+    for_each?: HclValue;
+    provider?: HclExpression;
+    lifecycle?: {
+        create_before_destroy?: boolean;
+        prevent_destroy?: boolean;
+        ignore_changes?: HclExpression;
+        replace_triggered_by?: HclExpression[];
+    };
+}
+/**
+ * Terraform data source configuration
+ */
+interface DataSourceConfig {
+    type: string;
+    name: string;
+    config: Record<string, HclValue>;
+    depends_on?: HclExpression[];
+    count?: HclValue;
+    for_each?: HclValue;
+    provider?: HclExpression;
+}
+/**
+ * Module configuration
+ */
+interface ModuleConfig {
+    name: string;
+    source: string;
+    version?: string;
+    config: Record<string, HclValue>;
+    depends_on?: HclExpression[];
+    count?: HclValue;
+    for_each?: HclValue;
+    providers?: Record<string, HclExpression>;
+}
+/**
+ * Complete Terraform configuration
+ */
+interface TerraformConfig {
+    terraform?: {
+        required_version?: string;
+        required_providers?: Record<string, RequiredProvider>;
+        backend?: BackendConfig;
+    };
+    providers?: ProviderConfig[];
+    variables?: Record<string, VariableConfig>;
+    locals?: Record<string, HclValue>;
+    resources?: ResourceConfig[];
+    dataSources?: DataSourceConfig[];
+    modules?: ModuleConfig[];
+    outputs?: Record<string, OutputConfig>;
+}
+
+/**
+ * Options for HCL generation
+ */
+interface HclOptions {
+    /** Indentation string (default: 2 spaces) */
+    indent?: string;
+    /** Whether to include empty values (default: false) */
+    includeEmpty?: boolean;
+}
+/**
+ * Convert a value to HCL string representation
+ */
+declare function toHcl(value: HclValue, options?: HclOptions): string;
+/**
+ * Format a block with labels
+ */
+declare function formatBlock(block: TerraformBlock, options?: HclOptions): string;
+/**
+ * Generate variable block
+ */
+declare function generateVariable(name: string, config: VariableConfig, opts?: HclOptions): string;
+/**
+ * Generate output block
+ */
+declare function generateOutput(name: string, config: OutputConfig, opts?: HclOptions): string;
+/**
+ * Generate provider block
+ */
+declare function generateProvider(config: ProviderConfig, opts?: HclOptions): string;
+/**
+ * Generate resource block
+ */
+declare function generateResource(config: ResourceConfig, opts?: HclOptions): string;
+/**
+ * Generate data source block
+ */
+declare function generateDataSource(config: DataSourceConfig, opts?: HclOptions): string;
+/**
+ * Generate module block
+ */
+declare function generateModule(config: ModuleConfig, opts?: HclOptions): string;
+/**
+ * Generate locals block
+ */
+declare function generateLocals(locals: Record<string, HclValue>, opts?: HclOptions): string;
+/**
+ * Generate terraform block (required_version, required_providers, backend)
+ */
+declare function generateTerraformBlock(config: {
+    required_version?: string;
+    required_providers?: Record<string, RequiredProvider>;
+    backend?: BackendConfig;
+}, opts?: HclOptions): string;
+/**
+ * Generate complete Terraform configuration
+ */
+declare function generateTerraformConfig(config: TerraformConfig, opts?: HclOptions): string;
+
+/**
+ * Result of writing terraform files
+ */
+interface WriteResult {
+    path: string;
+    content: string;
+}
+/**
+ * Options for writing terraform files
+ */
+interface WriteOptions extends HclOptions {
+    /** Add header comment to generated files */
+    header?: string;
+    /** File extension (default: .tf) */
+    extension?: string;
+}
+/**
+ * Generate terraform file content from config
+ */
+declare function generateTerraformFile(config: TerraformConfig, options?: WriteOptions): string;
+/**
+ * Generate multiple terraform files (e.g., main.tf, variables.tf, outputs.tf)
+ */
+declare function generateTerraformFiles(config: TerraformConfig, options?: WriteOptions): WriteResult[];
+/**
+ * Create a terraform file writer that can be used with a file system
+ */
+declare function createFileWriter(writeFile: (path: string, content: string) => Promise<void>): (results: WriteResult[], basePath?: string) => Promise<void>;
+/**
+ * Format content for a specific purpose (e.g., tfvars)
+ */
+declare function formatForTfvars(values: Record<string, unknown>): string;
+
+/**
+ * Builder for creating Terraform configurations
+ */
+declare class TerraformConfigBuilder {
+    private config;
+    /**
+     * Set required Terraform version
+     */
+    requiredVersion(version: string): this;
+    /**
+     * Add a required provider
+     */
+    requiredProvider(name: string, provider: RequiredProvider): this;
+    /**
+     * Set backend configuration
+     */
+    backend(backend: BackendConfig): this;
+    /**
+     * Add a provider configuration
+     */
+    provider(provider: string, config?: Record<string, HclValue>, alias?: string): this;
+    /**
+     * Add a variable
+     */
+    variable(name: string, type: string, options?: {
+        description?: string;
+        default?: HclValue;
+        sensitive?: boolean;
+    }): this;
+    /**
+     * Add locals
+     */
+    locals(values: Record<string, HclValue>): this;
+    /**
+     * Add a resource
+     */
+    resource(type: string, name: string, config: Record<string, HclValue>): this;
+    /**
+     * Add a data source
+     */
+    data(type: string, name: string, config: Record<string, HclValue>): this;
+    /**
+     * Add a module
+     */
+    module(name: string, source: string, config?: Record<string, HclValue>, version?: string): this;
+    /**
+     * Add an output
+     */
+    output(name: string, value: HclValue, options?: {
+        description?: string;
+        sensitive?: boolean;
+    }): this;
+    /**
+     * Get the built configuration
+     */
+    build(): TerraformConfig;
+    /**
+     * Generate HCL string
+     */
+    toHcl(options?: HclOptions): string;
+}
+/**
+ * Create a new Terraform configuration builder
+ */
+declare function terraform(): TerraformConfigBuilder;
+/**
+ * Common backend configurations
+ */
+declare const backends: {
+    /**
+     * S3 backend configuration
+     */
+    s3: (config: {
+        bucket: string;
+        key: string;
+        region: string;
+        encrypt?: boolean;
+        dynamodb_table?: string;
+    }) => BackendConfig;
+    /**
+     * GCS backend configuration
+     */
+    gcs: (config: {
+        bucket: string;
+        prefix: string;
+    }) => BackendConfig;
+    /**
+     * Azure backend configuration
+     */
+    azurerm: (config: {
+        resource_group_name: string;
+        storage_account_name: string;
+        container_name: string;
+        key: string;
+    }) => BackendConfig;
+    /**
+     * Local backend configuration
+     */
+    local: (path?: string) => BackendConfig;
+    /**
+     * Terraform Cloud backend configuration
+     */
+    cloud: (config: {
+        organization: string;
+        workspaces: {
+            name: string;
+        };
+    }) => BackendConfig;
+};
+/**
+ * Common provider configurations
+ */
+declare const providers: {
+    /**
+     * AWS provider
+     */
+    aws: (region: string, profile?: string) => {
+        provider: string;
+        config: {
+            profile?: string | undefined;
+            region: string;
+        };
+    };
+    /**
+     * Cloudflare provider
+     */
+    cloudflare: (apiToken?: string) => {
+        provider: string;
+        config: {
+            api_token: string;
+        } | {
+            api_token?: undefined;
+        };
+    };
+    /**
+     * Google provider
+     */
+    google: (project: string, region: string) => {
+        provider: string;
+        config: {
+            project: string;
+            region: string;
+        };
+    };
+    /**
+     * Azure provider
+     */
+    azurerm: (features?: Record<string, HclValue>) => {
+        provider: string;
+        config: {
+            features: Record<string, HclValue>;
+        };
+    };
+};
+
+/**
+ * Tfvars file generator
+ */
+interface TfvarsConfig {
+    /** Variable values */
+    values: Record<string, unknown>;
+    /** Optional header comment */
+    header?: string;
+}
+/**
+ * Generate a tfvars file content
+ */
+declare function generateTfvars(config: TfvarsConfig): string;
+/**
+ * Generate environment-specific tfvars
+ */
+declare function generateEnvTfvars(environment: string, values: Record<string, unknown>, options?: {
+    header?: boolean;
+}): {
+    filename: string;
+    content: string;
+};
+/**
+ * Builder for tfvars files
+ */
+declare class TfvarsBuilder {
+    private values;
+    private header?;
+    /**
+     * Set header comment
+     */
+    withHeader(header: string): this;
+    /**
+     * Set a string variable
+     */
+    string(name: string, value: string): this;
+    /**
+     * Set a number variable
+     */
+    number(name: string, value: number): this;
+    /**
+     * Set a boolean variable
+     */
+    bool(name: string, value: boolean): this;
+    /**
+     * Set a list variable
+     */
+    list(name: string, value: unknown[]): this;
+    /**
+     * Set a map variable
+     */
+    map(name: string, value: Record<string, unknown>): this;
+    /**
+     * Set a variable of any type
+     */
+    set(name: string, value: unknown): this;
+    /**
+     * Set multiple variables at once
+     */
+    setAll(values: Record<string, unknown>): this;
+    /**
+     * Build the tfvars content
+     */
+    build(): string;
+    /**
+     * Get the values as an object
+     */
+    toObject(): Record<string, unknown>;
+}
+/**
+ * Create a new tfvars builder
+ */
+declare function tfvars(): TfvarsBuilder;
+/**
+ * Merge multiple tfvars into one
+ */
+declare function mergeTfvars(...sources: Record<string, unknown>[]): Record<string, unknown>;
+/**
+ * Create tfvars from environment variables
+ *
+ * @example
+ * ```ts
+ * const vars = tfvarsFromEnv(
+ *   { cloudflare_account_id: 'CF_ACCOUNT_ID' },
+ *   process.env
+ * );
+ * ```
+ */
+declare function tfvarsFromEnv(mapping: Record<string, string>, env: Record<string, string | undefined>): Record<string, unknown>;
+
+/**
+ * Backend configuration builder
+ */
+declare class BackendBuilder {
+    private type;
+    private config;
+    constructor(type: string);
+    /**
+     * Set a configuration option
+     */
+    set(key: string, value: HclValue): this;
+    /**
+     * Set multiple configuration options
+     */
+    setAll(config: Record<string, HclValue>): this;
+    /**
+     * Build the backend configuration
+     */
+    build(): BackendConfig;
+}
+/**
+ * Create a backend builder
+ */
+declare function backend(type: string): BackendBuilder;
+/**
+ * S3 backend builder with type-safe options
+ */
+interface S3BackendOptions {
+    bucket: string;
+    key: string;
+    region: string;
+    encrypt?: boolean;
+    dynamodb_table?: string;
+    workspace_key_prefix?: string;
+    acl?: string;
+    skip_credentials_validation?: boolean;
+    skip_metadata_api_check?: boolean;
+    skip_region_validation?: boolean;
+    profile?: string;
+    role_arn?: string;
+}
+/**
+ * Create an S3 backend configuration
+ */
+declare function s3Backend(options: S3BackendOptions): BackendConfig;
+/**
+ * GCS backend options
+ */
+interface GcsBackendOptions {
+    bucket: string;
+    prefix?: string;
+    credentials?: string;
+    encryption_key?: string;
+}
+/**
+ * Create a GCS backend configuration
+ */
+declare function gcsBackend(options: GcsBackendOptions): BackendConfig;
+/**
+ * Azure backend options
+ */
+interface AzureBackendOptions {
+    resource_group_name: string;
+    storage_account_name: string;
+    container_name: string;
+    key: string;
+    access_key?: string;
+    sas_token?: string;
+    use_oidc?: boolean;
+    subscription_id?: string;
+    tenant_id?: string;
+    client_id?: string;
+}
+/**
+ * Create an Azure backend configuration
+ */
+declare function azureBackend(options: AzureBackendOptions): BackendConfig;
+/**
+ * Terraform Cloud backend options
+ */
+interface TerraformCloudOptions {
+    organization: string;
+    workspaces: {
+        name: string;
+    } | {
+        tags: string[];
+    } | {
+        project: string;
+    };
+    hostname?: string;
+    token?: string;
+}
+/**
+ * Create a Terraform Cloud backend configuration
+ */
+declare function terraformCloudBackend(options: TerraformCloudOptions): BackendConfig;
+/**
+ * Create a local backend configuration
+ */
+declare function localBackend(path?: string): BackendConfig;
+/**
+ * Consul backend options
+ */
+interface ConsulBackendOptions {
+    address: string;
+    path: string;
+    scheme?: 'http' | 'https';
+    datacenter?: string;
+    access_token?: string;
+    gzip?: boolean;
+    lock?: boolean;
+}
+/**
+ * Create a Consul backend configuration
+ */
+declare function consulBackend(options: ConsulBackendOptions): BackendConfig;
+
+/**
+ * Module definition with typed inputs and outputs
+ */
+interface ModuleDefinition<TInputs extends Record<string, unknown> = Record<string, unknown>, TOutputs extends Record<string, string> = Record<string, string>> {
+    /** Module source (registry, git, local path) */
+    source: string;
+    /** Module version (for registry modules) */
+    version?: string;
+    /** Available input variables */
+    inputs: TInputs;
+    /** Available output attributes */
+    outputs: TOutputs;
+}
+/**
+ * Create a typed module instance
+ */
+interface ModuleInstance<TOutputs extends Record<string, string>> {
+    /** Module name */
+    name: string;
+    /** Get an output reference */
+    output<K extends keyof TOutputs>(key: K): HclExpression;
+    /** Get the module configuration */
+    config: ModuleConfig;
+}
+/**
+ * Create a module definition
+ */
+declare function defineModule<TInputs extends Record<string, unknown>, TOutputs extends Record<string, string>>(source: string, version?: string): ModuleDefinition<TInputs, TOutputs>;
+/**
+ * Create a module instance from a definition
+ */
+declare function useModule<TInputs extends Record<string, unknown>, TOutputs extends Record<string, string>>(definition: ModuleDefinition<TInputs, TOutputs>, name: string, inputs: Partial<TInputs>): ModuleInstance<TOutputs>;
+/**
+ * Create a reference to a module output
+ */
+declare function moduleOutput(moduleName: string, outputName: string): HclExpression;
+/**
+ * Create a reference to a resource attribute
+ */
+declare function resourceRef(type: string, name: string, attribute: string): HclExpression;
+/**
+ * Create a reference to a data source attribute
+ */
+declare function dataRef(type: string, name: string, attribute: string): HclExpression;
+/**
+ * Create a reference to a variable
+ */
+declare function varRef(name: string): HclExpression;
+/**
+ * Create a reference to a local value
+ */
+declare function localRef(name: string): HclExpression;
+/**
+ * Common Terraform functions as expressions
+ */
+declare const tf: {
+    /** file() function */
+    file: (path: string) => HclExpression;
+    /** templatefile() function */
+    templatefile: (path: string, vars: string) => HclExpression;
+    /** jsonencode() function */
+    jsonencode: (value: string) => HclExpression;
+    /** jsondecode() function */
+    jsondecode: (value: string) => HclExpression;
+    /** lookup() function */
+    lookup: (map: string, key: string, defaultValue?: string) => HclExpression;
+    /** element() function */
+    element: (list: string, index: number | string) => HclExpression;
+    /** length() function */
+    length: (value: string) => HclExpression;
+    /** coalesce() function */
+    coalesce: (...values: string[]) => HclExpression;
+    /** join() function */
+    join: (separator: string, list: string) => HclExpression;
+    /** split() function */
+    split: (separator: string, value: string) => HclExpression;
+    /** format() function */
+    format: (formatStr: string, ...args: string[]) => HclExpression;
+    /** each.key */
+    eachKey: HclExpression;
+    /** each.value */
+    eachValue: HclExpression;
+    /** count.index */
+    countIndex: HclExpression;
+    /** self reference */
+    self: (attribute: string) => HclExpression;
+    /** path.module */
+    pathModule: HclExpression;
+    /** path.root */
+    pathRoot: HclExpression;
+    /** path.cwd */
+    pathCwd: HclExpression;
+    /** terraform.workspace */
+    workspace: HclExpression;
+};
+
+/**
+ * Cloudflare Worker script configuration
+ */
+interface WorkerScriptConfig {
+    /** Worker name */
+    name: string;
+    /** Account ID */
+    accountId: string | HclExpression;
+    /** Script content or path to script file */
+    content: string | HclExpression;
+    /** Module format (esm or service-worker) */
+    module?: boolean;
+    /** Compatibility date */
+    compatibilityDate?: string;
+    /** Compatibility flags */
+    compatibilityFlags?: string[];
+    /** Logpush enabled */
+    logpush?: boolean;
+    /** KV namespace bindings */
+    kvNamespaces?: WorkerKvBinding[];
+    /** D1 database bindings */
+    d1Databases?: WorkerD1Binding[];
+    /** R2 bucket bindings */
+    r2Buckets?: WorkerR2Binding[];
+    /** Environment variables (plain text) */
+    plainTextBindings?: Record<string, string>;
+    /** Secret bindings */
+    secretTextBindings?: Record<string, HclExpression>;
+    /** Service bindings */
+    serviceBindings?: WorkerServiceBinding[];
+}
+/**
+ * Worker KV namespace binding
+ */
+interface WorkerKvBinding {
+    name: string;
+    namespaceId: string | HclExpression;
+}
+/**
+ * Worker D1 database binding
+ */
+interface WorkerD1Binding {
+    name: string;
+    databaseId: string | HclExpression;
+}
+/**
+ * Worker R2 bucket binding
+ */
+interface WorkerR2Binding {
+    name: string;
+    bucketName: string | HclExpression;
+}
+/**
+ * Worker service binding
+ */
+interface WorkerServiceBinding {
+    name: string;
+    service: string;
+    environment?: string;
+}
+/**
+ * Create a Cloudflare Worker script resource
+ */
+declare function cloudflareWorkerScript(config: WorkerScriptConfig): ResourceConfig;
+/**
+ * Cloudflare Worker route configuration
+ */
+interface WorkerRouteConfig {
+    /** Route pattern (e.g., "example.com/*") */
+    pattern: string;
+    /** Zone ID */
+    zoneId: string | HclExpression;
+    /** Script name (reference to worker script) */
+    scriptName: string | HclExpression;
+}
+/**
+ * Create a Cloudflare Worker route resource
+ */
+declare function cloudflareWorkerRoute(config: WorkerRouteConfig): ResourceConfig;
+/**
+ * Cloudflare Worker custom domain configuration
+ */
+interface WorkerDomainConfig {
+    /** Account ID */
+    accountId: string | HclExpression;
+    /** Zone ID */
+    zoneId: string | HclExpression;
+    /** Hostname */
+    hostname: string;
+    /** Service (worker script name) */
+    service: string | HclExpression;
+    /** Environment (default: "production") */
+    environment?: string;
+}
+/**
+ * Create a Cloudflare Worker domain resource
+ */
+declare function cloudflareWorkerDomain(config: WorkerDomainConfig): ResourceConfig;
+/**
+ * Create a reference to a worker script
+ */
+declare function workerScriptRef(name: string, attribute?: string): HclExpression;
+
+/**
+ * Cloudflare KV namespace configuration
+ */
+interface KvNamespaceConfig {
+    /** Namespace title */
+    title: string;
+    /** Account ID */
+    accountId: string | HclExpression;
+}
+/**
+ * Create a Cloudflare KV namespace resource
+ */
+declare function cloudflareKvNamespace(config: KvNamespaceConfig): ResourceConfig;
+/**
+ * Cloudflare KV pair configuration
+ */
+interface KvPairConfig {
+    /** Namespace ID */
+    namespaceId: string | HclExpression;
+    /** Account ID */
+    accountId: string | HclExpression;
+    /** Key name */
+    key: string;
+    /** Value */
+    value: string | HclExpression;
+}
+/**
+ * Create a Cloudflare KV pair resource
+ */
+declare function cloudflareKvPair(config: KvPairConfig): ResourceConfig;
+/**
+ * Create a reference to a KV namespace
+ */
+declare function kvNamespaceRef(name: string, attribute?: string): HclExpression;
+/**
+ * Create multiple KV namespaces for different environments
+ */
+declare function cloudflareKvNamespaces(accountId: string | HclExpression, baseName: string, environments?: string[]): ResourceConfig[];
+/**
+ * Bulk KV configuration
+ */
+interface BulkKvConfig {
+    /** Account ID */
+    accountId: string | HclExpression;
+    /** Namespace ID */
+    namespaceId: string | HclExpression;
+    /** Key-value pairs */
+    entries: Record<string, string>;
+    /** Resource name prefix */
+    namePrefix?: string;
+}
+/**
+ * Create multiple KV pairs from an object
+ */
+declare function cloudflareKvBulk(config: BulkKvConfig): ResourceConfig[];
+
+/**
+ * Cloudflare D1 database configuration
+ */
+interface D1DatabaseConfig {
+    /** Database name */
+    name: string;
+    /** Account ID */
+    accountId: string | HclExpression;
+}
+/**
+ * Create a Cloudflare D1 database resource
+ */
+declare function cloudflareD1Database(config: D1DatabaseConfig): ResourceConfig;
+/**
+ * Create a reference to a D1 database
+ */
+declare function d1DatabaseRef(name: string, attribute?: string): HclExpression;
+/**
+ * Create multiple D1 databases for different environments
+ */
+declare function cloudflareD1Databases(accountId: string | HclExpression, baseName: string, environments?: string[]): ResourceConfig[];
+/**
+ * D1 database outputs configuration
+ */
+interface D1OutputsConfig {
+    /** Database resource name */
+    resourceName: string;
+    /** Output name prefix */
+    prefix?: string;
+}
+/**
+ * Create outputs for a D1 database
+ */
+declare function d1DatabaseOutputs(config: D1OutputsConfig): Record<string, {
+    value: HclExpression;
+    description?: string;
+}>;
+
+/**
+ * Cloudflare R2 bucket configuration
+ */
+interface R2BucketConfig {
+    /** Bucket name */
+    name: string;
+    /** Account ID */
+    accountId: string | HclExpression;
+    /** Location hint (optional) */
+    location?: 'wnam' | 'enam' | 'weur' | 'eeur' | 'apac';
+}
+/**
+ * Create a Cloudflare R2 bucket resource
+ */
+declare function cloudflareR2Bucket(config: R2BucketConfig): ResourceConfig;
+/**
+ * Create a reference to an R2 bucket
+ */
+declare function r2BucketRef(name: string, attribute?: string): HclExpression;
+/**
+ * Create multiple R2 buckets for different purposes
+ */
+declare function cloudflareR2Buckets(accountId: string | HclExpression, buckets: Array<{
+    name: string;
+    location?: R2BucketConfig['location'];
+}>): ResourceConfig[];
+/**
+ * R2 bucket with CORS configuration (note: CORS is configured via API, not Terraform)
+ * This creates outputs that can be used to configure CORS separately
+ */
+interface R2BucketWithCorsConfig extends R2BucketConfig {
+    /** Allowed origins for CORS */
+    corsOrigins?: string[];
+    /** Allowed methods for CORS */
+    corsMethods?: string[];
+}
+/**
+ * Create R2 bucket outputs
+ */
+declare function r2BucketOutputs(resourceName: string, prefix?: string): Record<string, {
+    value: HclExpression;
+    description?: string;
+}>;
+/**
+ * Create multiple R2 buckets for different environments
+ */
+declare function cloudflareR2BucketsForEnvs(accountId: string | HclExpression, baseName: string, environments?: string[], location?: R2BucketConfig['location']): ResourceConfig[];
+
+/**
+ * Cloudflare provider required_providers configuration
+ */
+declare const cloudflareProvider: {
+    source: string;
+    version: string;
+};
+/**
+ * Common Cloudflare variable definitions
+ */
+declare const cloudflareVariables: {
+    account_id: {
+        type: string;
+        description: string;
+        sensitive: boolean;
+    };
+    api_token: {
+        type: string;
+        description: string;
+        sensitive: boolean;
+    };
+    zone_id: {
+        type: string;
+        description: string;
+    };
+};
+/**
+ * Create a reference to var.cloudflare_account_id
+ */
+declare const cfAccountId: HclExpression;
+/**
+ * Create a reference to var.cloudflare_zone_id
+ */
+declare const cfZoneId: HclExpression;
+
+export { type AzureBackendOptions, BackendBuilder, type BackendConfig, type BlockType, type BulkKvConfig, type ConsulBackendOptions, type D1DatabaseConfig, type D1OutputsConfig, type DataSourceConfig, type GcsBackendOptions, type HclExpression, type HclOptions, type HclValue, type KvNamespaceConfig, type KvPairConfig, type ModuleConfig, type ModuleDefinition, type ModuleInstance, type OutputConfig, type ProviderConfig, type R2BucketConfig, type R2BucketWithCorsConfig, type RequiredProvider, type ResourceConfig, type S3BackendOptions, type TerraformBlock, type TerraformCloudOptions, type TerraformConfig, TerraformConfigBuilder, TfvarsBuilder, type TfvarsConfig, type VariableConfig, type WorkerD1Binding, type WorkerDomainConfig, type WorkerKvBinding, type WorkerR2Binding, type WorkerRouteConfig, type WorkerScriptConfig, type WorkerServiceBinding, type WriteOptions, type WriteResult, azureBackend, backend, backends, cfAccountId, cfZoneId, cloudflareD1Database, cloudflareD1Databases, cloudflareKvBulk, cloudflareKvNamespace, cloudflareKvNamespaces, cloudflareKvPair, cloudflareProvider, cloudflareR2Bucket, cloudflareR2Buckets, cloudflareR2BucketsForEnvs, cloudflareVariables, cloudflareWorkerDomain, cloudflareWorkerRoute, cloudflareWorkerScript, consulBackend, createFileWriter, d1DatabaseOutputs, d1DatabaseRef, dataRef, defineModule, expr, formatBlock, formatForTfvars, gcsBackend, generateDataSource, generateEnvTfvars, generateLocals, generateModule, generateOutput, generateProvider, generateResource, generateTerraformBlock, generateTerraformConfig, generateTerraformFile, generateTerraformFiles, generateTfvars, generateVariable, isHclExpression, kvNamespaceRef, localBackend, localRef, mergeTfvars, moduleOutput, providers, r2BucketOutputs, r2BucketRef, resourceRef, s3Backend, terraform, terraformCloudBackend, tf, tfvars, tfvarsFromEnv, toHcl, useModule, varRef, workerScriptRef };