devflare 1.0.0-next.15 → 1.0.0-next.17

package/dist/index-0rsa2c1t.js

@@ -1,325 +0,0 @@
-import {
-  getLocalD1DatabaseIdentifier,
-  normalizeDOBinding
-} from "./index-tksw7gpy.js";
-import {
-  __require
-} from "./index-37x76zdn.js";
-
-// src/bridge/miniflare.ts
-function generateGatewayScript() {
-  return `
-// Gateway Worker — Provides RPC access to all bindings
-export default {
-	async fetch(request, env, ctx) {
-		const url = new URL(request.url)
-		
-		// Health check
-		if (url.pathname === '/_devflare/health') {
-			return new Response(JSON.stringify({ status: 'ok', bindings: Object.keys(env) }), {
-				headers: { 'Content-Type': 'application/json' }
-			})
-		}
-		
-		// RPC endpoint
-		if (url.pathname === '/_devflare/rpc' && request.method === 'POST') {
-			try {
-				const { method, params } = await request.json()
-				const result = await executeRpc(env, method, params)
-				return new Response(JSON.stringify({ ok: true, result }), {
-					headers: { 'Content-Type': 'application/json' }
-				})
-			} catch (error) {
-				return new Response(JSON.stringify({
-					ok: false,
-					error: { code: 'RPC_ERROR', message: error.message }
-				}), {
-					status: 500,
-					headers: { 'Content-Type': 'application/json' }
-				})
-			}
-		}
-		
-		return new Response('Devflare Gateway', { status: 200 })
-	}
-}
-
-async function executeRpc(env, method, params) {
-	const [bindingName, ...methodPath] = method.split('.')
-	const binding = env[bindingName]
-	const RAW_EMAIL = 'EmailMessage::raw'
-	
-	if (!binding) {
-		throw new Error(\`Binding "\${bindingName}" not found\`)
-	}
-	
-	const methodName = methodPath.join('.')
-	
-	// KV operations
-	if (methodName === 'get') return binding.get(params[0], params[1])
-	if (methodName === 'put') return binding.put(params[0], params[1], params[2])
-	if (methodName === 'delete') return binding.delete(params[0])
-	if (methodName === 'list') return binding.list(params[0])
-	if (methodName === 'getWithMetadata') return binding.getWithMetadata(params[0], params[1])
-	
-	// R2 operations
-	if (methodName === 'head') return binding.head(params[0])
-	if (methodName === 'r2.get') return serializeR2Object(await binding.get(params[0], params[1]))
-	if (methodName === 'r2.put') return serializeR2Object(await binding.put(params[0], params[1], params[2]))
-	if (methodName === 'r2.delete') return binding.delete(params[0])
-	if (methodName === 'r2.list') return serializeR2Objects(await binding.list(params[0]))
-	
-	// D1 operations
-	if (methodName === 'exec') return binding.exec(params[0])
-	if (methodName === 'batch') {
-		const statements = params[0].map(s => binding.prepare(s.sql).bind(...(s.bindings || [])))
-		return binding.batch(statements)
-	}
-	if (methodName.startsWith('stmt.')) {
-		const [, stmtMethod] = methodName.split('.')
-		const [sql, ...bindings] = params
-		const stmt = binding.prepare(sql).bind(...bindings.slice(0, -1))
-		
-		if (stmtMethod === 'first') return stmt.first(bindings[bindings.length - 1])
-		if (stmtMethod === 'all') return stmt.all()
-		if (stmtMethod === 'run') return stmt.run()
-		if (stmtMethod === 'raw') return stmt.raw(bindings[bindings.length - 1])
-	}
-	
-	// DO operations
-	if (methodName === 'idFromName') {
-		const id = binding.idFromName(params[0])
-		return { __type: 'DOId', hex: id.toString() }
-	}
-	if (methodName === 'idFromString') {
-		const id = binding.idFromString(params[0])
-		return { __type: 'DOId', hex: id.toString() }
-	}
-	if (methodName === 'newUniqueId') {
-		const id = binding.newUniqueId(params[0])
-		return { __type: 'DOId', hex: id.toString() }
-	}
-	if (methodName === 'stub.fetch') {
-		const [, doId, serializedReq] = params
-		const id = binding.idFromString(doId.hex)
-		const stub = binding.get(id)
-		const response = await stub.fetch(new Request(serializedReq.url, {
-			method: serializedReq.method,
-			headers: serializedReq.headers,
-			body: serializedReq.body?.type === 'bytes' ? atob(serializedReq.body.data) : undefined
-		}))
-		return serializeResponse(response)
-	}
-	if (methodName === 'stub.rpc') {
-		// DO RPC: Call a method on the DO instance
-		const [, doId, rpcMethod, rpcParams] = params
-		const id = binding.idFromString(doId.hex)
-		const stub = binding.get(id)
-		
-		// Use fetch to call the RPC endpoint
-		const response = await stub.fetch(new Request('http://do/_rpc', {
-			method: 'POST',
-			headers: { 'Content-Type': 'application/json' },
-			body: JSON.stringify({ method: rpcMethod, params: rpcParams })
-		}))
-		
-		const result = await response.json()
-		if (!result.ok) throw new Error(result.error?.message || 'RPC failed')
-		return result.result
-	}
-	
-	// Queue operations
-	if (methodName === 'send') return binding.send(params[0], params[1])
-	if (methodName === 'sendBatch') return binding.sendBatch(params[0], params[1])
-
-	// Send Email operations
-	if (methodName === 'email.send') {
-		const message = params[0]
-		if (message && typeof message === 'object' && 'from' in message && 'to' in message && 'raw' in message) {
-			return binding.send({
-				from: message.from,
-				to: message.to,
-				[RAW_EMAIL]: createEmailMessageRaw(message.raw)
-			})
-		}
-		return binding.send(message)
-	}
-	
-	// Generic fallback
-	if (typeof binding[methodName] === 'function') {
-		return binding[methodName](...params)
-	}
-	
-	throw new Error(\`Unknown method: \${method}\`)
-}
-
-function createEmailMessageRaw(raw) {
-	if (typeof raw === 'string' || raw instanceof ReadableStream) {
-		return raw
-	}
-	if (raw instanceof ArrayBuffer || raw instanceof Uint8Array) {
-		return new Response(raw).body
-	}
-	throw new Error('Unsupported EmailMessage raw payload')
-}
-
-function serializeResponse(response) {
-	return {
-		status: response.status,
-		statusText: response.statusText,
-		headers: [...response.headers.entries()],
-		body: null // Will be streamed separately for large bodies
-	}
-}
-
-function serializeR2Object(obj) {
-	if (!obj) return null
-	return {
-		key: obj.key,
-		version: obj.version,
-		size: obj.size,
-		etag: obj.etag,
-		httpEtag: obj.httpEtag,
-		uploaded: obj.uploaded?.toISOString(),
-		httpMetadata: obj.httpMetadata,
-		customMetadata: obj.customMetadata
-	}
-}
-
-function serializeR2Objects(result) {
-	if (!result) return null
-	return {
-		objects: result.objects.map(serializeR2Object),
-		truncated: result.truncated,
-		cursor: result.cursor,
-		delimitedPrefixes: result.delimitedPrefixes
-	}
-}
-`;
-}
-async function startMiniflare(options = {}) {
-  const { Miniflare, Log, LogLevel } = await import("miniflare");
-  const port = options.port ?? 8787;
-  const persistPath = options.persistPath ?? ".devflare/data";
-  const mfConfig = {
-    modules: true,
-    script: generateGatewayScript(),
-    port,
-    host: "127.0.0.1",
-    log: options.verbose ? new Log(LogLevel.DEBUG) : new Log(LogLevel.WARN),
-    compatibilityDate: options.compatibilityDate ?? "2024-01-01",
-    compatibilityFlags: options.compatibilityFlags ?? []
-  };
-  const hasBindings = (val) => {
-    if (!val)
-      return false;
-    if (Array.isArray(val))
-      return val.length > 0;
-    return Object.keys(val).length > 0;
-  };
-  if (hasBindings(options.kvNamespaces)) {
-    mfConfig.kvNamespaces = options.kvNamespaces;
-    if (options.persist) {
-      mfConfig.kvPersist = `${persistPath}/kv`;
-    }
-  }
-  if (hasBindings(options.r2Buckets)) {
-    mfConfig.r2Buckets = options.r2Buckets;
-    if (options.persist) {
-      mfConfig.r2Persist = `${persistPath}/r2`;
-    }
-  }
-  if (hasBindings(options.d1Databases)) {
-    mfConfig.d1Databases = options.d1Databases;
-    if (options.persist) {
-      mfConfig.d1Persist = `${persistPath}/d1`;
-    }
-  }
-  if (options.durableObjects) {
-    mfConfig.durableObjects = options.durableObjects;
-    if (options.persist) {
-      mfConfig.durableObjectsPersist = `${persistPath}/do`;
-    }
-  }
-  if (options.sendEmail) {
-    mfConfig.email = {
-      send_email: Object.entries(options.sendEmail).map(([name, config]) => ({
-        name,
-        ...config.destinationAddress && {
-          destination_address: config.destinationAddress
-        },
-        ...config.allowedDestinationAddresses && {
-          allowed_destination_addresses: config.allowedDestinationAddresses
-        },
-        ...config.allowedSenderAddresses && {
-          allowed_sender_addresses: config.allowedSenderAddresses
-        }
-      }))
-    };
-  }
-  if (options.bindings && Object.keys(options.bindings).length > 0) {
-    mfConfig.bindings = options.bindings;
-  }
-  if (options.queues?.length) {
-    mfConfig.queueProducers = Object.fromEntries(options.queues.map((q) => [q, { queueName: q }]));
-  }
-  const mf = new Miniflare(mfConfig);
-  await mf.ready;
-  return {
-    ready: Promise.resolve(),
-    async dispose() {
-      await mf.dispose();
-    },
-    async getBindings() {
-      return mf.getBindings();
-    },
-    getKVNamespace: mf.getKVNamespace.bind(mf),
-    getR2Bucket: mf.getR2Bucket.bind(mf),
-    getD1Database: mf.getD1Database.bind(mf),
-    getDurableObjectNamespace: mf.getDurableObjectNamespace.bind(mf),
-    dispatchFetch: mf.dispatchFetch.bind(mf),
-    _mf: mf
-  };
-}
-async function startMiniflareFromConfig(config, options = {}) {
-  const bindings = config.bindings ?? {};
-  const mfOptions = {
-    ...options,
-    compatibilityDate: config.compatibilityDate,
-    compatibilityFlags: config.compatibilityFlags,
-    kvNamespaces: bindings.kv ? bindings.kv : undefined,
-    r2Buckets: bindings.r2 ? bindings.r2 : undefined,
-    d1Databases: bindings.d1 ? Object.fromEntries(Object.entries(bindings.d1).map(([bindingName, bindingConfig]) => {
-      return [bindingName, getLocalD1DatabaseIdentifier(bindingConfig)];
-    })) : undefined,
-    queues: bindings.queues?.consumers?.map((c) => c.queue),
-    sendEmail: bindings.sendEmail ? bindings.sendEmail : undefined,
-    bindings: config.vars,
-    durableObjects: bindings.durableObjects ? Object.fromEntries(Object.entries(bindings.durableObjects).map(([bindingName, doConfig]) => {
-      const normalized = normalizeDOBinding(doConfig);
-      return [
-        bindingName,
-        {
-          className: normalized.className,
-          scriptPath: normalized.scriptName
-        }
-      ];
-    })) : undefined
-  };
-  return startMiniflare(mfOptions);
-}
-var globalMiniflare = null;
-async function getMiniflare(options) {
-  if (!globalMiniflare) {
-    globalMiniflare = await startMiniflare(options);
-  }
-  return globalMiniflare;
-}
-async function stopMiniflare() {
-  if (globalMiniflare) {
-    await globalMiniflare.dispose();
-    globalMiniflare = null;
-  }
-}
-
-export { startMiniflare, startMiniflareFromConfig, getMiniflare, stopMiniflare };

