@alchemy.run/e2b 0.0.0 → 2.0.0-beta.86

package/src/Volume.ts

@@ -0,0 +1,173 @@
+import * as volumes from "@distilled.cloud/e2b/volumes";
+import { Unowned } from "alchemy/AdoptPolicy";
+import { isResolved } from "alchemy/Diff";
+import * as Provider from "alchemy/Provider";
+import { Resource } from "alchemy/Resource";
+import * as Effect from "effect/Effect";
+import { E2BUnexpectedResponse } from "./Errors.ts";
+import { e2bName, isGeneratedName } from "./internal/Ownership.ts";
+import type { Providers } from "./Providers.ts";
+
+export interface VolumeProps {
+  /**
+   * Volume name, unique within the team. Letters, digits, `-` and `_`. If
+   * omitted, a unique name is generated from the stack, stage and logical ID.
+   * Changing it replaces the volume, and its files are lost.
+   */
+  name?: string;
+}
+
+export interface VolumeAttributes {
+  /** E2B's volume id. */
+  volumeId: string;
+  /** The volume's name. Sandboxes mount a volume by name. */
+  name: string;
+}
+
+export interface Volume extends Resource<
+  "E2B.Volume",
+  VolumeProps,
+  VolumeAttributes,
+  never,
+  Providers,
+  { name: string }
+> {}
+
+/**
+ * A persistent E2B volume: a team-wide filesystem that sandboxes mount at a
+ * path and that outlives every sandbox using it.
+ *
+ * Declare a volume when every sandbox shares it (a package cache, a
+ * dataset). Per-user and per-session volumes are created at runtime by name
+ * with `E2B.CreateVolume()`, and both kinds mount the same way.
+ *
+ * E2B volumes carry no labels, so Alchemy recognises its volumes by their
+ * generated name. A volume found under an explicit name without prior state
+ * is reported as unowned and is only adopted with `--adopt`.
+ *
+ * E2B enables volumes per team; on a team without them, a deploy fails
+ * with `VolumesNotEnabled`.
+ *
+ * ### Creating a Volume
+ * **Example:** A shared cache volume
+ * ```typescript
+ * export const Cache = E2B.Volume("Cache", {});
+ * ```
+ *
+ * **Example:** A volume with a fixed name
+ * ```typescript
+ * export const Datasets = E2B.Volume("Datasets", { name: "datasets" });
+ * ```
+ *
+ * ### Mounting a Volume
+ * **Example:** Mount it into a declared sandbox
+ * ```typescript
+ * export const Builder = E2B.Sandbox("Builder", {
+ *   template: Agent,
+ *   mounts: [{ volume: Cache, path: "/cache" }],
+ * });
+ * ```
+ *
+ * **Example:** Mount it into the sandboxes a Worker creates
+ * ```typescript
+ * const cache = yield* E2B.MountVolume(Cache, { path: "/cache" });
+ * const sandboxes = yield* E2B.CreateSandbox(Agent);
+ * // in fetch:
+ * const sandbox = yield* sandboxes.create({ mounts: [cache] });
+ * ```
+ *
+ * ### Reading files from outside a sandbox
+ * **Example:** Read a report the sandbox wrote
+ * ```typescript
+ * const reports = yield* E2B.ReadVolume(Reports);
+ * const report = yield* reports.readFile("/report.json");
+ * ```
+ *
+ * ### Referencing a volume the stack doesn't manage
+ * `E2B.Volume.lookup` finds an existing volume by name. Nothing is created,
+ * adopted or deleted.
+ *
+ * **Example:** Look one up by name
+ * ```typescript
+ * const datasets = E2B.Volume.lookup({ name: "datasets" });
+ * const files = yield* E2B.ReadVolume(datasets);
+ * ```
+ *
+ * @resource
+ * @product Volume
+ */
+export const Volume = Resource<Volume>("E2B.Volume");
+
+const toAttrs = (volume: { volumeID: string; name: string }): VolumeAttributes => ({
+  volumeId: volume.volumeID,
+  name: volume.name,
+});
+
+/** The volume with this name, if any. E2B lists a team's volumes in one page. */
+const findByName = (name: string) =>
+  volumes.listVolumes({}).pipe(Effect.map((all) => all.find((volume) => volume.name === name)));
+
+const observe = (volumeId: string | undefined, name: string) =>
+  volumeId !== undefined
+    ? volumes.getVolume({ volumeID: volumeId }).pipe(
+        Effect.map((volume): volumes.Volume | undefined => volume),
+        Effect.catchTag("NotFound", () => findByName(name)),
+      )
+    : findByName(name);
+
+export const VolumeProvider = () =>
+  Provider.effect(
+    Volume,
+    Effect.gen(function* () {
+      return {
+        stables: ["volumeId", "name"],
+        diff: Effect.fn(function* ({ id, olds, news, output }) {
+          if (!isResolved(news)) return undefined;
+          // Only an explicit name can force a rename; a generated name is
+          // engine-owned and never compared against a fresh computation.
+          if (news.name === undefined && olds?.name === undefined) return undefined;
+          const name = output?.name ?? (yield* e2bName(id, olds?.name));
+          if (news.name !== name) return { action: "replace" } as const;
+          return undefined;
+        }),
+        lookup: Effect.fn(function* ({ name }) {
+          const volume = yield* observe(undefined, name);
+          return volume === undefined ? undefined : toAttrs(volume);
+        }),
+        read: Effect.fn(function* ({ id, olds, output }) {
+          const name = output?.name ?? (yield* e2bName(id, olds?.name));
+          const volume = yield* observe(output?.volumeId, name);
+          if (volume === undefined) return undefined;
+          const attrs = toAttrs(volume);
+          return output !== undefined || olds?.name === undefined ? attrs : Unowned(attrs);
+        }),
+        reconcile: Effect.fn(function* ({ id, news, output, session }) {
+          const name = output?.name ?? (yield* e2bName(id, news.name));
+          // Observe
+          const observed = yield* observe(output?.volumeId, name);
+          if (observed !== undefined) return toAttrs(observed);
+          // Ensure — a Conflict is a peer creating the same name: read it back.
+          yield* session.note(`Creating volume ${name}...`);
+          const created = yield* volumes.createVolume({ name }).pipe(
+            Effect.map((volume): volumes.Volume | undefined => volume),
+            Effect.catchTag("Conflict", () => findByName(name)),
+          );
+          if (created === undefined) {
+            return yield* new E2BUnexpectedResponse({
+              message: `E2B volume ${name} vanished after create`,
+            });
+          }
+          return toAttrs(created);
+        }),
+        delete: Effect.fn(function* ({ output }) {
+          yield* volumes
+            .deleteVolume({ volumeID: output.volumeId })
+            .pipe(Effect.catchTag("NotFound", () => Effect.void));
+        }),
+        list: Effect.fn(function* () {
+          const all = yield* volumes.listVolumes({});
+          return all.filter((volume) => isGeneratedName(volume.name)).map(toAttrs);
+        }),
+      };
+    }),
+  );

