@vritti/api-sdk 0.3.6 → 0.3.8

package/dist/pluralize.cjs

@@ -0,0 +1,41 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/pluralize.ts
+var pluralize_exports = {};
+__export(pluralize_exports, {
+  pluralize: () => import_pluralize_esm.default
+});
+module.exports = __toCommonJS(pluralize_exports);
+var import_pluralize_esm = __toESM(require("pluralize-esm"), 1);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluralize
+});
+//# sourceMappingURL=pluralize.cjs.map

package/dist/pluralize.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/pluralize.ts"],"sourcesContent":["// Re-export pluralize-esm's default export as the subpath entry point\nexport { default as pluralize } from 'pluralize-esm';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;AACA,2BAAqC;","names":[]}

package/dist/pluralize.d.cts

@@ -0,0 +1 @@
+export { default as pluralize } from 'pluralize-esm';

package/dist/pluralize.d.ts

@@ -0,0 +1 @@
+export { default as pluralize } from 'pluralize-esm';

package/dist/pluralize.js

@@ -0,0 +1,6 @@
+// src/pluralize.ts
+import { default as default2 } from "pluralize-esm";
+export {
+  default2 as pluralize
+};
+//# sourceMappingURL=pluralize.js.map

package/dist/pluralize.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/pluralize.ts"],"sourcesContent":["// Re-export pluralize-esm's default export as the subpath entry point\nexport { default as pluralize } from 'pluralize-esm';\n"],"mappings":";AACA,SAAoBA,WAAXC,gBAA4B;","names":["pluralize","default"]}

package/dist/storage.cjs