package/dist/index-2q3pmzrx.js

@@ -1,90 +0,0 @@
-import {
-  DEFAULT_ENTRYPOINT_PATTERN,
-  findFiles,
-  findFilesSync
-} from "./index-rbht7m9r.js";
-import {
-  __require
-} from "./index-37x76zdn.js";
-
-// src/utils/entrypoint-discovery.ts
-import { readFileSync } from "fs";
-var ENTRYPOINT_CLASS_PATTERN = /export\s+class\s+(\w+)\s+extends\s+WorkerEntrypoint/g;
-function findEntrypointClasses(code) {
-  const classes = [];
-  ENTRYPOINT_CLASS_PATTERN.lastIndex = 0;
-  let match;
-  while ((match = ENTRYPOINT_CLASS_PATTERN.exec(code)) !== null) {
-    classes.push(match[1]);
-  }
-  return classes;
-}
-function discoverEntrypointsSync(cwd, pattern = DEFAULT_ENTRYPOINT_PATTERN) {
-  const discovered = [];
-  try {
-    const files = findFilesSync(pattern, { cwd });
-    for (const file of files) {
-      try {
-        const code = readFileSync(file, "utf-8");
-        const classNames = findEntrypointClasses(code);
-        for (const className of classNames) {
-          discovered.push({ className, filePath: file });
-        }
-      } catch {}
-    }
-  } catch {}
-  return discovered;
-}
-async function discoverEntrypointsAsync(cwd, pattern = DEFAULT_ENTRYPOINT_PATTERN) {
-  const fs = await import("node:fs/promises");
-  const discovered = [];
-  const files = await findFiles(pattern, { cwd });
-  for (const filePath of files) {
-    try {
-      const code = await fs.readFile(filePath, "utf-8");
-      const classNames = findEntrypointClasses(code);
-      for (const className of classNames) {
-        discovered.push({ className, filePath });
-      }
-    } catch {}
-  }
-  return discovered;
-}
-
-// src/utils/resolve-package.ts
-import { resolve, dirname } from "pathe";
-import { readFileSync as readFileSync2, existsSync } from "node:fs";
-function resolvePackageSpecifier(specifier, fromDir) {
-  if (specifier.startsWith(".") || specifier.startsWith("/") || /^[A-Za-z]:/.test(specifier)) {
-    return resolve(fromDir, specifier);
-  }
-  try {
-    const parts = specifier.startsWith("@") ? specifier.split("/").slice(0, 2).join("/") : specifier.split("/")[0];
-    const subpath = specifier.startsWith("@") ? specifier.split("/").slice(2).join("/") : specifier.split("/").slice(1).join("/");
-    const pkgJsonPath = __require.resolve(`${parts}/package.json`, { paths: [fromDir] });
-    const pkgDir = dirname(pkgJsonPath);
-    if (subpath) {
-      const pkgJson = JSON.parse(readFileSync2(pkgJsonPath, "utf-8"));
-      const exportPath = pkgJson.exports?.[`./${subpath}`];
-      if (exportPath) {
-        const targetPath = typeof exportPath === "string" ? exportPath : exportPath.default || exportPath.import;
-        return resolve(pkgDir, targetPath);
-      }
-      const directPath = resolve(pkgDir, `${subpath}.ts`);
-      if (existsSync(directPath))
-        return directPath;
-      const withExt = resolve(pkgDir, subpath);
-      if (existsSync(withExt))
-        return withExt;
-      if (existsSync(`${withExt}.ts`))
-        return `${withExt}.ts`;
-      if (existsSync(`${withExt}.js`))
-        return `${withExt}.js`;
-    }
-    return pkgDir;
-  } catch {
-    return resolve(fromDir, specifier);
-  }
-}
-
-export { discoverEntrypointsSync, discoverEntrypointsAsync, resolvePackageSpecifier };

