@krak-stack/registry 0.1.0

package/dist/services/embedding.d.ts

@@ -0,0 +1,2 @@
+import { Config, Layer } from "effect";
+export declare const EmbeddingLayer: Layer.Layer<import("effect/unstable/ai/EmbeddingModel").EmbeddingModel, Config.ConfigError, never>;

package/dist/services/embedding.js

@@ -0,0 +1,23 @@
+// ../../src/services/embedding.ts
+import { OpenAiClient, OpenAiEmbeddingModel } from "@effect/ai-openai-compat";
+import { Config, Effect, Layer, Redacted } from "effect";
+import { FetchHttpClient } from "effect/unstable/http";
+var EmbeddingLayer = Layer.unwrap(Effect.gen(function* () {
+  const apiUrl = yield* Config.string("EMBEDDINGS_URL");
+  const embeddingModel = yield* Config.string("EMBEDDINGS_MODEL");
+  const embeddingDimensions = yield* Config.number("EMBEDDINGS_DIMENSIONS");
+  const embeddingClientLayer = OpenAiClient.layer({
+    apiKey: Redacted.make("embedding"),
+    apiUrl
+  });
+  return OpenAiEmbeddingModel.layer({
+    model: embeddingModel,
+    config: {
+      dimensions: embeddingDimensions,
+      encoding_format: "float"
+    }
+  }).pipe(Layer.provide(embeddingClientLayer), Layer.provide(FetchHttpClient.layer));
+}));
+export {
+  EmbeddingLayer
+};

package/dist/services/notification/channels/index.d.ts

@@ -0,0 +1,22 @@
+import { Context, Effect, Layer } from "effect";
+import { NotificationSendError } from "../schema.js";
+export interface NotificationChannels {
+}
+export type NotificationMessage = keyof NotificationChannels extends never ? Record<string, unknown> : Partial<{
+    readonly [Key in keyof NotificationChannels]: NotificationChannels[Key];
+}>;
+export interface NotificationChannelShape<Key extends string = string, Payload = unknown> {
+    readonly key: Key;
+    readonly send: (payload: unknown, message: NotificationMessage) => Effect.Effect<void, NotificationSendError>;
+    readonly payload?: Payload;
+}
+export interface NotificationChannelRegistryShape {
+    readonly channels: ReadonlyArray<NotificationChannelShape>;
+}
+declare const NotificationChannelRegistry_base: Context.ServiceClass<NotificationChannelRegistry, "NotificationChannelRegistry", NotificationChannelRegistryShape>;
+export declare class NotificationChannelRegistry extends NotificationChannelRegistry_base {
+    static readonly make: (...channels: ReadonlyArray<NotificationChannelShape>) => NotificationChannelRegistryShape;
+    static readonly layer: (channels: ReadonlyArray<NotificationChannelShape>) => Layer.Layer<NotificationChannelRegistry, never, never>;
+    static readonly emptyLayer: Layer.Layer<NotificationChannelRegistry, never, never>;
+}
+export {};

package/dist/services/notification/channels/index.js

@@ -0,0 +1,11 @@
+// ../../src/services/notification/channels/index.ts
+import { Context, Layer } from "effect";
+
+class NotificationChannelRegistry extends Context.Service()("NotificationChannelRegistry") {
+  static make = (...channels) => ({ channels });
+  static layer = (channels) => Layer.succeed(this, this.make(...channels));
+  static emptyLayer = Layer.succeed(this, this.make());
+}
+export {
+  NotificationChannelRegistry
+};

package/dist/services/notification/channels/ses/index.d.ts