package/src/VolumeFiles.ts

@@ -0,0 +1,53 @@
+import type * as volumeContent from "@distilled.cloud/e2b/volume_content";
+import type { RuntimeContext } from "alchemy/RuntimeContext";
+import type * as Effect from "effect/Effect";
+import type { E2BError } from "./SandboxClient.ts";
+
+/** A file, directory or symlink in a volume. */
+export type VolumeEntry = volumeContent.VolumeEntryStat;
+
+/** Ownership and permissions for a written file or directory. */
+export interface VolumeEntryOptions {
+  readonly uid?: number;
+  readonly gid?: number;
+  /** POSIX mode, e.g. `0o644`. */
+  readonly mode?: number;
+}
+
+/** Read a volume's files without a sandbox. Paths are absolute inside the volume. */
+export interface ReadVolumeClient {
+  read(path: string): Effect.Effect<Uint8Array, E2BError, RuntimeContext>;
+  readText(path: string): Effect.Effect<string, E2BError, RuntimeContext>;
+  /** Directory entries, `depth` levels deep. */
+  list(
+    path: string,
+    options?: { readonly depth?: number },
+  ): Effect.Effect<ReadonlyArray<VolumeEntry>, E2BError, RuntimeContext>;
+  stat(path: string): Effect.Effect<VolumeEntry, E2BError, RuntimeContext>;
+  exists(path: string): Effect.Effect<boolean, E2BError, RuntimeContext>;
+}
+
+/** Write a volume's files without a sandbox. Paths are absolute inside the volume. */
+export interface WriteVolumeClient {
+  /** Writes a file, creating parent directories. */
+  write(
+    path: string,
+    data: string | Uint8Array,
+    options?: VolumeEntryOptions,
+  ): Effect.Effect<VolumeEntry, E2BError, RuntimeContext>;
+  /** Creates a directory and its parents. */
+  makeDir(
+    path: string,
+    options?: VolumeEntryOptions,
+  ): Effect.Effect<VolumeEntry, E2BError, RuntimeContext>;
+  /** Changes ownership or mode. */
+  chmod(
+    path: string,
+    options: VolumeEntryOptions,
+  ): Effect.Effect<VolumeEntry, E2BError, RuntimeContext>;
+  /** Removes a file or a directory tree. Removing a missing path succeeds. */
+  remove(path: string): Effect.Effect<void, E2BError, RuntimeContext>;
+}
+
+/** Read and write a volume's files without a sandbox. */
+export interface ReadWriteVolumeClient extends ReadVolumeClient, WriteVolumeClient {}

