effect 4.0.0-beta.6 → 4.0.0-beta.62

package/dist/ServiceMap.d.ts

@@ -1,1126 +0,0 @@
-/**
- * This module provides a data structure called `ServiceMap` that can be used
- * for dependency injection in effectful programs. It is essentially a table
- * mapping `Service`s identifiers to their implementations, and can be used to
- * manage dependencies in a type-safe way. The `ServiceMap` data structure is
- * essentially a way of providing access to a set of related services that can
- * be passed around as a single unit. This module provides functions to create,
- * modify, and query the contents of a `ServiceMap`, as well as a number of
- * utility types for working with a `ServiceMap`.
- *
- * @since 4.0.0
- */
-import type { Effect, EffectIterator, Yieldable } from "./Effect.ts";
-import * as Equal from "./Equal.ts";
-import { type LazyArg } from "./Function.ts";
-import type { Inspectable } from "./Inspectable.ts";
-import * as Option from "./Option.ts";
-import type { Pipeable } from "./Pipeable.ts";
-import type * as Types from "./Types.ts";
-declare const ServiceTypeId: "~effect/ServiceMap/Service";
-/**
- * @example
- * ```ts
- * import { ServiceMap } from "effect"
- *
- * // Define an identifier for a database service
- * const Database = ServiceMap.Service<{ query: (sql: string) => string }>(
- *   "Database"
- * )
- *
- * // The key can be used to store and retrieve services
- * const services = ServiceMap.make(Database, { query: (sql) => `Result: ${sql}` })
- * ```
- *
- * @since 4.0.0
- * @category Models
- */
-export interface Service<in out Identifier, in out Shape> extends Pipeable, Inspectable, Yieldable<Service<Identifier, Shape>, Shape, never, Identifier> {
-    readonly [ServiceTypeId]: {
-        readonly _Service: Types.Invariant<Shape>;
-        readonly _Identifier: Types.Invariant<Identifier>;
-    };
-    readonly Service: Shape;
-    readonly Identifier: Identifier;
-    of(self: Shape): Shape;
-    serviceMap(self: Shape): ServiceMap<Identifier>;
-    use<A, E, R>(f: (service: Shape) => Effect<A, E, R>): Effect<A, E, R | Identifier>;
-    useSync<A>(f: (service: Shape) => A): Effect<A, never, Identifier>;
-    readonly stack?: string | undefined;
-    readonly key: string;
-}
-/**
- * @since 4.0.0
- * @category Models
- */
-export interface ServiceClass<in out Self, in out Identifier extends string, in out Shape> extends Service<Self, Shape> {
-    new (_: never): ServiceClass.Shape<Identifier, Shape>;
-    readonly key: Identifier;
-}
-/**
- * @since 4.0.0
- * @category Models
- */
-export declare namespace ServiceClass {
-    /**
-     * @since 4.0.0
-     * @category Models
-     */
-    interface Shape<Identifier extends string, Service> {
-        readonly [ServiceTypeId]: typeof ServiceTypeId;
-        readonly key: Identifier;
-        readonly Service: Service;
-    }
-}
-/**
- * @example
- * ```ts
- * import { ServiceMap } from "effect"
- *
- * // Create a simple service
- * const Database = ServiceMap.Service<{
- *   query: (sql: string) => string
- * }>("Database")
- *
- * // Create a service class
- * class Config extends ServiceMap.Service<Config, {
- *   port: number
- * }>()("Config") {}
- *
- * // Use the services to create service maps
- * const db = ServiceMap.make(Database, {
- *   query: (sql) => `Result: ${sql}`
- * })
- * const config = ServiceMap.make(Config, { port: 8080 })
- * ```
- *
- * @since 4.0.0
- * @category Constructors
- */
-export declare const Service: {
-    /**
-     * @example
-     * ```ts
-     * import { ServiceMap } from "effect"
-     *
-     * // Create a simple service
-     * const Database = ServiceMap.Service<{
-     *   query: (sql: string) => string
-     * }>("Database")
-     *
-     * // Create a service class
-     * class Config extends ServiceMap.Service<Config, {
-     *   port: number
-     * }>()("Config") {}
-     *
-     * // Use the services to create service maps
-     * const db = ServiceMap.make(Database, {
-     *   query: (sql) => `Result: ${sql}`
-     * })
-     * const config = ServiceMap.make(Config, { port: 8080 })
-     * ```
-     *
-     * @since 4.0.0
-     * @category Constructors
-     */
-    <Identifier, Shape = Identifier>(key: string): Service<Identifier, Shape>;
-    /**
-     * @example
-     * ```ts
-     * import { ServiceMap } from "effect"
-     *
-     * // Create a simple service
-     * const Database = ServiceMap.Service<{
-     *   query: (sql: string) => string
-     * }>("Database")
-     *
-     * // Create a service class
-     * class Config extends ServiceMap.Service<Config, {
-     *   port: number
-     * }>()("Config") {}
-     *
-     * // Use the services to create service maps
-     * const db = ServiceMap.make(Database, {
-     *   query: (sql) => `Result: ${sql}`
-     * })
-     * const config = ServiceMap.make(Config, { port: 8080 })
-     * ```
-     *
-     * @since 4.0.0
-     * @category Constructors
-     */
-    <Self, Shape>(): <const Identifier extends string, E, R = Types.unassigned, Args extends ReadonlyArray<any> = never>(id: Identifier, options?: {
-        readonly make: ((...args: Args) => Effect<Shape, E, R>) | Effect<Shape, E, R> | undefined;
-    } | undefined) => ServiceClass<Self, Identifier, Shape> & ([Types.unassigned] extends [R] ? unknown : {
-        readonly make: [Args] extends [never] ? Effect<Shape, E, R> : (...args: Args) => Effect<Shape, E, R>;
-    });
-    /**
-     * @example
-     * ```ts
-     * import { ServiceMap } from "effect"
-     *
-     * // Create a simple service
-     * const Database = ServiceMap.Service<{
-     *   query: (sql: string) => string
-     * }>("Database")
-     *
-     * // Create a service class
-     * class Config extends ServiceMap.Service<Config, {
-     *   port: number
-     * }>()("Config") {}
-     *
-     * // Use the services to create service maps
-     * const db = ServiceMap.make(Database, {
-     *   query: (sql) => `Result: ${sql}`
-     * })
-     * const config = ServiceMap.make(Config, { port: 8080 })
-     * ```
-     *
-     * @since 4.0.0
-     * @category Constructors
-     */
-    <Self>(): <const Identifier extends string, Make extends Effect<any, any, any> | ((...args: any) => Effect<any, any, any>)>(id: Identifier, options: {
-        readonly make: Make;
-    }) => ServiceClass<Self, Identifier, Make extends Effect<infer _A, infer _E, infer _R> | ((...args: infer _Args) => Effect<infer _A, infer _E, infer _R>) ? _A : never> & {
-        readonly make: Make;
-    };
-};
-declare const ReferenceTypeId: "~effect/ServiceMap/Reference";
-/**
- * @example
- * ```ts
- * import { ServiceMap } from "effect"
- *
- * // Define a reference with a default value
- * const LoggerRef: ServiceMap.Reference<{ log: (msg: string) => void }> =
- *   ServiceMap.Reference("Logger", {
- *     defaultValue: () => ({ log: (msg: string) => console.log(msg) })
- *   })
- *
- * // The reference can be used without explicit provision
- * const serviceMap = ServiceMap.empty()
- * const logger = ServiceMap.get(serviceMap, LoggerRef) // Uses default value
- * ```
- *
- * @since 4.0.0
- * @category Models
- */
-export interface Reference<in out Shape> extends Service<never, Shape> {
-    readonly [ReferenceTypeId]: typeof ReferenceTypeId;
-    readonly defaultValue: () => Shape;
-    [Symbol.iterator](): EffectIterator<Reference<Shape>>;
-}
-/**
- * @example
- * ```ts
- * import { ServiceMap } from "effect"
- *
- * const Database = ServiceMap.Service<{
- *   query: (sql: string) => string
- * }>("Database")
- *
- * // Extract service type from a key
- * type DatabaseService = ServiceMap.Service.Shape<typeof Database>
- *
- * // Extract identifier type from a key
- * type DatabaseId = ServiceMap.Service.Identifier<typeof Database>
- * ```
- *
- * @since 4.0.0
- * @category Models
- */
-export declare namespace Service {
-    /**
-     * @example
-     * ```ts
-     * import type { ServiceMap } from "effect"
-     *
-     * // Variance interface is used internally for type inference
-     * type MyVariance = ServiceMap.Service.Variance<"MyId", { value: number }>
-     * ```
-     *
-     * @since 4.0.0
-     * @category Models
-     */
-    interface Variance<in out Identifier, in out Shape> {
-        readonly [ServiceTypeId]: {
-            readonly _Service: Types.Invariant<Shape>;
-            readonly _Identifier: Types.Invariant<Identifier>;
-        };
-    }
-    /**
-     * @example
-     * ```ts
-     * import { ServiceMap } from "effect"
-     *
-     * // Any represents any possible service type
-     * const services: Array<ServiceMap.Service.Any> = [
-     *   ServiceMap.Service<{ log: (msg: string) => void }>("Logger"),
-     *   ServiceMap.Service<{ query: (sql: string) => string }>("Database")
-     * ]
-     * ```
-     *
-     * @since 4.0.0
-     * @category Models
-     */
-    type Any = Service<never, any> | Service<any, any>;
-    /**
-     * @example
-     * ```ts
-     * import { ServiceMap } from "effect"
-     *
-     * const Database = ServiceMap.Service<{ query: (sql: string) => string }>(
-     *   "Database"
-     * )
-     *
-     * // Extract the service shape from the service
-     * type DatabaseService = ServiceMap.Service.Shape<typeof Database>
-     * // DatabaseService is { query: (sql: string) => string }
-     * ```
-     *
-     * @since 4.0.0
-     * @category Models
-     */
-    type Shape<T> = T extends Variance<infer _I, infer S> ? S : never;
-    /**
-     * @example
-     * ```ts
-     * import { ServiceMap } from "effect"
-     *
-     * const Database = ServiceMap.Service<{ query: (sql: string) => string }>(
-     *   "Database"
-     * )
-     *
-     * // Extract the identifier type from a key
-     * type DatabaseId = ServiceMap.Service.Identifier<typeof Database>
-     * // DatabaseId is the identifier type
-     * ```
-     *
-     * @since 4.0.0
-     * @category Models
-     */
-    type Identifier<T> = T extends Variance<infer I, infer _S> ? I : never;
-}
-declare const TypeId: "~effect/ServiceMap";
-/**
- * @example
- * ```ts
- * import { ServiceMap } from "effect"
- *
- * // Create a service map with multiple services
- * const Logger = ServiceMap.Service<{ log: (msg: string) => void }>("Logger")
- * const Database = ServiceMap.Service<{ query: (sql: string) => string }>(
- *   "Database"
- * )
- *
- * const services = ServiceMap.make(Logger, {
- *   log: (msg: string) => console.log(msg)
- * })
- *   .pipe(ServiceMap.add(Database, { query: (sql) => `Result: ${sql}` }))
- * ```
- *
- * @since 4.0.0
- * @category Models
- */
-export interface ServiceMap<in Services> extends Equal.Equal, Pipeable, Inspectable {
-    readonly [TypeId]: {
-        readonly _Services: Types.Contravariant<Services>;
-    };
-    readonly mapUnsafe: ReadonlyMap<string, any>;
-}
-/**
- * @example
- * ```ts
- * import { ServiceMap } from "effect"
- *
- * // Create a service map from a Map (unsafe)
- * const map = new Map([
- *   ["Logger", { log: (msg: string) => console.log(msg) }]
- * ])
- *
- * const services = ServiceMap.makeUnsafe(map)
- * ```
- *
- * @since 4.0.0
- * @category Constructors
- */
-export declare const makeUnsafe: <Services = never>(mapUnsafe: ReadonlyMap<string, any>) => ServiceMap<Services>;
-/**
- * Checks if the provided argument is a `ServiceMap`.
- *
- * @example
- * ```ts
- * import { ServiceMap } from "effect"
- * import * as assert from "node:assert"
- *
- * assert.strictEqual(ServiceMap.isServiceMap(ServiceMap.empty()), true)
- * ```
- *
- * @since 4.0.0
- * @category Guards
- */
-export declare const isServiceMap: (u: unknown) => u is ServiceMap<never>;
-/**
- * Checks if the provided argument is a `Service`.
- *
- * @example
- * ```ts
- * import { ServiceMap } from "effect"
- * import * as assert from "node:assert"
- *
- * assert.strictEqual(ServiceMap.isService(ServiceMap.Service("Service")), true)
- * ```
- *
- * @since 4.0.0
- * @category Guards
- */
-export declare const isService: (u: unknown) => u is Service<any, any>;
-/**
- * Checks if the provided argument is a `Reference`.
- *
- * @example
- * ```ts
- * import { ServiceMap } from "effect"
- * import * as assert from "node:assert"
- *
- * const LoggerRef = ServiceMap.Reference("Logger", {
- *   defaultValue: () => ({ log: (msg: string) => console.log(msg) })
- * })
- *
- * assert.strictEqual(ServiceMap.isReference(LoggerRef), true)
- * assert.strictEqual(ServiceMap.isReference(ServiceMap.Service("Key")), false)
- * ```
- *
- * @since 4.0.0
- * @category Guards
- */
-export declare const isReference: (u: unknown) => u is Reference<any>;
-/**
- * Returns an empty `ServiceMap`.
- *
- * @example
- * ```ts
- * import { ServiceMap } from "effect"
- * import * as assert from "node:assert"
- *
- * assert.strictEqual(ServiceMap.isServiceMap(ServiceMap.empty()), true)
- * ```
- *
- * @since 4.0.0
- * @category Constructors
- */
-export declare const empty: () => ServiceMap<never>;
-/**
- * Creates a new `ServiceMap` with a single service associated to the key.
- *
- * @example
- * ```ts
- * import { ServiceMap } from "effect"
- * import * as assert from "node:assert"
- *
- * const Port = ServiceMap.Service<{ PORT: number }>("Port")
- *
- * const Services = ServiceMap.make(Port, { PORT: 8080 })
- *
- * assert.deepStrictEqual(ServiceMap.get(Services, Port), { PORT: 8080 })
- * ```
- *
- * @since 4.0.0
- * @category Constructors
- */
-export declare const make: <I, S>(key: Service<I, S>, service: Types.NoInfer<S>) => ServiceMap<I>;
-/**
- * Adds a service to a given `ServiceMap`.
- *
- * @example
- * ```ts
- * import { pipe, ServiceMap } from "effect"
- * import * as assert from "node:assert"
- *
- * const Port = ServiceMap.Service<{ PORT: number }>("Port")
- * const Timeout = ServiceMap.Service<{ TIMEOUT: number }>("Timeout")
- *
- * const someServiceMap = ServiceMap.make(Port, { PORT: 8080 })
- *
- * const Services = pipe(
- *   someServiceMap,
- *   ServiceMap.add(Timeout, { TIMEOUT: 5000 })
- * )
- *
- * assert.deepStrictEqual(ServiceMap.get(Services, Port), { PORT: 8080 })
- * assert.deepStrictEqual(ServiceMap.get(Services, Timeout), { TIMEOUT: 5000 })
- * ```
- *
- * @since 4.0.0
- * @category Adders
- */
-export declare const add: {
-    /**
-     * Adds a service to a given `ServiceMap`.
-     *
-     * @example
-     * ```ts
-     * import { pipe, ServiceMap } from "effect"
-     * import * as assert from "node:assert"
-     *
-     * const Port = ServiceMap.Service<{ PORT: number }>("Port")
-     * const Timeout = ServiceMap.Service<{ TIMEOUT: number }>("Timeout")
-     *
-     * const someServiceMap = ServiceMap.make(Port, { PORT: 8080 })
-     *
-     * const Services = pipe(
-     *   someServiceMap,
-     *   ServiceMap.add(Timeout, { TIMEOUT: 5000 })
-     * )
-     *
-     * assert.deepStrictEqual(ServiceMap.get(Services, Port), { PORT: 8080 })
-     * assert.deepStrictEqual(ServiceMap.get(Services, Timeout), { TIMEOUT: 5000 })
-     * ```
-     *
-     * @since 4.0.0
-     * @category Adders
-     */
-    <I, S>(key: Service<I, S>, service: Types.NoInfer<S>): <Services>(self: ServiceMap<Services>) => ServiceMap<Services | I>;
-    /**
-     * Adds a service to a given `ServiceMap`.
-     *
-     * @example
-     * ```ts
-     * import { pipe, ServiceMap } from "effect"
-     * import * as assert from "node:assert"
-     *
-     * const Port = ServiceMap.Service<{ PORT: number }>("Port")
-     * const Timeout = ServiceMap.Service<{ TIMEOUT: number }>("Timeout")
-     *
-     * const someServiceMap = ServiceMap.make(Port, { PORT: 8080 })
-     *
-     * const Services = pipe(
-     *   someServiceMap,
-     *   ServiceMap.add(Timeout, { TIMEOUT: 5000 })
-     * )
-     *
-     * assert.deepStrictEqual(ServiceMap.get(Services, Port), { PORT: 8080 })
-     * assert.deepStrictEqual(ServiceMap.get(Services, Timeout), { TIMEOUT: 5000 })
-     * ```
-     *
-     * @since 4.0.0
-     * @category Adders
-     */
-    <Services, I, S>(self: ServiceMap<Services>, key: Service<I, S>, service: Types.NoInfer<S>): ServiceMap<Services | I>;
-};
-/**
- * @since 4.0.0
- * @category Adders
- */
-export declare const addOrOmit: {
-    /**
-     * @since 4.0.0
-     * @category Adders
-     */
-    <I, S>(key: Service<I, S>, service: Option.Option<Types.NoInfer<S>>): <Services>(self: ServiceMap<Services>) => ServiceMap<Services | I>;
-    /**
-     * @since 4.0.0
-     * @category Adders
-     */
-    <Services, I, S>(self: ServiceMap<Services>, key: Service<I, S>, service: Option.Option<Types.NoInfer<S>>): ServiceMap<Services | I>;
-};
-/**
- * Get a service from the context that corresponds to the given key, or
- * use the fallback value.
- *
- * @example
- * ```ts
- * import { ServiceMap } from "effect"
- * import * as assert from "node:assert"
- *
- * const Logger = ServiceMap.Service<{ log: (msg: string) => void }>("Logger")
- * const Database = ServiceMap.Service<{ query: (sql: string) => string }>(
- *   "Database"
- * )
- *
- * const services = ServiceMap.make(Logger, {
- *   log: (msg: string) => console.log(msg)
- * })
- *
- * const logger = ServiceMap.getOrElse(services, Logger, () => ({ log: () => {} }))
- * const database = ServiceMap.getOrElse(
- *   services,
- *   Database,
- *   () => ({ query: () => "fallback" })
- * )
- *
- * assert.deepStrictEqual(logger, { log: (msg: string) => console.log(msg) })
- * assert.deepStrictEqual(database, { query: () => "fallback" })
- * ```
- *
- * @since 4.0.0
- * @category Getters
- */
-export declare const getOrElse: {
-    /**
-     * Get a service from the context that corresponds to the given key, or
-     * use the fallback value.
-     *
-     * @example
-     * ```ts
-     * import { ServiceMap } from "effect"
-     * import * as assert from "node:assert"
-     *
-     * const Logger = ServiceMap.Service<{ log: (msg: string) => void }>("Logger")
-     * const Database = ServiceMap.Service<{ query: (sql: string) => string }>(
-     *   "Database"
-     * )
-     *
-     * const services = ServiceMap.make(Logger, {
-     *   log: (msg: string) => console.log(msg)
-     * })
-     *
-     * const logger = ServiceMap.getOrElse(services, Logger, () => ({ log: () => {} }))
-     * const database = ServiceMap.getOrElse(
-     *   services,
-     *   Database,
-     *   () => ({ query: () => "fallback" })
-     * )
-     *
-     * assert.deepStrictEqual(logger, { log: (msg: string) => console.log(msg) })
-     * assert.deepStrictEqual(database, { query: () => "fallback" })
-     * ```
-     *
-     * @since 4.0.0
-     * @category Getters
-     */
-    <S, I, B>(key: Service<I, S>, orElse: LazyArg<B>): <Services>(self: ServiceMap<Services>) => S | B;
-    /**
-     * Get a service from the context that corresponds to the given key, or
-     * use the fallback value.
-     *
-     * @example
-     * ```ts
-     * import { ServiceMap } from "effect"
-     * import * as assert from "node:assert"
-     *
-     * const Logger = ServiceMap.Service<{ log: (msg: string) => void }>("Logger")
-     * const Database = ServiceMap.Service<{ query: (sql: string) => string }>(
-     *   "Database"
-     * )
-     *
-     * const services = ServiceMap.make(Logger, {
-     *   log: (msg: string) => console.log(msg)
-     * })
-     *
-     * const logger = ServiceMap.getOrElse(services, Logger, () => ({ log: () => {} }))
-     * const database = ServiceMap.getOrElse(
-     *   services,
-     *   Database,
-     *   () => ({ query: () => "fallback" })
-     * )
-     *
-     * assert.deepStrictEqual(logger, { log: (msg: string) => console.log(msg) })
-     * assert.deepStrictEqual(database, { query: () => "fallback" })
-     * ```
-     *
-     * @since 4.0.0
-     * @category Getters
-     */
-    <Services, S, I, B>(self: ServiceMap<Services>, key: Service<I, S>, orElse: LazyArg<B>): S | B;
-};
-/**
- * @since 4.0.0
- * @category Getters
- */
-export declare const getOrUndefined: {
-    /**
-     * @since 4.0.0
-     * @category Getters
-     */
-    <S, I>(key: Service<I, S>): <Services>(self: ServiceMap<Services>) => S | undefined;
-    /**
-     * @since 4.0.0
-     * @category Getters
-     */
-    <Services, S, I>(self: ServiceMap<Services>, key: Service<I, S>): S | undefined;
-};
-/**
- * Get a service from the context that corresponds to the given key.
- *
- * This function is unsafe because if the key is not present in the context, a
- * runtime error will be thrown.
- *
- * For a safer version see {@link getOption}.
- *
- * @param self - The `ServiceMap` to search for the service.
- * @param service - The `Service` of the service to retrieve.
- *
- * @example
- * ```ts
- * import { ServiceMap } from "effect"
- * import * as assert from "node:assert"
- *
- * const Port = ServiceMap.Service<{ PORT: number }>("Port")
- * const Timeout = ServiceMap.Service<{ TIMEOUT: number }>("Timeout")
- *
- * const Services = ServiceMap.make(Port, { PORT: 8080 })
- *
- * assert.deepStrictEqual(ServiceMap.getUnsafe(Services, Port), { PORT: 8080 })
- * assert.throws(() => ServiceMap.getUnsafe(Services, Timeout))
- * ```
- *
- * @since 4.0.0
- * @category unsafe
- */
-export declare const getUnsafe: {
-    /**
-     * Get a service from the context that corresponds to the given key.
-     *
-     * This function is unsafe because if the key is not present in the context, a
-     * runtime error will be thrown.
-     *
-     * For a safer version see {@link getOption}.
-     *
-     * @param self - The `ServiceMap` to search for the service.
-     * @param service - The `Service` of the service to retrieve.
-     *
-     * @example
-     * ```ts
-     * import { ServiceMap } from "effect"
-     * import * as assert from "node:assert"
-     *
-     * const Port = ServiceMap.Service<{ PORT: number }>("Port")
-     * const Timeout = ServiceMap.Service<{ TIMEOUT: number }>("Timeout")
-     *
-     * const Services = ServiceMap.make(Port, { PORT: 8080 })
-     *
-     * assert.deepStrictEqual(ServiceMap.getUnsafe(Services, Port), { PORT: 8080 })
-     * assert.throws(() => ServiceMap.getUnsafe(Services, Timeout))
-     * ```
-     *
-     * @since 4.0.0
-     * @category unsafe
-     */
-    <S, I>(service: Service<I, S>): <Services>(self: ServiceMap<Services>) => S;
-    /**
-     * Get a service from the context that corresponds to the given key.
-     *
-     * This function is unsafe because if the key is not present in the context, a
-     * runtime error will be thrown.
-     *
-     * For a safer version see {@link getOption}.
-     *
-     * @param self - The `ServiceMap` to search for the service.
-     * @param service - The `Service` of the service to retrieve.
-     *
-     * @example
-     * ```ts
-     * import { ServiceMap } from "effect"
-     * import * as assert from "node:assert"
-     *
-     * const Port = ServiceMap.Service<{ PORT: number }>("Port")
-     * const Timeout = ServiceMap.Service<{ TIMEOUT: number }>("Timeout")
-     *
-     * const Services = ServiceMap.make(Port, { PORT: 8080 })
-     *
-     * assert.deepStrictEqual(ServiceMap.getUnsafe(Services, Port), { PORT: 8080 })
-     * assert.throws(() => ServiceMap.getUnsafe(Services, Timeout))
-     * ```
-     *
-     * @since 4.0.0
-     * @category unsafe
-     */
-    <Services, S, I>(self: ServiceMap<Services>, services: Service<I, S>): S;
-};
-/**
- * Get a service from the context that corresponds to the given key.
- *
- * @param self - The `ServiceMap` to search for the service.
- * @param service - The `Service` of the service to retrieve.
- *
- * @example
- * ```ts
- * import { pipe, ServiceMap } from "effect"
- * import * as assert from "node:assert"
- *
- * const Port = ServiceMap.Service<{ PORT: number }>("Port")
- * const Timeout = ServiceMap.Service<{ TIMEOUT: number }>("Timeout")
- *
- * const Services = pipe(
- *   ServiceMap.make(Port, { PORT: 8080 }),
- *   ServiceMap.add(Timeout, { TIMEOUT: 5000 })
- * )
- *
- * assert.deepStrictEqual(ServiceMap.get(Services, Timeout), { TIMEOUT: 5000 })
- * ```
- *
- * @since 4.0.0
- * @category Getters
- */
-export declare const get: {
-    /**
-     * Get a service from the context that corresponds to the given key.
-     *
-     * @param self - The `ServiceMap` to search for the service.
-     * @param service - The `Service` of the service to retrieve.
-     *
-     * @example
-     * ```ts
-     * import { pipe, ServiceMap } from "effect"
-     * import * as assert from "node:assert"
-     *
-     * const Port = ServiceMap.Service<{ PORT: number }>("Port")
-     * const Timeout = ServiceMap.Service<{ TIMEOUT: number }>("Timeout")
-     *
-     * const Services = pipe(
-     *   ServiceMap.make(Port, { PORT: 8080 }),
-     *   ServiceMap.add(Timeout, { TIMEOUT: 5000 })
-     * )
-     *
-     * assert.deepStrictEqual(ServiceMap.get(Services, Timeout), { TIMEOUT: 5000 })
-     * ```
-     *
-     * @since 4.0.0
-     * @category Getters
-     */
-    <Services, I extends Services, S>(service: Service<I, S>): (self: ServiceMap<Services>) => S;
-    /**
-     * Get a service from the context that corresponds to the given key.
-     *
-     * @param self - The `ServiceMap` to search for the service.
-     * @param service - The `Service` of the service to retrieve.
-     *
-     * @example
-     * ```ts
-     * import { pipe, ServiceMap } from "effect"
-     * import * as assert from "node:assert"
-     *
-     * const Port = ServiceMap.Service<{ PORT: number }>("Port")
-     * const Timeout = ServiceMap.Service<{ TIMEOUT: number }>("Timeout")
-     *
-     * const Services = pipe(
-     *   ServiceMap.make(Port, { PORT: 8080 }),
-     *   ServiceMap.add(Timeout, { TIMEOUT: 5000 })
-     * )
-     *
-     * assert.deepStrictEqual(ServiceMap.get(Services, Timeout), { TIMEOUT: 5000 })
-     * ```
-     *
-     * @since 4.0.0
-     * @category Getters
-     */
-    <Services, I extends Services, S>(self: ServiceMap<Services>, service: Service<I, S>): S;
-};
-/**
- * @example
- * ```ts
- * import { ServiceMap } from "effect"
- * import * as assert from "node:assert"
- *
- * const LoggerRef = ServiceMap.Reference("Logger", {
- *   defaultValue: () => ({ log: (msg: string) => console.log(msg) })
- * })
- *
- * const services = ServiceMap.empty()
- * const logger = ServiceMap.getReferenceUnsafe(services, LoggerRef)
- *
- * assert.deepStrictEqual(logger, { log: (msg: string) => console.log(msg) })
- * ```
- *
- * @since 4.0.0
- * @category unsafe
- */
-export declare const getReferenceUnsafe: <Services, S>(self: ServiceMap<Services>, service: Reference<S>) => S;
-/**
- * Get the value associated with the specified key from the context wrapped in
- * an `Option` object. If the key is not found, the `Option` object will be
- * `None`.
- *
- * @param self - The `ServiceMap` to search for the service.
- * @param service - The `Service` of the service to retrieve.
- *
- * @example
- * ```ts
- * import { Option, ServiceMap } from "effect"
- * import * as assert from "node:assert"
- *
- * const Port = ServiceMap.Service<{ PORT: number }>("Port")
- * const Timeout = ServiceMap.Service<{ TIMEOUT: number }>("Timeout")
- *
- * const Services = ServiceMap.make(Port, { PORT: 8080 })
- *
- * assert.deepStrictEqual(
- *   ServiceMap.getOption(Services, Port),
- *   Option.some({ PORT: 8080 })
- * )
- * assert.deepStrictEqual(ServiceMap.getOption(Services, Timeout), Option.none())
- * ```
- *
- * @since 4.0.0
- * @category Getters
- */
-export declare const getOption: {
-    /**
-     * Get the value associated with the specified key from the context wrapped in
-     * an `Option` object. If the key is not found, the `Option` object will be
-     * `None`.
-     *
-     * @param self - The `ServiceMap` to search for the service.
-     * @param service - The `Service` of the service to retrieve.
-     *
-     * @example
-     * ```ts
-     * import { Option, ServiceMap } from "effect"
-     * import * as assert from "node:assert"
-     *
-     * const Port = ServiceMap.Service<{ PORT: number }>("Port")
-     * const Timeout = ServiceMap.Service<{ TIMEOUT: number }>("Timeout")
-     *
-     * const Services = ServiceMap.make(Port, { PORT: 8080 })
-     *
-     * assert.deepStrictEqual(
-     *   ServiceMap.getOption(Services, Port),
-     *   Option.some({ PORT: 8080 })
-     * )
-     * assert.deepStrictEqual(ServiceMap.getOption(Services, Timeout), Option.none())
-     * ```
-     *
-     * @since 4.0.0
-     * @category Getters
-     */
-    <S, I>(service: Service<I, S>): <Services>(self: ServiceMap<Services>) => Option.Option<S>;
-    /**
-     * Get the value associated with the specified key from the context wrapped in
-     * an `Option` object. If the key is not found, the `Option` object will be
-     * `None`.
-     *
-     * @param self - The `ServiceMap` to search for the service.
-     * @param service - The `Service` of the service to retrieve.
-     *
-     * @example
-     * ```ts
-     * import { Option, ServiceMap } from "effect"
-     * import * as assert from "node:assert"
-     *
-     * const Port = ServiceMap.Service<{ PORT: number }>("Port")
-     * const Timeout = ServiceMap.Service<{ TIMEOUT: number }>("Timeout")
-     *
-     * const Services = ServiceMap.make(Port, { PORT: 8080 })
-     *
-     * assert.deepStrictEqual(
-     *   ServiceMap.getOption(Services, Port),
-     *   Option.some({ PORT: 8080 })
-     * )
-     * assert.deepStrictEqual(ServiceMap.getOption(Services, Timeout), Option.none())
-     * ```
-     *
-     * @since 4.0.0
-     * @category Getters
-     */
-    <Services, S, I>(self: ServiceMap<Services>, service: Service<I, S>): Option.Option<S>;
-};
-/**
- * Merges two `ServiceMap`s, returning a new `ServiceMap` containing the services of both.
- *
- * @param self - The first `ServiceMap` to merge.
- * @param that - The second `ServiceMap` to merge.
- *
- * @example
- * ```ts
- * import { ServiceMap } from "effect"
- * import * as assert from "node:assert"
- *
- * const Port = ServiceMap.Service<{ PORT: number }>("Port")
- * const Timeout = ServiceMap.Service<{ TIMEOUT: number }>("Timeout")
- *
- * const firstServiceMap = ServiceMap.make(Port, { PORT: 8080 })
- * const secondServiceMap = ServiceMap.make(Timeout, { TIMEOUT: 5000 })
- *
- * const Services = ServiceMap.merge(firstServiceMap, secondServiceMap)
- *
- * assert.deepStrictEqual(ServiceMap.get(Services, Port), { PORT: 8080 })
- * assert.deepStrictEqual(ServiceMap.get(Services, Timeout), { TIMEOUT: 5000 })
- * ```
- *
- * @since 4.0.0
- * @category Utils
- */
-export declare const merge: {
-    /**
-     * Merges two `ServiceMap`s, returning a new `ServiceMap` containing the services of both.
-     *
-     * @param self - The first `ServiceMap` to merge.
-     * @param that - The second `ServiceMap` to merge.
-     *
-     * @example
-     * ```ts
-     * import { ServiceMap } from "effect"
-     * import * as assert from "node:assert"
-     *
-     * const Port = ServiceMap.Service<{ PORT: number }>("Port")
-     * const Timeout = ServiceMap.Service<{ TIMEOUT: number }>("Timeout")
-     *
-     * const firstServiceMap = ServiceMap.make(Port, { PORT: 8080 })
-     * const secondServiceMap = ServiceMap.make(Timeout, { TIMEOUT: 5000 })
-     *
-     * const Services = ServiceMap.merge(firstServiceMap, secondServiceMap)
-     *
-     * assert.deepStrictEqual(ServiceMap.get(Services, Port), { PORT: 8080 })
-     * assert.deepStrictEqual(ServiceMap.get(Services, Timeout), { TIMEOUT: 5000 })
-     * ```
-     *
-     * @since 4.0.0
-     * @category Utils
-     */
-    <R1>(that: ServiceMap<R1>): <Services>(self: ServiceMap<Services>) => ServiceMap<R1 | Services>;
-    /**
-     * Merges two `ServiceMap`s, returning a new `ServiceMap` containing the services of both.
-     *
-     * @param self - The first `ServiceMap` to merge.
-     * @param that - The second `ServiceMap` to merge.
-     *
-     * @example
-     * ```ts
-     * import { ServiceMap } from "effect"
-     * import * as assert from "node:assert"
-     *
-     * const Port = ServiceMap.Service<{ PORT: number }>("Port")
-     * const Timeout = ServiceMap.Service<{ TIMEOUT: number }>("Timeout")
-     *
-     * const firstServiceMap = ServiceMap.make(Port, { PORT: 8080 })
-     * const secondServiceMap = ServiceMap.make(Timeout, { TIMEOUT: 5000 })
-     *
-     * const Services = ServiceMap.merge(firstServiceMap, secondServiceMap)
-     *
-     * assert.deepStrictEqual(ServiceMap.get(Services, Port), { PORT: 8080 })
-     * assert.deepStrictEqual(ServiceMap.get(Services, Timeout), { TIMEOUT: 5000 })
-     * ```
-     *
-     * @since 4.0.0
-     * @category Utils
-     */
-    <Services, R1>(self: ServiceMap<Services>, that: ServiceMap<R1>): ServiceMap<Services | R1>;
-};
-/**
- * Merges any number of `ServiceMap`s, returning a new `ServiceMap` containing the services of all.
- *
- * @example
- * ```ts
- * import { ServiceMap } from "effect"
- * import * as assert from "node:assert"
- *
- * const Port = ServiceMap.Service<{ PORT: number }>("Port")
- * const Timeout = ServiceMap.Service<{ TIMEOUT: number }>("Timeout")
- * const Host = ServiceMap.Service<{ HOST: string }>("Host")
- *
- * const firstServiceMap = ServiceMap.make(Port, { PORT: 8080 })
- * const secondServiceMap = ServiceMap.make(Timeout, { TIMEOUT: 5000 })
- * const thirdServiceMap = ServiceMap.make(Host, { HOST: "localhost" })
- *
- * const Services = ServiceMap.mergeAll(
- *   firstServiceMap,
- *   secondServiceMap,
- *   thirdServiceMap
- * )
- *
- * assert.deepStrictEqual(ServiceMap.get(Services, Port), { PORT: 8080 })
- * assert.deepStrictEqual(ServiceMap.get(Services, Timeout), { TIMEOUT: 5000 })
- * assert.deepStrictEqual(ServiceMap.get(Services, Host), { HOST: "localhost" })
- * ```
- *
- * @since 3.12.0
- */
-export declare const mergeAll: <T extends Array<unknown>>(...ctxs: [...{ [K in keyof T]: ServiceMap<T[K]>; }]) => ServiceMap<T[number]>;
-/**
- * Returns a new `ServiceMap` that contains only the specified services.
- *
- * @param self - The `ServiceMap` to prune services from.
- * @param services - The list of `Service`s to be included in the new `ServiceMap`.
- *
- * @example
- * ```ts
- * import { Option, pipe, ServiceMap } from "effect"
- * import * as assert from "node:assert"
- *
- * const Port = ServiceMap.Service<{ PORT: number }>("Port")
- * const Timeout = ServiceMap.Service<{ TIMEOUT: number }>("Timeout")
- *
- * const someServiceMap = pipe(
- *   ServiceMap.make(Port, { PORT: 8080 }),
- *   ServiceMap.add(Timeout, { TIMEOUT: 5000 })
- * )
- *
- * const Services = pipe(someServiceMap, ServiceMap.pick(Port))
- *
- * assert.deepStrictEqual(
- *   ServiceMap.getOption(Services, Port),
- *   Option.some({ PORT: 8080 })
- * )
- * assert.deepStrictEqual(ServiceMap.getOption(Services, Timeout), Option.none())
- * ```
- *
- * @since 4.0.0
- * @category Utils
- */
-export declare const pick: <S extends ReadonlyArray<Service<any, any>>>(...services: S) => <Services>(self: ServiceMap<Services>) => ServiceMap<Services & Service.Identifier<S[number]>>;
-/**
- * @example
- * ```ts
- * import { Option, pipe, ServiceMap } from "effect"
- * import * as assert from "node:assert"
- *
- * const Port = ServiceMap.Service<{ PORT: number }>("Port")
- * const Timeout = ServiceMap.Service<{ TIMEOUT: number }>("Timeout")
- *
- * const someServiceMap = pipe(
- *   ServiceMap.make(Port, { PORT: 8080 }),
- *   ServiceMap.add(Timeout, { TIMEOUT: 5000 })
- * )
- *
- * const Services = pipe(someServiceMap, ServiceMap.omit(Timeout))
- *
- * assert.deepStrictEqual(
- *   ServiceMap.getOption(Services, Port),
- *   Option.some({ PORT: 8080 })
- * )
- * assert.deepStrictEqual(ServiceMap.getOption(Services, Timeout), Option.none())
- * ```
- *
- * @since 4.0.0
- * @category Utils
- */
-export declare const omit: <S extends ReadonlyArray<Service<any, any>>>(...keys: S) => <Services>(self: ServiceMap<Services>) => ServiceMap<Exclude<Services, Service.Identifier<S[number]>>>;
-/**
- * Creates a service map key with a default value.
- *
- * **Details**
- *
- * `ServiceMap.Reference` allows you to create a key that can hold a value. You
- * can provide a default value for the service, which will automatically be used
- * when the context is accessed, or override it with a custom implementation
- * when needed.
- *
- * @example
- * ```ts
- * import { ServiceMap } from "effect"
- *
- * // Create a reference with a default value
- * const LoggerRef = ServiceMap.Reference("Logger", {
- *   defaultValue: () => ({ log: (msg: string) => console.log(msg) })
- * })
- *
- * // The reference provides the default value when accessed from an empty context
- * const services = ServiceMap.empty()
- * const logger = ServiceMap.get(services, LoggerRef)
- *
- * // You can also override the default value
- * const customServices = ServiceMap.make(LoggerRef, {
- *   log: (msg: string) => `Custom: ${msg}`
- * })
- * const customLogger = ServiceMap.get(customServices, LoggerRef)
- * ```
- *
- * @since 4.0.0
- * @category References
- */
-export declare const Reference: <Service>(key: string, options: {
-    readonly defaultValue: () => Service;
-}) => Reference<Service>;
-export {};
-//# sourceMappingURL=ServiceMap.d.ts.map