@@ -0,0 +1,51 @@
+import { Config, Context, Effect, Layer, Redacted } from "effect";
+import { type NotificationChannelShape } from "..";
+import { SesEmailNotification } from "./schema.js";
+declare module ".." {
+    interface NotificationChannels {
+        readonly email: SesEmailNotification;
+    }
+}
+interface SesAccessKey {
+    readonly id: Redacted.Redacted<string>;
+    readonly secret: Redacted.Redacted<string>;
+}
+interface SesIdentity {
+    readonly region: string;
+    readonly from: string | undefined;
+}
+interface SesNotificationConfigShape {
+    readonly identity: SesIdentity;
+    readonly accessKey: SesAccessKey;
+}
+declare const SesNotificationConfig_base: Context.ServiceClass<SesNotificationConfig, "SesNotificationConfig", SesNotificationConfigShape> & {
+    readonly make: Effect.Effect<SesNotificationConfigShape, Config.ConfigError, never>;
+};
+export declare class SesNotificationConfig extends SesNotificationConfig_base {
+    static readonly layer: Layer.Layer<SesNotificationConfig, Config.ConfigError, never>;
+}
+declare const SesNotificationChannel_base: Context.ServiceClass<SesNotificationChannel, "SesNotificationChannel", NotificationChannelShape<"email", {
+    readonly from?: string | undefined;
+    readonly to: string | readonly [string, ...string[]];
+    readonly cc?: readonly string[] | undefined;
+    readonly bcc?: readonly string[] | undefined;
+    readonly replyTo?: readonly string[] | undefined;
+    readonly subject: string;
+    readonly text?: string | undefined;
+    readonly html?: string | undefined;
+}>> & {
+    readonly make: Effect.Effect<NotificationChannelShape<"email", {
+        readonly from?: string | undefined;
+        readonly to: string | readonly [string, ...string[]];
+        readonly cc?: readonly string[] | undefined;
+        readonly bcc?: readonly string[] | undefined;
+        readonly replyTo?: readonly string[] | undefined;
+        readonly subject: string;
+        readonly text?: string | undefined;
+        readonly html?: string | undefined;
+    }>, never, SesNotificationConfig>;
+};
+export declare class SesNotificationChannel extends SesNotificationChannel_base {
+    static readonly layer: Layer.Layer<SesNotificationChannel, Config.ConfigError, never>;
+}
+export {};

package/dist/services/notification/channels/ses/index.js