package/src/Webhook.ts

@@ -0,0 +1,215 @@
+import * as webhooks from "@distilled.cloud/e2b/webhooks";
+import { Unowned } from "alchemy/AdoptPolicy";
+import * as Provider from "alchemy/Provider";
+import { Resource } from "alchemy/Resource";
+import * as Effect from "effect/Effect";
+import * as Redacted from "effect/Redacted";
+import { E2BUnexpectedResponse } from "./Errors.ts";
+import { e2bName, isGeneratedName } from "./internal/Ownership.ts";
+import type { Providers } from "./Providers.ts";
+
+/** Sandbox lifecycle events E2B delivers to webhooks. */
+export type SandboxEventType =
+  | "sandbox.lifecycle.created"
+  | "sandbox.lifecycle.killed"
+  | "sandbox.lifecycle.updated"
+  | "sandbox.lifecycle.paused"
+  | "sandbox.lifecycle.resumed"
+  | "sandbox.lifecycle.checkpointed";
+
+export const ALL_SANDBOX_EVENTS: ReadonlyArray<SandboxEventType> = [
+  "sandbox.lifecycle.created",
+  "sandbox.lifecycle.killed",
+  "sandbox.lifecycle.updated",
+  "sandbox.lifecycle.paused",
+  "sandbox.lifecycle.resumed",
+  "sandbox.lifecycle.checkpointed",
+];
+
+export interface WebhookProps {
+  /**
+   * Webhook name. If omitted, a unique name is generated from the stack,
+   * stage and logical ID. Updated in place.
+   */
+  name?: string;
+  /** The URL E2B POSTs each event to. */
+  url: string;
+  /**
+   * The events to deliver.
+   * @default every sandbox lifecycle event
+   */
+  events?: SandboxEventType[];
+  /**
+   * Whether E2B delivers events.
+   * @default true
+   */
+  enabled?: boolean;
+  /**
+   * The secret E2B signs each delivery with. The `e2b-signature` header is
+   * the unpadded base64 SHA-256 of this secret followed by the raw body.
+   * At least 32 characters.
+   */
+  signatureSecret: Redacted.Redacted<string>;
+}
+
+export interface WebhookAttributes {
+  /** E2B's webhook id. */
+  webhookId: string;
+  name: string;
+  url: string;
+  events: string[];
+  enabled: boolean;
+}
+
+export interface Webhook extends Resource<
+  "E2B.Webhook",
+  WebhookProps,
+  WebhookAttributes,
+  never,
+  Providers,
+  { name: string }
+> {}
+
+/**
+ * An E2B webhook: E2B POSTs every sandbox lifecycle event (created, paused,
+ * resumed, checkpointed, updated, killed) in your team to a URL.
+ *
+ * Use `E2B.SandboxEvents` to point a webhook at a Worker or Function and
+ * handle the events there; it declares this resource for you and verifies
+ * each delivery's signature. Declare a `Webhook` directly for an endpoint
+ * Alchemy does not deploy.
+ *
+ * E2B webhooks carry no labels, so Alchemy recognises its webhooks by their
+ * generated name.
+ *
+ * ### Creating a Webhook
+ * **Example:** Deliver pause and kill events to an existing endpoint
+ * ```typescript
+ * export const Lifecycle = E2B.Webhook("Lifecycle", {
+ *   url: "https://hooks.example.com/e2b",
+ *   events: ["sandbox.lifecycle.paused", "sandbox.lifecycle.killed"],
+ *   signatureSecret: Config.Redacted("E2B_WEBHOOK_SECRET"),
+ * });
+ * ```
+ *
+ * ### Referencing a webhook the stack doesn't manage
+ * `E2B.Webhook.lookup` finds an existing webhook by name. Nothing is created,
+ * adopted or deleted.
+ *
+ * **Example:** Look one up by name
+ * ```typescript
+ * const audit = E2B.Webhook.lookup({ name: "audit" });
+ * const deliveries = yield* E2B.ReadWebhook(audit);
+ * ```
+ *
+ * @resource
+ * @product Webhook
+ */
+export const Webhook = Resource<Webhook>("E2B.Webhook");
+
+const toAttrs = (
+  webhook: webhooks.WebhookDetail | webhooks.WebhookCreation,
+): WebhookAttributes => ({
+  webhookId: webhook.id,
+  name: webhook.name,
+  url: webhook.url,
+  events: [...webhook.events],
+  enabled: webhook.enabled,
+});
+
+const findByName = (name: string) =>
+  webhooks.listWebhooks({}).pipe(Effect.map((all) => all.find((hook) => hook.name === name)));
+
+const observe = (webhookId: string | undefined, name: string) =>
+  webhookId !== undefined
+    ? webhooks.getWebhook({ webhookID: webhookId }).pipe(
+        Effect.map((hook): webhooks.WebhookDetail | undefined => hook),
+        Effect.catchTag("NotFound", () => findByName(name)),
+      )
+    : findByName(name);
+
+const sameEvents = (a: ReadonlyArray<string>, b: ReadonlyArray<string>) =>
+  a.length === b.length && [...a].sort().join() === [...b].sort().join();
+
+export const WebhookProvider = () =>
+  Provider.effect(
+    Webhook,
+    Effect.gen(function* () {
+      return {
+        stables: ["webhookId"],
+        lookup: Effect.fn(function* ({ name }) {
+          const hook = yield* observe(undefined, name);
+          return hook === undefined ? undefined : toAttrs(hook);
+        }),
+        read: Effect.fn(function* ({ id, olds, output }) {
+          const name = output?.name ?? (yield* e2bName(id, olds?.name));
+          const hook = yield* observe(output?.webhookId, name);
+          if (hook === undefined) return undefined;
+          const attrs = toAttrs(hook);
+          return output !== undefined || olds?.name === undefined ? attrs : Unowned(attrs);
+        }),
+        reconcile: Effect.fn(function* ({ id, news, olds, output, session }) {
+          // Webhooks are renamed in place, so the desired name wins over the
+          // stored one; the stored id finds the webhook either way.
+          const name = news.name ?? output?.name ?? (yield* e2bName(id, undefined));
+          const events = [...(news.events ?? ALL_SANDBOX_EVENTS)];
+          const enabled = news.enabled ?? true;
+
+          // Observe
+          const observed = yield* observe(output?.webhookId, output?.name ?? name);
+
+          // Ensure
+          if (observed === undefined) {
+            yield* session.note(`Creating webhook ${name}...`);
+            const created = yield* webhooks.createWebhook({
+              name,
+              url: news.url,
+              events,
+              enabled,
+              signatureSecret: news.signatureSecret,
+            });
+            return toAttrs(created);
+          }
+
+          // Sync — the signing secret is write-only, so `olds` is the only
+          // signal that the stored one already matches.
+          const secretChanged =
+            olds === undefined ||
+            Redacted.value(olds.signatureSecret) !== Redacted.value(news.signatureSecret);
+          if (
+            observed.name !== name ||
+            observed.url !== news.url ||
+            observed.enabled !== enabled ||
+            !sameEvents(observed.events, events) ||
+            secretChanged
+          ) {
+            yield* webhooks.updateWebhook({
+              webhookID: observed.id,
+              name,
+              url: news.url,
+              events,
+              enabled,
+              ...(secretChanged ? { signatureSecret: news.signatureSecret } : {}),
+            });
+            const updated = yield* observe(observed.id, name);
+            if (updated === undefined) {
+              return yield* new E2BUnexpectedResponse({
+                message: `E2B webhook ${name} vanished after update`,
+              });
+            }
+            return toAttrs(updated);
+          }
+          return toAttrs(observed);
+        }),
+        delete: Effect.fn(function* ({ output }) {
+          yield* webhooks
+            .deleteWebhook({ webhookID: output.webhookId })
+            .pipe(Effect.catchTag("NotFound", () => Effect.void));
+        }),
+        list: Effect.fn(function* () {
+          const all = yield* webhooks.listWebhooks({});
+          return all.filter((hook) => isGeneratedName(hook.name)).map(toAttrs);
+        }),
+      };
+    }),
+  );