@@ -0,0 +1,571 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/storage/index.ts
+var storage_exports = {};
+__export(storage_exports, {
+  BucketUsageReader: () => BucketUsageReader,
+  OrgStorageProvisionerFactory: () => OrgStorageProvisionerFactory,
+  R2BucketProvisioner: () => R2BucketProvisioner,
+  R2StorageProvider: () => R2StorageProvider,
+  StorageFactory: () => StorageFactory,
+  orgBucketNames: () => orgBucketNames,
+  readConfigSource: () => readConfigSource
+});
+module.exports = __toCommonJS(storage_exports);
+
+// src/storage/bucket-usage.reader.ts
+var import_common = require("@nestjs/common");
+var CF_GRAPHQL = "https://api.cloudflare.com/client/v4/graphql";
+var QUERY = `query BucketUsage($accountTag: string!, $bucketName: string, $start: Time, $end: Time) {
+  viewer {
+    accounts(filter: { accountTag: $accountTag }) {
+      r2StorageAdaptiveGroups(
+        limit: 1
+        filter: { datetime_geq: $start, datetime_leq: $end, bucketName: $bucketName }
+        orderBy: [datetime_DESC]
+      ) {
+        max { objectCount payloadSize metadataSize }
+        dimensions { datetime }
+      }
+    }
+  }
+}`;
+var BucketUsageReader = class _BucketUsageReader {
+  static {
+    __name(this, "BucketUsageReader");
+  }
+  config;
+  logger = new import_common.Logger(_BucketUsageReader.name);
+  constructor(config) {
+    this.config = config;
+  }
+  // Returns the newest reported sample, or zeroes for a bucket the dataset has not reported on yet (a new or
+  // empty bucket produces no rows at all rather than a row of zeroes)
+  async getBucketUsage(bucketName, windowHours = 24) {
+    const end = /* @__PURE__ */ new Date();
+    const start = new Date(end.getTime() - windowHours * 60 * 60 * 1e3);
+    const response = await fetch(CF_GRAPHQL, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.config.analyticsToken}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        query: QUERY,
+        variables: {
+          accountTag: this.config.accountId,
+          bucketName,
+          start: start.toISOString(),
+          end: end.toISOString()
+        }
+      })
+    });
+    const body = await response.json();
+    if (body.errors?.length) {
+      throw new Error(`Cloudflare usage query failed for ${bucketName}: ${body.errors.map((e) => e.message).join("; ")}`);
+    }
+    const sample = body.data?.viewer?.accounts?.[0]?.r2StorageAdaptiveGroups?.[0]?.max;
+    if (!sample) {
+      this.logger.debug(`No usage samples yet for bucket ${bucketName}`);
+      return {
+        bytes: 0,
+        objectCount: 0
+      };
+    }
+    return {
+      bytes: (sample.payloadSize ?? 0) + (sample.metadataSize ?? 0),
+      objectCount: sample.objectCount ?? 0
+    };
+  }
+};
+
+// src/storage/config-source.ts
+function readConfigSource(source, provider) {
+  if (source === void 0) {
+    throw new Error(`Storage provider '${provider}' is not configured.`);
+  }
+  return typeof source === "function" ? source() : source;
+}
+__name(readConfigSource, "readConfigSource");
+
+// src/storage/providers/r2-storage.provider.ts
+var import_client_s3 = require("@aws-sdk/client-s3");
+var import_s3_request_presigner = require("@aws-sdk/s3-request-presigner");
+var import_common21 = require("@nestjs/common");
+
+// src/exceptions/bad-gateway.exception.ts
+var import_common3 = require("@nestjs/common");
+
+// src/exceptions/base-field.exception.ts
+var import_common2 = require("@nestjs/common");
+var HttpProblemException = class extends import_common2.HttpException {
+  static {
+    __name(this, "HttpProblemException");
+  }
+  constructor(detailOrOptions, httpStatus) {
+    const options = typeof detailOrOptions === "string" ? {
+      detail: detailOrOptions
+    } : detailOrOptions;
+    super({
+      type: options.type ?? "about:blank",
+      label: options.label,
+      detail: options.detail,
+      errors: options.errors ?? []
+    }, httpStatus);
+  }
+};
+
+// src/exceptions/bad-request.exception.ts
+var import_common4 = require("@nestjs/common");
+
+// src/exceptions/conflict.exception.ts
+var import_common5 = require("@nestjs/common");
+
+// src/exceptions/forbidden.exception.ts
+var import_common6 = require("@nestjs/common");
+
+// src/exceptions/gone.exception.ts
+var import_common7 = require("@nestjs/common");
+
+// src/exceptions/internal-server-error.exception.ts
+var import_common8 = require("@nestjs/common");
+
+// src/exceptions/method-not-allowed.exception.ts
+var import_common9 = require("@nestjs/common");
+
+// src/exceptions/not-acceptable.exception.ts
+var import_common10 = require("@nestjs/common");
+
+// src/exceptions/not-found.exception.ts
+var import_common11 = require("@nestjs/common");
+var NotFoundException = class extends HttpProblemException {
+  static {
+    __name(this, "NotFoundException");
+  }
+  constructor(detailOrOptions) {
+    super(detailOrOptions ?? "Not Found", import_common11.HttpStatus.NOT_FOUND);
+  }
+};
+
+// src/exceptions/not-implemented.exception.ts
+var import_common12 = require("@nestjs/common");
+
+// src/exceptions/payload-too-large.exception.ts
+var import_common13 = require("@nestjs/common");
+
+// src/exceptions/request-timeout.exception.ts
+var import_common14 = require("@nestjs/common");
+
+// src/exceptions/service-unavailable.exception.ts
+var import_common15 = require("@nestjs/common");
+
+// src/exceptions/too-many-requests.exception.ts
+var import_common16 = require("@nestjs/common");
+
+// src/exceptions/unauthorized.exception.ts
+var import_common17 = require("@nestjs/common");
+
+// src/exceptions/unprocessable-entity.exception.ts
+var import_common18 = require("@nestjs/common");
+
+// src/exceptions/unsupported-media-type.exception.ts
+var import_common19 = require("@nestjs/common");
+
+// src/exceptions/validation.exception.ts
+var import_common20 = require("@nestjs/common");
+
+// src/storage/providers/r2-storage.provider.ts
+var R2StorageProvider = class _R2StorageProvider {
+  static {
+    __name(this, "R2StorageProvider");
+  }
+  config;
+  logger = new import_common21.Logger(_R2StorageProvider.name);
+  client;
+  constructor(config) {
+    this.config = config;
+    this.client = new import_client_s3.S3Client({
+      region: "auto",
+      endpoint: `https://${config.accountId}.r2.cloudflarestorage.com`,
+      credentials: {
+        accessKeyId: config.accessKeyId,
+        secretAccessKey: config.secretAccessKey
+      }
+    });
+  }
+  // Uploads a file buffer or stream
+  async upload(params) {
+    await this.client.send(new import_client_s3.PutObjectCommand({
+      Bucket: this.requireBucket(params.bucket, this.config.defaultBucket),
+      Key: params.key,
+      Body: params.body,
+      ContentType: params.contentType
+    }));
+    this.logger.log(`Uploaded file to R2: ${params.key}`);
+    return params.key;
+  }
+  // Uploads a file to a public bucket and returns its permanent URL
+  async uploadPublic(key, body, contentType, bucket) {
+    await this.client.send(new import_client_s3.PutObjectCommand({
+      Bucket: this.requireBucket(bucket, this.config.publicBucket),
+      Key: key,
+      Body: body,
+      ContentType: contentType
+    }));
+    const url = this.getPublicUrl(key);
+    this.logger.log(`Uploaded public file to R2: ${key} \u2192 ${url}`);
+    return url;
+  }
+  // Public URLs come from the configured custom domain, which maps to one bucket — R2 has no per-bucket URL to derive,
+  // so a multi-tenant caller with a bucket per org cannot build one at all
+  getPublicUrl(key) {
+    if (!this.config.publicUrl) {
+      throw new Error("R2 storage has no publicUrl configured; public URLs cannot be built.");
+    }
+    return `${this.config.publicUrl}/${key}`;
+  }
+  // Deletes a file
+  async delete(key, bucket) {
+    await this.client.send(new import_client_s3.DeleteObjectCommand({
+      Bucket: bucket ?? this.config.defaultBucket,
+      Key: key
+    }));
+    this.logger.log(`Deleted file from R2: ${key}`);
+  }
+  // Generates a presigned download URL (default 1 hour)
+  async getSignedUrl(key, expiresInSeconds = 3600, bucket) {
+    const command = new import_client_s3.GetObjectCommand({
+      Bucket: this.requireBucket(bucket, this.config.defaultBucket),
+      Key: key
+    });
+    return (0, import_s3_request_presigner.getSignedUrl)(this.client, command, {
+      expiresIn: expiresInSeconds
+    });
+  }
+  // Returns a readable stream
+  async getStream(key, bucket) {
+    const response = await this.client.send(new import_client_s3.GetObjectCommand({
+      Bucket: this.requireBucket(bucket, this.config.defaultBucket),
+      Key: key
+    }));
+    if (!response.Body) {
+      throw new NotFoundException("File not found in storage.");
+    }
+    return response.Body;
+  }
+  // One page of a bucket's contents. S3 has no "list everything" call and no bucket-size call — a full inventory is
+  // this looped until nextToken is absent, and each page is a Class A request.
+  async listObjects(bucket, continuationToken) {
+    const response = await this.client.send(new import_client_s3.ListObjectsV2Command({
+      Bucket: bucket,
+      ContinuationToken: continuationToken
+    }));
+    return {
+      objects: (response.Contents ?? []).map((o) => ({
+        key: o.Key ?? "",
+        size: o.Size ?? 0,
+        lastModified: o.LastModified ?? /* @__PURE__ */ new Date(0)
+      })),
+      nextToken: response.NextContinuationToken
+    };
+  }
+  // Failing loudly here beats letting a missing org bucket fall through to some other tenant's default
+  requireBucket(bucket, fallback) {
+    const resolved = bucket ?? fallback;
+    if (!resolved) {
+      throw new Error("No bucket supplied and R2 storage has no default bucket configured.");
+    }
+    return resolved;
+  }
+};
+
+// src/storage/provisioners/r2-bucket.provisioner.ts
+var import_node_crypto = require("crypto");
+var import_common22 = require("@nestjs/common");
+var CF_API = "https://api.cloudflare.com/client/v4";
+var BUCKET_ITEM_WRITE = "Workers R2 Storage Bucket Item Write";
+function orgBucketNames(subdomain) {
+  return {
+    storageBucket: `org-${subdomain}`,
+    storagePublicBucket: `org-${subdomain}-public`
+  };
+}
+__name(orgBucketNames, "orgBucketNames");
+var R2BucketProvisioner = class _R2BucketProvisioner {
+  static {
+    __name(this, "R2BucketProvisioner");
+  }
+  config;
+  logger = new import_common22.Logger(_R2BucketProvisioner.name);
+  jurisdiction;
+  bucketItemWriteGroupId = null;
+  constructor(config) {
+    this.config = config;
+    this.jurisdiction = config.jurisdiction ?? "default";
+  }
+  // Creates the org's two buckets and one credential scoped to just those buckets
+  async provisionOrg(subdomain) {
+    const names = orgBucketNames(subdomain);
+    await this.createBucket(names.storageBucket);
+    await this.createBucket(names.storagePublicBucket);
+    let publicUrl = null;
+    try {
+      publicUrl = await this.enablePublicAccess(names.storagePublicBucket);
+    } catch (error) {
+      this.logger.warn(`Public access not enabled for ${names.storagePublicBucket}: ${error}`);
+    }
+    const token = await this.createScopedToken(subdomain, [
+      names.storageBucket,
+      names.storagePublicBucket
+    ]);
+    return {
+      provider: "r2",
+      accountId: this.config.accountId,
+      bucket: names.storageBucket,
+      publicBucket: names.storagePublicBucket,
+      publicUrl,
+      accessKeyId: token.id,
+      // R2 derives the S3 pair from the token: key id = token id, secret = SHA-256 of the token value. The value is
+      // returned exactly once, so it is hashed here rather than handed back to a caller that might drop it.
+      secretAccessKey: (0, import_node_crypto.createHash)("sha256").update(token.value).digest("hex"),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  // Mints a replacement credential scoped to the same buckets. Returns only the credential pair, not a whole
+  // descriptor: the control plane does not hold the org's publicUrl, so it is in no position to rebuild one.
+  //
+  // The old token is NOT revoked here. Revoking before the caller has persisted the new credential would leave the org
+  // with no working key in the gap; deleteCredential is a separate call, made once the new one is stored.
+  async rotateCredential(subdomain, buckets) {
+    const token = await this.createScopedToken(subdomain, [
+      buckets.storageBucket,
+      buckets.storagePublicBucket
+    ]);
+    return {
+      accessKeyId: token.id,
+      secretAccessKey: (0, import_node_crypto.createHash)("sha256").update(token.value).digest("hex")
+    };
+  }
+  // Removes an org's buckets. R2 refuses to delete a bucket that still holds objects, so the uploading server must
+  // have emptied them first — a 'not empty' failure here means that step did not finish.
+  async deleteOrgBuckets(buckets) {
+    for (const bucket of [
+      buckets.storageBucket,
+      buckets.storagePublicBucket
+    ]) {
+      const response = await fetch(`${CF_API}/accounts/${this.config.accountId}/r2/buckets/${bucket}`, {
+        method: "DELETE",
+        headers: {
+          Authorization: `Bearer ${this.config.adminToken}`
+        }
+      });
+      const body = await response.json();
+      if (body.success || body.errors?.some((e) => e.code === 10006)) {
+        this.logger.log(`Deleted bucket ${bucket}`);
+        continue;
+      }
+      throw new Error(`Cloudflare bucket delete failed for ${bucket}: ${this.describe(body)}`);
+    }
+  }
+  // Revokes a credential by its access key id, which on R2 is the Cloudflare token id
+  async deleteCredential(accessKeyId) {
+    const response = await fetch(`${CF_API}/accounts/${this.config.accountId}/tokens/${accessKeyId}`, {
+      method: "DELETE",
+      headers: {
+        Authorization: `Bearer ${this.config.tokensToken}`
+      }
+    });
+    const body = await response.json();
+    if (!body.success) {
+      throw new Error(`Cloudflare token delete failed for ${accessKeyId}: ${this.describe(body)}`);
+    }
+    this.logger.log(`Revoked storage credential ${accessKeyId}`);
+  }
+  // Creates one bucket, treating an existing bucket as success so provisioning can be re-run to reconcile
+  async createBucket(name) {
+    const response = await fetch(`${CF_API}/accounts/${this.config.accountId}/r2/buckets`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.config.adminToken}`,
+        "Content-Type": "application/json",
+        "cf-r2-jurisdiction": this.jurisdiction
+      },
+      body: JSON.stringify({
+        name,
+        ...this.config.locationHint && {
+          locationHint: this.config.locationHint
+        }
+      })
+    });
+    const body = await response.json();
+    if (body.success) {
+      this.logger.log(`Created bucket ${name}`);
+      return;
+    }
+    if (body.errors?.some((e) => e.code === 10004)) return;
+    throw new Error(`Cloudflare bucket create failed for ${name}: ${this.describe(body)}`);
+  }
+  // Turns on the bucket's Cloudflare-managed domain and returns it. NOTE: r2.dev is rate limited and documented as
+  // non-production — sustained traffic gets 429s. A custom domain per bucket is the production answer, and drops into
+  // this same field.
+  async enablePublicAccess(bucket) {
+    const response = await fetch(`${CF_API}/accounts/${this.config.accountId}/r2/buckets/${bucket}/domains/managed`, {
+      method: "PUT",
+      headers: {
+        Authorization: `Bearer ${this.config.adminToken}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        enabled: true
+      })
+    });
+    const body = await response.json();
+    if (!body.success || !body.result?.domain) {
+      throw new Error(`Cloudflare enable public access failed for ${bucket}: ${this.describe(body)}`);
+    }
+    this.logger.log(`Enabled public access for ${bucket} \u2192 ${body.result.domain}`);
+    return `https://${body.result.domain}`;
+  }
+  // Mints an ACCOUNT-owned token that can only touch this org's buckets. Account-owned rather than user-owned so a
+  // tenant's credential does not die with whichever Cloudflare user happened to create the parent token. Requires the
+  // parent to hold `Account API Tokens Write`; a user-scoped `API Tokens: Edit` token is rejected here with 9109.
+  async createScopedToken(subdomain, buckets) {
+    const permissionGroupId = await this.resolveBucketItemWriteGroupId();
+    const resources = Object.fromEntries(buckets.map((bucket) => [
+      `com.cloudflare.edge.r2.bucket.${this.config.accountId}_${this.jurisdiction}_${bucket}`,
+      "*"
+    ]));
+    const response = await fetch(`${CF_API}/accounts/${this.config.accountId}/tokens`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.config.tokensToken}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        name: `org-${subdomain}`,
+        policies: [
+          {
+            effect: "allow",
+            permission_groups: [
+              {
+                id: permissionGroupId
+              }
+            ],
+            resources
+          }
+        ]
+      })
+    });
+    const body = await response.json();
+    if (!body.success || !body.result?.value) {
+      throw new Error(`Cloudflare token create failed for org-${subdomain}: ${this.describe(body)}`);
+    }
+    this.logger.log(`Minted storage credential for org-${subdomain} scoped to ${buckets.length} bucket(s)`);
+    return body.result;
+  }
+  // The create-token API takes permission group UUIDs, not names. Looked up once rather than hardcoded: a UUID copied
+  // from docs fails much later with an error that says nothing useful. Same account-scoped endpoint as creation.
+  async resolveBucketItemWriteGroupId() {
+    if (this.bucketItemWriteGroupId) return this.bucketItemWriteGroupId;
+    const response = await fetch(`${CF_API}/accounts/${this.config.accountId}/tokens/permission_groups`, {
+      headers: {
+        Authorization: `Bearer ${this.config.tokensToken}`
+      }
+    });
+    const body = await response.json();
+    const group = body.result?.find((g) => g.name === BUCKET_ITEM_WRITE);
+    if (!group) {
+      throw new Error(`Cloudflare permission group '${BUCKET_ITEM_WRITE}' not found: ${this.describe(body)}`);
+    }
+    this.bucketItemWriteGroupId = group.id;
+    return group.id;
+  }
+  describe(body) {
+    return body.errors?.map((e) => `${e.code} ${e.message}`).join("; ") || "unknown error";
+  }
+};
+
+// src/storage/provisioner.factory.ts
+var OrgStorageProvisionerFactory = class {
+  static {
+    __name(this, "OrgStorageProvisionerFactory");
+  }
+  options;
+  cache = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.options = options;
+  }
+  // Resolves a provisioner by provider name, constructing it once on first use
+  resolve(provider) {
+    const cached = this.cache.get(provider);
+    if (cached) return cached;
+    const created = this.create(provider);
+    this.cache.set(provider, created);
+    return created;
+  }
+  create(provider) {
+    switch (provider) {
+      case "r2":
+        return new R2BucketProvisioner(readConfigSource(this.options.r2, "r2"));
+      default:
+        throw new Error(`Unsupported storage provider: ${provider}`);
+    }
+  }
+};
+
+// src/storage/storage.factory.ts
+var StorageFactory = class {
+  static {
+    __name(this, "StorageFactory");
+  }
+  options;
+  cache = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.options = options;
+  }
+  // Resolves a provider by name, constructing it once on first use
+  resolve(provider) {
+    const cached = this.cache.get(provider);
+    if (cached) return cached;
+    const created = this.create(provider);
+    this.cache.set(provider, created);
+    return created;
+  }
+  create(provider) {
+    switch (provider) {
+      case "r2":
+        return new R2StorageProvider(readConfigSource(this.options.r2, "r2"));
+      default:
+        throw new Error(`Unsupported storage provider: ${provider}`);
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BucketUsageReader,
+  OrgStorageProvisionerFactory,
+  R2BucketProvisioner,
+  R2StorageProvider,
+  StorageFactory,
+  orgBucketNames,
+  readConfigSource
+});
+//# sourceMappingURL=storage.cjs.map