package/dist/index-5s1bz1e0.js

@@ -1,202 +0,0 @@
-import {
-  normalizeD1Binding,
-  normalizeDOBinding,
-  resolveConfigForEnvironment
-} from "./index-tksw7gpy.js";
-import {
-  __require
-} from "./index-37x76zdn.js";
-
-// src/config/compiler.ts
-function getWranglerD1DatabaseId(bindingName, bindingConfig) {
-  const normalized = normalizeD1Binding(bindingConfig);
-  if (normalized.databaseId) {
-    return normalized.databaseId;
-  }
-  throw new Error(`D1 binding "${bindingName}" is configured by name (${normalized.name}) and must be resolved before compiling Wrangler config. Use loadResolvedConfig() or resolveConfigResources() for build/deploy/automation flows.`);
-}
-function compileConfig(config, environment) {
-  const mergedConfig = resolveConfigForEnvironment(config, environment);
-  const result = {
-    name: mergedConfig.name,
-    compatibility_date: mergedConfig.compatibilityDate
-  };
-  if (mergedConfig.accountId) {
-    result.account_id = mergedConfig.accountId;
-  }
-  const mainEntry = mergedConfig.files?.fetch;
-  if (typeof mainEntry === "string") {
-    result.main = mainEntry;
-  }
-  if (mergedConfig.compatibilityFlags && mergedConfig.compatibilityFlags.length > 0) {
-    result.compatibility_flags = mergedConfig.compatibilityFlags;
-  }
-  if (mergedConfig.bindings) {
-    compileBindings(mergedConfig.bindings, result);
-  }
-  if (mergedConfig.triggers?.crons && mergedConfig.triggers.crons.length > 0) {
-    result.triggers = { crons: mergedConfig.triggers.crons };
-  }
-  if (mergedConfig.vars && Object.keys(mergedConfig.vars).length > 0) {
-    result.vars = mergedConfig.vars;
-  }
-  if (mergedConfig.routes && mergedConfig.routes.length > 0) {
-    result.routes = mergedConfig.routes.map((route) => ({
-      pattern: route.pattern,
-      ...route.zone_name && { zone_name: route.zone_name },
-      ...route.zone_id && { zone_id: route.zone_id },
-      ...route.custom_domain !== undefined && { custom_domain: route.custom_domain }
-    }));
-  }
-  if (mergedConfig.assets && mergedConfig.assets.directory) {
-    result.assets = {
-      directory: mergedConfig.assets.directory,
-      ...mergedConfig.assets.binding && { binding: mergedConfig.assets.binding }
-    };
-  }
-  if (mergedConfig.observability) {
-    result.observability = mergedConfig.observability;
-  }
-  if (mergedConfig.limits) {
-    result.limits = mergedConfig.limits;
-  }
-  if (mergedConfig.migrations && mergedConfig.migrations.length > 0) {
-    result.migrations = mergedConfig.migrations.map((migration) => ({
-      tag: migration.tag,
-      ...migration.new_classes && { new_classes: migration.new_classes },
-      ...migration.renamed_classes && {
-        renamed_classes: migration.renamed_classes.map((rc) => ({
-          from: rc.from,
-          to: rc.to
-        }))
-      },
-      ...migration.deleted_classes && { deleted_classes: migration.deleted_classes },
-      ...migration.new_sqlite_classes && { new_sqlite_classes: migration.new_sqlite_classes }
-    }));
-  }
-  if (mergedConfig.wrangler?.passthrough) {
-    Object.assign(result, mergedConfig.wrangler.passthrough);
-  }
-  return result;
-}
-function compileToProgrammaticConfig(config, environment) {
-  const wranglerConfig = compileConfig(config, environment);
-  return { ...wranglerConfig };
-}
-function compileBindings(bindings, result) {
-  if (bindings.kv) {
-    result.kv_namespaces = Object.entries(bindings.kv).map(([binding, id]) => ({
-      binding,
-      id
-    }));
-  }
-  if (bindings.d1) {
-    result.d1_databases = Object.entries(bindings.d1).map(([binding, database_id]) => ({
-      binding,
-      database_id: getWranglerD1DatabaseId(binding, database_id)
-    }));
-  }
-  if (bindings.r2) {
-    result.r2_buckets = Object.entries(bindings.r2).map(([binding, bucket_name]) => ({
-      binding,
-      bucket_name
-    }));
-  }
-  if (bindings.durableObjects) {
-    result.durable_objects = {
-      bindings: Object.entries(bindings.durableObjects).map(([name, config]) => {
-        const normalized = normalizeDOBinding(config);
-        const binding = {
-          name,
-          class_name: normalized.className
-        };
-        if (normalized.scriptName) {
-          binding.script_name = normalized.scriptName;
-        }
-        return binding;
-      })
-    };
-  }
-  if (bindings.queues) {
-    result.queues = {};
-    if (bindings.queues.producers) {
-      result.queues.producers = Object.entries(bindings.queues.producers).map(([binding, queue]) => ({ binding, queue }));
-    }
-    if (bindings.queues.consumers) {
-      result.queues.consumers = bindings.queues.consumers.map((consumer) => ({
-        queue: consumer.queue,
-        ...consumer.maxBatchSize && { max_batch_size: consumer.maxBatchSize },
-        ...consumer.maxBatchTimeout && { max_batch_timeout: consumer.maxBatchTimeout },
-        ...consumer.maxRetries && { max_retries: consumer.maxRetries },
-        ...consumer.deadLetterQueue && { dead_letter_queue: consumer.deadLetterQueue },
-        ...consumer.maxConcurrency && { max_concurrency: consumer.maxConcurrency },
-        ...consumer.retryDelay && { retry_delay: consumer.retryDelay }
-      }));
-    }
-  }
-  if (bindings.services) {
-    result.services = Object.entries(bindings.services).map(([binding, config]) => ({
-      binding,
-      service: config.service,
-      ...config.entrypoint && { entrypoint: config.entrypoint },
-      ...config.environment && { environment: config.environment }
-    }));
-  }
-  if (bindings.ai && bindings.ai.binding) {
-    result.ai = { binding: bindings.ai.binding };
-  }
-  if (bindings.vectorize) {
-    result.vectorize = Object.entries(bindings.vectorize).map(([binding, config]) => ({
-      binding,
-      index_name: config.indexName
-    }));
-  }
-  if (bindings.hyperdrive) {
-    result.hyperdrive = Object.entries(bindings.hyperdrive).map(([binding, config]) => ({
-      binding,
-      id: config.id
-    }));
-  }
-  if (bindings.browser && bindings.browser.binding) {
-    result.browser = { binding: bindings.browser.binding };
-  }
-  if (bindings.analyticsEngine) {
-    result.analytics_engine_datasets = Object.entries(bindings.analyticsEngine).map(([binding, config]) => ({
-      binding,
-      dataset: config.dataset
-    }));
-  }
-  if (bindings.sendEmail) {
-    result.send_email = Object.entries(bindings.sendEmail).map(([name, config]) => ({
-      name,
-      ...config.destinationAddress && {
-        destination_address: config.destinationAddress
-      },
-      ...config.allowedDestinationAddresses && {
-        allowed_destination_addresses: config.allowedDestinationAddresses
-      },
-      ...config.allowedSenderAddresses && {
-        allowed_sender_addresses: config.allowedSenderAddresses
-      }
-    }));
-  }
-}
-function stringifyConfig(config) {
-  const header = `// Generated by devflare — Do not edit directly
-// Edit devflare.config.ts instead
-
-`;
-  return header + JSON.stringify(config, null, "\t");
-}
-async function writeWranglerConfig(cwd, config, filename = "wrangler.jsonc") {
-  const { resolve } = await import("pathe");
-  const fs = await import("node:fs/promises");
-  try {
-    await fs.mkdir(cwd, { recursive: true });
-  } catch {}
-  const content = stringifyConfig(config);
-  const wranglerPath = resolve(cwd, filename);
-  await fs.writeFile(wranglerPath, content, "utf-8");
-  return wranglerPath;
-}
-export { compileConfig, compileToProgrammaticConfig, stringifyConfig, writeWranglerConfig };