package/src/WriteSecret.ts

@@ -0,0 +1,39 @@
+import * as Binding from "alchemy/Binding";
+import type { RuntimeContext } from "alchemy/RuntimeContext";
+import type * as Effect from "effect/Effect";
+import type * as Redacted from "effect/Redacted";
+import type { E2BError } from "./SandboxClient.ts";
+import type { Secret, SecretAttributes } from "./Secret.ts";
+
+/** Rotate one declared secret. */
+export interface WriteSecretClient {
+  /** Stores a new version of the secret. Sandboxes resolve it on their next request. */
+  put(value: Redacted.Redacted<string>): Effect.Effect<SecretAttributes, E2BError, RuntimeContext>;
+}
+
+/**
+ * Rotate a declared {@link Secret} at runtime: a scheduled job refreshing a
+ * short-lived token, or a webhook storing a reissued credential. Sandboxes
+ * resolve the new version on their next request.
+ *
+ * A later deploy stores the declared `value` again only when that value
+ * changes.
+ *
+ * ### Rotating a secret
+ * **Example:** Store a refreshed token
+ * ```typescript
+ * const token = yield* E2B.WriteSecret(GitHubToken);
+ * // in a scheduled handler:
+ * yield* token.put(Redacted.make(fresh));
+ * ```
+ *
+ * @binding
+ * @product Secret
+ */
+export interface WriteSecret extends Binding.Service<
+  WriteSecret,
+  "E2B.WriteSecret",
+  (secret: Secret) => Effect.Effect<WriteSecretClient>
+> {}
+
+export const WriteSecret = Binding.Service<WriteSecret>("E2B.WriteSecret");