@@ -0,0 +1,145 @@
+// ../../src/services/notification/channels/ses/index.ts
+import {
+  SESv2Client,
+  SendEmailCommand
+} from "@aws-sdk/client-sesv2";
+import { Config, Context, Effect, Layer, Redacted, Schema as Schema3 } from "effect";
+
+// ../../src/services/notification/schema.ts
+import { Schema } from "effect";
+var NotificationMessageSchema = Schema.Record(Schema.String, Schema.Unknown).annotate({
+  identifier: "NotificationMessage",
+  title: "Notification message",
+  description: "A dynamic notification envelope keyed by channel capability. Installed channels send the payload matching their key.",
+  examples: [
+    {
+      email: {
+        to: "user@example.com",
+        subject: "Welcome",
+        text: "Thanks for signing up."
+      },
+      discord: {
+        content: "A user signed up."
+      }
+    }
+  ]
+});
+
+class NotificationSendError extends Schema.TaggedErrorClass()("NotificationSendError", {
+  message: Schema.String,
+  channel: Schema.optional(Schema.String),
+  error: Schema.optional(Schema.Defect())
+}) {
+}
+
+// ../../src/services/notification/channels/ses/schema.ts
+import { Schema as Schema2 } from "effect";
+var SesEmailAddress = Schema2.NonEmptyString.annotate({
+  identifier: "SesEmailAddress",
+  title: "SES email address",
+  description: "An email address used by the SES notification channel.",
+  examples: ["user@example.com"]
+});
+var SesEmailNotification = Schema2.Struct({
+  from: Schema2.optional(SesEmailAddress),
+  to: Schema2.Union([SesEmailAddress, Schema2.NonEmptyArray(SesEmailAddress)]),
+  cc: Schema2.optional(Schema2.Array(SesEmailAddress)),
+  bcc: Schema2.optional(Schema2.Array(SesEmailAddress)),
+  replyTo: Schema2.optional(Schema2.Array(SesEmailAddress)),
+  subject: Schema2.NonEmptyString,
+  text: Schema2.optional(Schema2.NonEmptyString),
+  html: Schema2.optional(Schema2.NonEmptyString)
+}).annotate({
+  identifier: "SesEmailNotification",
+  title: "SES email notification",
+  description: "Email notification payload handled by the SES notification channel. At least one of text or html must be provided when sending.",
+  examples: [
+    {
+      from: "KrakStack <no-reply@example.com>",
+      to: "user@example.com",
+      subject: "Welcome",
+      text: "Thanks for signing up.",
+      html: "<p>Thanks for signing up.</p>"
+    }
+  ]
+});
+
+// ../../src/services/notification/channels/ses/index.ts
+class SesNotificationConfig extends Context.Service()("SesNotificationConfig", {
+  make: Effect.gen(function* () {
+    const region = yield* Config.string("SES_REGION");
+    const id = yield* Config.redacted("SES_ACCESS_KEY_ID");
+    const secret = yield* Config.redacted("SES_SECRET_ACCESS_KEY");
+    const from = yield* Config.string("NOTIFICATION_EMAIL_FROM").pipe(Config.orElse(() => Config.succeed("")));
+    return {
+      identity: { region, from: from || undefined },
+      accessKey: { id, secret }
+    };
+  })
+}) {
+  static layer = Layer.effect(this, this.make);
+}
+
+class SesNotificationChannel extends Context.Service()("SesNotificationChannel", {
+  make: Effect.gen(function* () {
+    const { accessKey, identity } = yield* SesNotificationConfig;
+    const client = new SESv2Client({
+      region: identity.region,
+      credentials: {
+        accessKeyId: Redacted.value(accessKey.id),
+        secretAccessKey: Redacted.value(accessKey.secret)
+      }
+    });
+    const send = Effect.fn("SesNotificationChannel.send")(function* (payload, _message) {
+      const email = yield* decodeEmail(payload);
+      const from = email.from ?? identity.from;
+      if (!from) {
+        return yield* notificationSendError("SES email notification requires from or NOTIFICATION_EMAIL_FROM");
+      }
+      const body = yield* requireBody(email);
+      const emailMessage = {
+        Subject: { Data: email.subject, Charset: "UTF-8" },
+        Body: body
+      };
+      yield* Effect.tryPromise({
+        try: () => client.send(new SendEmailCommand({
+          FromEmailAddress: from,
+          Destination: buildDestination(email),
+          Content: { Simple: emailMessage },
+          ...email.replyTo?.length ? { ReplyToAddresses: Array.from(email.replyTo) } : {}
+        })),
+        catch: (error) => notificationSendError("Failed to send SES email", error)
+      });
+    });
+    return { key: "email", send };
+  })
+}) {
+  static layer = Layer.effect(this, this.make).pipe(Layer.provide(SesNotificationConfig.layer));
+}
+var notificationSendError = (message, error) => new NotificationSendError({
+  channel: "email",
+  message,
+  ...error === undefined ? {} : { error }
+});
+var decodeEmail = (payload) => Schema3.decodeUnknownEffect(SesEmailNotification)(payload).pipe(Effect.mapError((error) => notificationSendError("Invalid SES email notification payload", error)));
+var requireBody = (email) => {
+  const { html, text } = email;
+  if (!html && !text) {
+    return Effect.fail(notificationSendError("SES email notification requires text or html"));
+  }
+  const body = {
+    ...text ? { Text: { Data: text, Charset: "UTF-8" } } : {},
+    ...html ? { Html: { Data: html, Charset: "UTF-8" } } : {}
+  };
+  return Effect.succeed(body);
+};
+var recipients = (to) => Array.isArray(to) ? Array.from(to) : [to];
+var buildDestination = (email) => ({
+  ToAddresses: recipients(email.to),
+  ...email.cc?.length ? { CcAddresses: Array.from(email.cc) } : {},
+  ...email.bcc?.length ? { BccAddresses: Array.from(email.bcc) } : {}
+});
+export {
+  SesNotificationConfig,
+  SesNotificationChannel
+};

package/dist/services/notification/channels/ses/schema.d.ts

@@ -0,0 +1,13 @@
+import { Schema } from "effect";
+export declare const SesEmailAddress: Schema.NonEmptyString;
+export declare const SesEmailNotification: Schema.Struct<{
+    readonly from: Schema.optional<Schema.NonEmptyString>;
+    readonly to: Schema.Union<readonly [Schema.NonEmptyString, Schema.NonEmptyArray<Schema.NonEmptyString>]>;
+    readonly cc: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+    readonly bcc: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+    readonly replyTo: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+    readonly subject: Schema.NonEmptyString;
+    readonly text: Schema.optional<Schema.NonEmptyString>;
+    readonly html: Schema.optional<Schema.NonEmptyString>;
+}>;
+export type SesEmailNotification = typeof SesEmailNotification.Type;

package/dist/services/notification/channels/ses/schema.js