package/dist/index-6nb7w45m.js

@@ -1,79 +0,0 @@
-import {
-  canProceedWithTest,
-  getAllUsageSummaries,
-  getLimits,
-  getUsage,
-  getUsageSummary,
-  isWithinLimits,
-  recordTestUsage,
-  recordUsage,
-  resetUsage,
-  setLimits,
-  setLimitsEnabled,
-  shouldSkip
-} from "./index-7bq4xq84.js";
-import {
-  clearGlobalDefaultAccountId,
-  getAccountById,
-  getAccountSummary,
-  getAccounts,
-  getAllServiceStatus,
-  getApiToken,
-  getEffectiveAccountId,
-  getGlobalDefaultAccountId,
-  getPrimaryAccount,
-  getServiceStatus,
-  getWorkspaceAccountId,
-  getWranglerAuth,
-  hasService,
-  hasWranglerConfig,
-  isAuthenticated,
-  listAIModels,
-  listD1Databases,
-  listKVNamespaces,
-  listR2Buckets,
-  listVectorizeIndexes,
-  listWorkers,
-  setGlobalDefaultAccountId,
-  setWorkspaceAccountId
-} from "./index-xdq9ery1.js";
-
-// src/cloudflare/index.ts
-var account = {
-  isAuthenticated,
-  hasWranglerConfig,
-  getApiToken,
-  getWranglerAuth,
-  getAccounts,
-  getPrimaryAccount,
-  getAccountById,
-  getAccountSummary,
-  workers: listWorkers,
-  kv: listKVNamespaces,
-  d1: listD1Databases,
-  r2: listR2Buckets,
-  vectorize: listVectorizeIndexes,
-  ai: listAIModels,
-  getServiceStatus,
-  getAllServiceStatus,
-  hasService,
-  getUsage,
-  recordUsage,
-  resetUsage,
-  getAllUsageSummaries,
-  getUsageSummary,
-  getLimits,
-  setLimits,
-  setLimitsEnabled,
-  isWithinLimits,
-  canProceedWithTest,
-  recordTestUsage,
-  shouldSkip,
-  getGlobalDefaultAccountId,
-  setGlobalDefaultAccountId,
-  getWorkspaceAccountId,
-  setWorkspaceAccountId,
-  getEffectiveAccountId,
-  clearGlobalDefaultAccountId
-};
-export { account };