declare const make: <A, I, R>(options: {
  readonly name: string
  readonly schema: Schema.Schema<A, I, R>
}) => Effect.Effect<PersistedQueue<A, R>, never, PersistedQueueFactory>

declare const ErrorTypeId: "~@effect/experimental/PersistedQueue/PersistedQueueError"

type ErrorTypeId = "~@effect/experimental/PersistedQueue/PersistedQueueError"

declare class PersistedQueueError

readonly [ErrorTypeId]: "~@effect/experimental/PersistedQueue/PersistedQueueError"

declare class PersistedQueueFactory

declare const layer: Layer.Layer<PersistedQueueFactory, never, PersistedQueueStore>

declare const makeFactory: Effect.Effect<
  {
    readonly make: <A, I, R>(options: {
      readonly name: string
      readonly schema: Schema.Schema<A, I, R>
    }) => Effect.Effect<PersistedQueue<A, R>>
  },
  never,
  PersistedQueueStore
>

export interface PersistedQueue<in out A, out R = never> {
  readonly [TypeId]: TypeId

  /**
   * Adds an element to the queue. Returns the id of the enqueued element.
   */
  readonly offer: (value: A) => Effect.Effect<string, PersistedQueueError | ParseResult.ParseError, R>

  /**
   * Takes an element from the queue.
   * If the queue is empty, it will wait until an element is available.
   *
   * If the returned effect succeeds, the element is marked as processed,
   * otherwise it will be retried according to the provided options.
   * ake
   * By default, max attempts is set to 10.
   */
  readonly take: <XA, XE, XR>(
    f: (
      value: A,
      metadata: {
        readonly id: string
        readonly attempts: number
      }
    ) => Effect.Effect<XA, XE, XR>,
    options?: {
      readonly maxAttempts?: number | undefined
    }
  ) => Effect.Effect<XA, XE | PersistedQueueError | ParseResult.ParseError, R | XR>
}

declare class PersistedQueueStore

declare const layerStoreMemory: Layer.Layer<PersistedQueueStore, never, never>

declare const TypeId: "~@effect/experimental/PersistedQueue"

type TypeId = "~@effect/experimental/PersistedQueue"