package/src/WriteSecretHttp.ts

@@ -0,0 +1,43 @@
+import * as secrets from "@distilled.cloud/e2b/secrets";
+import type * as Output from "alchemy/Output";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { bindE2B } from "./E2BBindings.ts";
+import { type Secret, toSecretAttributes } from "./Secret.ts";
+import { WriteSecret, type WriteSecretClient } from "./WriteSecret.ts";
+
+/**
+ * HTTP implementation of {@link WriteSecret}. Works on any host.
+ *
+ * ### Provide the layer
+ * **Example:** On a Worker
+ * ```typescript
+ * Effect.gen(function* () {
+ *   const token = yield* E2B.WriteSecret(GitHubToken);
+ *   // ...
+ * }).pipe(Effect.provide(E2B.WriteSecretHttp))
+ * ```
+ *
+ * @layer
+ * @product Secret
+ * @provides E2B.WriteSecret
+ */
+export const WriteSecretHttp = Layer.succeed(
+  WriteSecret,
+  Effect.fn("E2B.WriteSecret")(function* (secret: Secret) {
+    const auth = yield* bindE2B;
+    const secretId = yield* (secret.secretId as Output.Output<string, never>).asEffect();
+    const client: WriteSecretClient = {
+      put: Effect.fn("E2B.WriteSecret.put")(function* (value) {
+        const id = yield* secretId;
+        // Keep the secret's metadata (ownership stamp included) as it is.
+        const current = yield* auth.authorize(secrets.getSecret({ secretID: id }));
+        const stored = yield* auth.authorize(
+          secrets.updateSecret({ secretID: id, value, metadata: current.metadata }),
+        );
+        return toSecretAttributes(stored);
+      }),
+    };
+    return client;
+  }),
+);

package/src/WriteVolume.ts