@@ -0,0 +1,35 @@
+// ../../src/services/notification/channels/ses/schema.ts
+import { Schema } from "effect";
+var SesEmailAddress = Schema.NonEmptyString.annotate({
+  identifier: "SesEmailAddress",
+  title: "SES email address",
+  description: "An email address used by the SES notification channel.",
+  examples: ["user@example.com"]
+});
+var SesEmailNotification = Schema.Struct({
+  from: Schema.optional(SesEmailAddress),
+  to: Schema.Union([SesEmailAddress, Schema.NonEmptyArray(SesEmailAddress)]),
+  cc: Schema.optional(Schema.Array(SesEmailAddress)),
+  bcc: Schema.optional(Schema.Array(SesEmailAddress)),
+  replyTo: Schema.optional(Schema.Array(SesEmailAddress)),
+  subject: Schema.NonEmptyString,
+  text: Schema.optional(Schema.NonEmptyString),
+  html: Schema.optional(Schema.NonEmptyString)
+}).annotate({
+  identifier: "SesEmailNotification",
+  title: "SES email notification",
+  description: "Email notification payload handled by the SES notification channel. At least one of text or html must be provided when sending.",
+  examples: [
+    {
+      from: "KrakStack <no-reply@example.com>",
+      to: "user@example.com",
+      subject: "Welcome",
+      text: "Thanks for signing up.",
+      html: "<p>Thanks for signing up.</p>"
+    }
+  ]
+});
+export {
+  SesEmailNotification,
+  SesEmailAddress
+};

package/dist/services/notification/index.d.ts

@@ -0,0 +1,15 @@
+import { Context, Effect, Layer } from "effect";
+import { NotificationChannelRegistry, type NotificationMessage, type NotificationChannelShape } from "./channels/index.js";
+import { NotificationSendError } from "./schema.js";
+export interface NotificationServiceShape {
+    readonly send: (message: NotificationMessage) => Effect.Effect<void, NotificationSendError>;
+}
+declare const NotificationService_base: Context.ServiceClass<NotificationService, "NotificationService", NotificationServiceShape> & {
+    readonly make: Effect.Effect<NotificationServiceShape, never, NotificationChannelRegistry>;
+};
+export declare class NotificationService extends NotificationService_base {
+    static readonly layer: Layer.Layer<NotificationService, never, NotificationChannelRegistry>;
+    static readonly makeLayer: (channels: ReadonlyArray<NotificationChannelShape>) => Layer.Layer<NotificationService, never, never>;
+    static readonly noopLayer: Layer.Layer<NotificationService, never, never>;
+}
+export {};

package/dist/services/notification/index.js

@@ -0,0 +1,67 @@
+// ../../src/services/notification/index.ts
+import { Context as Context2, Effect as Effect2, Layer as Layer2 } from "effect";
+
+// ../../src/services/notification/channels/index.ts
+import { Context, Layer } from "effect";
+
+class NotificationChannelRegistry extends Context.Service()("NotificationChannelRegistry") {
+  static make = (...channels) => ({ channels });
+  static layer = (channels) => Layer.succeed(this, this.make(...channels));
+  static emptyLayer = Layer.succeed(this, this.make());
+}
+
+// ../../src/services/notification/schema.ts
+import { Schema } from "effect";
+var NotificationMessageSchema = Schema.Record(Schema.String, Schema.Unknown).annotate({
+  identifier: "NotificationMessage",
+  title: "Notification message",
+  description: "A dynamic notification envelope keyed by channel capability. Installed channels send the payload matching their key.",
+  examples: [
+    {
+      email: {
+        to: "user@example.com",
+        subject: "Welcome",
+        text: "Thanks for signing up."
+      },
+      discord: {
+        content: "A user signed up."
+      }
+    }
+  ]
+});
+
+class NotificationSendError extends Schema.TaggedErrorClass()("NotificationSendError", {
+  message: Schema.String,
+  channel: Schema.optional(Schema.String),
+  error: Schema.optional(Schema.Defect())
+}) {
+}
+
+// ../../src/services/notification/index.ts
+class NotificationService extends Context2.Service()("NotificationService", {
+  make: Effect2.gen(function* () {
+    const registry = yield* NotificationChannelRegistry;
+    const send = Effect2.fn("NotificationService.send")((message) => Effect2.gen(function* () {
+      for (const [key, payload] of Object.entries(message)) {
+        const channels = registry.channels.filter((item) => item.key === key);
+        if (channels.length === 0) {
+          return yield* new NotificationSendError({
+            channel: key,
+            message: `No notification channel installed for ${key}`
+          });
+        }
+        yield* Effect2.forEach(channels, (channel) => channel.send(payload, message));
+      }
+    }));
+    return { send };
+  })
+}) {
+  static layer = Layer2.effect(this, this.make);
+  static makeLayer = (channels) => this.layer.pipe(Layer2.provide(NotificationChannelRegistry.layer(channels)));
+  static noopLayer = Layer2.succeed(this, {
+    send: () => Effect2.void
+  });
+}
+export {
+  NotificationService
+};