@@ -0,0 +1,29 @@
+import * as Binding from "alchemy/Binding";
+import type * as Effect from "effect/Effect";
+import type { Volume } from "./Volume.ts";
+import type { WriteVolumeClient } from "./VolumeFiles.ts";
+
+/**
+ * Write a {@link Volume}'s files from outside any sandbox: seed inputs before sandboxes start, or clean up after them.
+ *
+ * The client talks to E2B's volume content API with the volume's own token,
+ * looked up once through the host's API key.
+ *
+ * ### Using the client
+ * **Example:** In a Worker
+ * ```typescript
+ * const inputs = yield* E2B.WriteVolume(Inputs);
+ * // in fetch:
+ * yield* inputs.write("/task.json", JSON.stringify(task));
+ * ```
+ *
+ * @binding
+ * @product Volume
+ */
+export interface WriteVolume extends Binding.Service<
+  WriteVolume,
+  "E2B.WriteVolume",
+  (volume: Volume) => Effect.Effect<WriteVolumeClient>
+> {}
+
+export const WriteVolume = Binding.Service<WriteVolume>("E2B.WriteVolume");

package/src/WriteVolumeHttp.ts

@@ -0,0 +1,32 @@
+import type * as Output from "alchemy/Output";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { bindE2B } from "./E2BBindings.ts";
+import { makeVolumeFiles } from "./internal/VolumeHttp.ts";
+import type { Volume } from "./Volume.ts";
+import { WriteVolume } from "./WriteVolume.ts";
+
+/**
+ * HTTP implementation of {@link WriteVolume}. Works on any host.
+ *
+ * ### Provide the layer
+ * **Example:** On a Worker
+ * ```typescript
+ * Effect.gen(function* () {
+ *   const inputs = yield* E2B.WriteVolume(Inputs);
+ *   // ...
+ * }).pipe(Effect.provide(E2B.WriteVolumeHttp))
+ * ```
+ *
+ * @layer
+ * @product Volume
+ * @provides E2B.WriteVolume
+ */
+export const WriteVolumeHttp = Layer.succeed(
+  WriteVolume,
+  Effect.fn("E2B.WriteVolume")(function* (volume: Volume) {
+    const auth = yield* bindE2B;
+    const volumeId = yield* (volume.volumeId as Output.Output<string, never>).asEffect();
+    return makeVolumeFiles(auth, volumeId);
+  }),
+);

package/src/globals.d.ts

@@ -0,0 +1,2 @@
+// `globalThis.__ALCHEMY_RUNTIME__`, declared by alchemy's Phase module.
+import type {} from "alchemy/Phase";

package/src/index.ts

@@ -0,0 +1,42 @@
+export * from "./ApiKey.ts";
+export * from "./AuthProvider.ts";
+export * from "./ConnectSandbox.ts";
+export * from "./ConnectSandboxHttp.ts";
+export * from "./CreateSandbox.ts";
+export * from "./CreateSandboxHttp.ts";
+export * from "./CreateSecret.ts";
+export * from "./CreateSecretHttp.ts";
+export * from "./CreateSnapshot.ts";
+export * from "./CreateSnapshotHttp.ts";
+export * from "./CreateTemplate.ts";
+export * from "./CreateTemplateHttp.ts";
+export * from "./CreateVolume.ts";
+export * from "./CreateVolumeHttp.ts";
+export * from "./Credentials.ts";
+export * from "./Errors.ts";
+export * from "./InferEnv.ts";
+export * from "./MountVolume.ts";
+export * from "./MountVolumeLive.ts";
+export * from "./Providers.ts";
+export * from "./ReadTeam.ts";
+export * from "./ReadTeamHttp.ts";
+export * from "./ReadVolume.ts";
+export * from "./ReadWebhook.ts";
+export * from "./ReadWebhookHttp.ts";
+export * from "./ReadVolumeHttp.ts";
+export * from "./ReadWriteVolume.ts";
+export * from "./ReadWriteVolumeHttp.ts";
+export * from "./Sandbox.ts";
+export * from "./SandboxClient.ts";
+export * from "./SandboxEvents.ts";
+export * from "./SandboxEventsLive.ts";
+export * from "./Secret.ts";
+export * from "./Snapshot.ts";
+export * from "./Template.ts";
+export * from "./Volume.ts";
+export * from "./VolumeFiles.ts";
+export * from "./Webhook.ts";
+export * from "./WriteSecret.ts";
+export * from "./WriteSecretHttp.ts";
+export * from "./WriteVolume.ts";
+export * from "./WriteVolumeHttp.ts";