package/dist/services/notification/schema.d.ts

@@ -0,0 +1,10 @@
+import { Schema } from "effect";
+export declare const NotificationMessageSchema: Schema.$Record<Schema.String, Schema.Unknown>;
+declare const NotificationSendError_base: Schema.Class<NotificationSendError, Schema.TaggedStruct<"NotificationSendError", {
+    readonly message: Schema.String;
+    readonly channel: Schema.optional<Schema.String>;
+    readonly error: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class NotificationSendError extends NotificationSendError_base {
+}
+export type { NotificationMessage } from "./channels/index.js";

package/dist/services/notification/schema.js

@@ -0,0 +1,30 @@
+// ../../src/services/notification/schema.ts
+import { Schema } from "effect";
+var NotificationMessageSchema = Schema.Record(Schema.String, Schema.Unknown).annotate({
+  identifier: "NotificationMessage",
+  title: "Notification message",
+  description: "A dynamic notification envelope keyed by channel capability. Installed channels send the payload matching their key.",
+  examples: [
+    {
+      email: {
+        to: "user@example.com",
+        subject: "Welcome",
+        text: "Thanks for signing up."
+      },
+      discord: {
+        content: "A user signed up."
+      }
+    }
+  ]
+});
+
+class NotificationSendError extends Schema.TaggedErrorClass()("NotificationSendError", {
+  message: Schema.String,
+  channel: Schema.optional(Schema.String),
+  error: Schema.optional(Schema.Defect())
+}) {
+}
+export {
+  NotificationSendError,
+  NotificationMessageSchema
+};

package/dist/services/opentelemetry.d.ts

@@ -0,0 +1,8 @@
+import { Config, Effect, Layer, Context } from "effect";
+declare const OpenTelemetry_base: Context.ServiceClass<OpenTelemetry, "OpenTelemetry", void> & {
+    readonly make: Effect.Effect<void, never, never>;
+};
+export declare class OpenTelemetry extends OpenTelemetry_base {
+    static readonly layer: Layer.Layer<OpenTelemetry, Config.ConfigError, never>;
+}
+export {};

package/dist/services/opentelemetry.js

@@ -0,0 +1,23 @@
+// ../../src/services/opentelemetry.ts
+import { FetchHttpClient } from "effect/unstable/http";
+import { Otlp, OtlpSerialization } from "effect/unstable/observability";
+import { Config, Effect, Layer, Context } from "effect";
+var OtelLive = Layer.unwrap(Effect.gen(function* () {
+  const serviceName = yield* Config.string("OTEL_SERVICE_NAME").pipe(Config.withDefault("app"));
+  const otlpEndpoint = yield* Config.string("OTEL_EXPORTER_OTLP_ENDPOINT").pipe(Config.withDefault("http://localhost:4318"));
+  return Otlp.layer({
+    baseUrl: otlpEndpoint,
+    resource: {
+      serviceName
+    }
+  }).pipe(Layer.provide(OtlpSerialization.layerJson), Layer.provide(FetchHttpClient.layer));
+}));
+
+class OpenTelemetry extends Context.Service()("OpenTelemetry", {
+  make: Effect.log("OpenTelemetry initialized")
+}) {
+  static layer = Layer.effect(this, this.make).pipe(Layer.provideMerge(OtelLive));
+}
+export {
+  OpenTelemetry
+};

package/dist/services/s3/index.d.ts

@@ -0,0 +1,62 @@
+import { Config, Context, Effect, Layer } from "effect";
+import { S3ServiceError } from "./schema.js";
+declare const S3ServiceConfig_base: Context.ServiceClass<S3ServiceConfig, "S3ServiceConfig", {
+    options: {
+        accessKeyId: string;
+        secretAccessKey: string;
+        bucket: string;
+        region?: string | undefined;
+        endpoint?: string | undefined;
+        sessionToken?: string | undefined;
+    };
+}> & {
+    readonly make: Effect.Effect<{
+        options: {
+            accessKeyId: string;
+            secretAccessKey: string;
+            bucket: string;
+            region?: string | undefined;
+            endpoint?: string | undefined;
+            sessionToken?: string | undefined;
+        };
+    }, Config.ConfigError, never>;
+};
+export declare class S3ServiceConfig extends S3ServiceConfig_base {
+    static readonly layer: Layer.Layer<S3ServiceConfig, Config.ConfigError, never>;
+}
+declare const S3Service_base: Context.ServiceClass<S3Service, "S3Service", {
+    file: (path: string, options?: Bun.S3Options | undefined) => Effect.Effect<Bun.S3File, S3ServiceError, never>;
+    write: (path: string, data: string | Bun.Archive | ArrayBuffer | Blob | Bun.BunFile | File | Request | Response | Bun.S3File | SharedArrayBuffer | Bun.ArrayBufferView<ArrayBufferLike>, options?: Bun.S3Options | undefined) => Effect.Effect<number, S3ServiceError, never>;
+    text: (path: string) => Effect.Effect<string, S3ServiceError, never>;
+    json: (path: string) => Effect.Effect<any, S3ServiceError, never>;
+    bytes: (path: string) => Effect.Effect<Uint8Array<ArrayBuffer>, S3ServiceError, never>;
+    arrayBuffer: (path: string) => Effect.Effect<ArrayBuffer, S3ServiceError, never>;
+    stream: (path: string) => Effect.Effect<ReadableStream<Uint8Array<ArrayBuffer>>, S3ServiceError, never>;
+    exists: (path: string) => Effect.Effect<boolean, S3ServiceError, never>;
+    stat: (path: string) => Effect.Effect<Bun.S3Stats, S3ServiceError, never>;
+    size: (path: string) => Effect.Effect<number, S3ServiceError, never>;
+    delete: (path: string) => Effect.Effect<void, S3ServiceError, never>;
+    presign: (path: string, options?: Bun.S3FilePresignOptions | undefined) => Effect.Effect<string, S3ServiceError, never>;
+    list: (options?: Bun.S3ListObjectsOptions | null | undefined) => Effect.Effect<Bun.S3ListObjectsResponse, S3ServiceError, never>;
+}> & {
+    readonly make: Effect.Effect<{
+        file: (path: string, options?: Bun.S3Options | undefined) => Effect.Effect<Bun.S3File, S3ServiceError, never>;
+        write: (path: string, data: string | Bun.Archive | ArrayBuffer | Blob | Bun.BunFile | File | Request | Response | Bun.S3File | SharedArrayBuffer | Bun.ArrayBufferView<ArrayBufferLike>, options?: Bun.S3Options | undefined) => Effect.Effect<number, S3ServiceError, never>;
+        text: (path: string) => Effect.Effect<string, S3ServiceError, never>;
+        json: (path: string) => Effect.Effect<any, S3ServiceError, never>;
+        bytes: (path: string) => Effect.Effect<Uint8Array<ArrayBuffer>, S3ServiceError, never>;
+        arrayBuffer: (path: string) => Effect.Effect<ArrayBuffer, S3ServiceError, never>;
+        stream: (path: string) => Effect.Effect<ReadableStream<Uint8Array<ArrayBuffer>>, S3ServiceError, never>;
+        exists: (path: string) => Effect.Effect<boolean, S3ServiceError, never>;
+        stat: (path: string) => Effect.Effect<Bun.S3Stats, S3ServiceError, never>;
+        size: (path: string) => Effect.Effect<number, S3ServiceError, never>;
+        delete: (path: string) => Effect.Effect<void, S3ServiceError, never>;
+        presign: (path: string, options?: Bun.S3FilePresignOptions | undefined) => Effect.Effect<string, S3ServiceError, never>;
+        list: (options?: Bun.S3ListObjectsOptions | null | undefined) => Effect.Effect<Bun.S3ListObjectsResponse, S3ServiceError, never>;
+    }, never, S3ServiceConfig>;
+};
+export declare class S3Service extends S3Service_base {
+    static readonly layer: Layer.Layer<S3Service, Config.ConfigError, never>;
+    static readonly testLayer: (service: typeof this.Service) => Layer.Layer<S3Service, never, never>;
+}
+export {};