effect 2.0.0-next.47 → 2.0.0-next.49

package/dist/declarations/src/Effect.d.ts

@@ -25,7 +25,6 @@ import type * as HashMap from "./HashMap.js";
 import type * as HashSet from "./HashSet.js";
 import type { TypeLambda } from "./HKT.js";
 import type * as Layer from "./Layer.js";
-import type * as Logger from "./Logger.js";
 import type { LogLevel } from "./LogLevel.js";
 import type * as Metric from "./Metric.js";
 import type * as MetricLabel from "./MetricLabel.js";
@@ -1975,11 +1974,6 @@ export declare const withConcurrency: {
     (concurrency: number | "unbounded"): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
     <R, E, A>(self: Effect<R, E, A>, concurrency: number | "unbounded"): Effect<R, E, A>;
 };
-/**
- * @since 2.0.0
- * @category scheduler
- */
-export declare const setScheduler: (scheduler: Scheduler.Scheduler) => Layer.Layer<never, never, never>;
 /**
  * Sets the provided scheduler for usage in the wrapped effect
  *
@@ -2025,11 +2019,6 @@ export declare const clock: Effect<never, never, Clock.Clock>;
  * @category clock
  */
 export declare const clockWith: <R, E, A>(f: (clock: Clock.Clock) => Effect<R, E, A>) => Effect<R, E, A>;
-/**
- * @since 2.0.0
- * @category clock
- */
-export declare const setClock: <A extends Clock.Clock>(clock: A) => Layer.Layer<never, never, never>;
 /**
  * Sets the implementation of the clock service to the specified value and
  * restores it to its original value when the scope is closed.
@@ -2183,13 +2172,6 @@ export declare const config: <A>(config: Config<A>) => Effect<never, ConfigError
  * @category config
  */
 export declare const configProviderWith: <R, E, A>(f: (configProvider: ConfigProvider) => Effect<R, E, A>) => Effect<R, E, A>;
-/**
- * Sets the current `ConfigProvider`.
- *
- * @since 2.0.0
- * @category config
- */
-export declare const setConfigProvider: (configProvider: ConfigProvider) => Layer.Layer<never, never, never>;
 /**
  * Executes the specified workflow with the specified configuration provider.
  *
@@ -3117,10 +3099,10 @@ export declare const withLogSpan: {
  * @category logging
  */
 export declare const annotateLogs: {
-    (key: string, value: Logger.AnnotationValue): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A>;
-    (values: Record<string, Logger.AnnotationValue>): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A>;
-    <R, E, A>(effect: Effect<R, E, A>, key: string, value: Logger.AnnotationValue): Effect<R, E, A>;
-    <R, E, A>(effect: Effect<R, E, A>, values: Record<string, Logger.AnnotationValue>): Effect<R, E, A>;
+    (key: string, value: unknown): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A>;
+    (values: Record<string, unknown>): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A>;
+    <R, E, A>(effect: Effect<R, E, A>, key: string, value: unknown): Effect<R, E, A>;
+    <R, E, A>(effect: Effect<R, E, A>, values: Record<string, unknown>): Effect<R, E, A>;
 };
 /**
  * Retrieves the log annotations associated with the current scope.
@@ -3128,7 +3110,7 @@ export declare const annotateLogs: {
  * @since 2.0.0
  * @category logging
  */
-export declare const logAnnotations: Effect<never, never, HashMap.HashMap<string, Logger.AnnotationValue>>;
+export declare const logAnnotations: Effect<never, never, HashMap.HashMap<string, unknown>>;
 /**
  * Decides wether child fibers will report or not unhandled errors via the logger
  *
@@ -3139,11 +3121,6 @@ export declare const withUnhandledErrorLogLevel: {
     (level: Option.Option<LogLevel>): <R, E, B>(self: Effect<R, E, B>) => Effect<R, E, B>;
     <R, E, B>(self: Effect<R, E, B>, level: Option.Option<LogLevel>): Effect<R, E, B>;
 };
-/**
- * @since 2.0.0
- * @category logging
- */
-export declare const setUnhandledErrorLogLevel: (level: Option.Option<LogLevel>) => Layer.Layer<never, never, never>;
 /**
  * Translates effect failure into death of the fiber, making all failures
  * unchecked and not a part of the type of the effect.
@@ -3484,6 +3461,14 @@ export declare const zipWith: {
         readonly batching?: boolean | "inherit";
     }): Effect<R | R2, E | E2, B>;
 };
+/**
+ * @category combining
+ * @since 2.0.0
+ */
+export declare const ap: {
+    <R2, E2, A>(that: Effect<R2, E2, A>): <R, E, B>(self: Effect<R, E, (a: A) => B>) => Effect<R | R2, E | E2, B>;
+    <R, E, A, B, R2, E2>(self: Effect<R, E, (a: A) => B>, that: Effect<R2, E2, A>): Effect<R | R2, E | E2, B>;
+};
 /**
  * @category requests & batching
  * @since 2.0.0
@@ -3526,24 +3511,6 @@ export declare const withRequestBatching: {
     (requestBatching: boolean): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
     <R, E, A>(self: Effect<R, E, A>, requestBatching: boolean): Effect<R, E, A>;
 };
-/**
- * @since 2.0.0
- * @category requests & batching
- */
-export declare const setRequestBatching: (requestBatching: boolean) => Layer.Layer<never, never, never>;
-/**
- * @since 2.0.0
- * @category requests & batching
- */
-export declare const setRequestCaching: (requestCaching: boolean) => Layer.Layer<never, never, never>;
-/**
- * @since 2.0.0
- * @category requests & batching
- */
-export declare const setRequestCache: {
-    <R, E>(cache: Effect<R, E, Request.Cache>): Layer.Layer<Exclude<R, Scope.Scope>, E, never>;
-    (cache: Request.Cache): Layer.Layer<never, never, never>;
-};
 /**
  * @since 2.0.0
  * @category requests & batching
@@ -3560,13 +3527,6 @@ export declare const withRequestCache: {
     (cache: Request.Cache): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
     <R, E, A>(self: Effect<R, E, A>, cache: Request.Cache): Effect<R, E, A>;
 };
-/**
- * Create a Layer that sets the current Tracer
- *
- * @since 2.0.0
- * @category tracing
- */
-export declare const setTracer: (tracer: Tracer.Tracer) => Layer.Layer<never, never, never>;
 /**
  * @since 2.0.0
  * @category tracing
@@ -3598,11 +3558,6 @@ export declare const withTracerTiming: {
     (enabled: boolean): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A>;
     <R, E, A>(effect: Effect<R, E, A>, enabled: boolean): Effect<R, E, A>;
 };
-/**
- * @since 2.0.0
- * @category tracing
- */
-export declare const setTracerTiming: (enabled: boolean) => Layer.Layer<never, never, never>;
 /**
  * Adds an annotation to each span in this effect.
  *
@@ -3610,10 +3565,10 @@ export declare const setTracerTiming: (enabled: boolean) => Layer.Layer<never, n
  * @category tracing
  */
 export declare const annotateSpans: {
-    (key: string, value: Tracer.AttributeValue): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A>;
-    (values: Record<string, Tracer.AttributeValue>): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A>;
-    <R, E, A>(effect: Effect<R, E, A>, key: string, value: Tracer.AttributeValue): Effect<R, E, A>;
-    <R, E, A>(effect: Effect<R, E, A>, values: Record<string, Tracer.AttributeValue>): Effect<R, E, A>;
+    (key: string, value: unknown): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A>;
+    (values: Record<string, unknown>): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A>;
+    <R, E, A>(effect: Effect<R, E, A>, key: string, value: unknown): Effect<R, E, A>;
+    <R, E, A>(effect: Effect<R, E, A>, values: Record<string, unknown>): Effect<R, E, A>;
 };
 /**
  * Adds an annotation to the current span if available
@@ -3622,8 +3577,8 @@ export declare const annotateSpans: {
  * @category tracing
  */
 export declare const annotateCurrentSpan: {
-    (key: string, value: Tracer.AttributeValue): Effect<never, never, void>;
-    (values: Record<string, Tracer.AttributeValue>): Effect<never, never, void>;
+    (key: string, value: unknown): Effect<never, never, void>;
+    (values: Record<string, unknown>): Effect<never, never, void>;
 };
 /**
  * @since 2.0.0
@@ -3639,7 +3594,7 @@ export declare const currentParentSpan: Effect<never, never, Option.Option<Trace
  * @since 2.0.0
  * @category tracing
  */
-export declare const spanAnnotations: Effect<never, never, HashMap.HashMap<string, Tracer.AttributeValue>>;
+export declare const spanAnnotations: Effect<never, never, HashMap.HashMap<string, unknown>>;
 /**
  * @since 2.0.0
  * @category tracing
@@ -3652,8 +3607,8 @@ export declare const spanLinks: Effect<never, never, Chunk.Chunk<Tracer.SpanLink
  * @category tracing
  */
 export declare const linkSpans: {
-    (span: Tracer.ParentSpan, attributes?: Record<string, Tracer.AttributeValue>): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
-    <R, E, A>(self: Effect<R, E, A>, span: Tracer.ParentSpan, attributes?: Record<string, Tracer.AttributeValue>): Effect<R, E, A>;
+    (span: Tracer.ParentSpan, attributes?: Record<string, unknown>): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
+    <R, E, A>(self: Effect<R, E, A>, span: Tracer.ParentSpan, attributes?: Record<string, unknown>): Effect<R, E, A>;
 };
 /**
  * Create a new span for tracing.
@@ -3662,34 +3617,31 @@ export declare const linkSpans: {
  * @category tracing
  */
 export declare const makeSpan: (name: string, options?: {
-    readonly attributes?: Record<string, Tracer.AttributeValue>;
+    readonly attributes?: Record<string, unknown>;
     readonly links?: ReadonlyArray<Tracer.SpanLink>;
     readonly parent?: Tracer.ParentSpan;
     readonly root?: boolean;
+    readonly sampled?: boolean;
     readonly context?: Context.Context<never>;
 }) => Effect<never, never, Tracer.Span>;
 /**
- * Adds the provided span to the span stack.
- *
- * @since 2.0.0
- * @category tracing
- */
-export declare const setParentSpan: (span: Tracer.ParentSpan) => Layer.Layer<never, never, never>;
-/**
- * Create and add a span to the current span stack.
+ * Create a new span for tracing, and automatically close it when the Scope
+ * finalizes.
  *
- * The span is ended when the Layer is released.
+ * The span is not added to the current span stack, so no child spans will be
+ * created for it.
  *
  * @since 2.0.0
  * @category tracing
  */
-export declare const setSpan: (name: string, options?: {
-    readonly attributes?: Record<string, Tracer.AttributeValue>;
+export declare const makeSpanScoped: (name: string, options?: {
+    readonly attributes?: Record<string, unknown>;
     readonly links?: ReadonlyArray<Tracer.SpanLink>;
     readonly parent?: Tracer.ParentSpan;
     readonly root?: boolean;
+    readonly sampled?: boolean;
     readonly context?: Context.Context<never>;
-}) => Layer.Layer<never, never, never>;
+}) => Effect<Scope.Scope, never, Tracer.Span>;
 /**
  * Create a new span for tracing, and automatically close it when the effect
  * completes.
@@ -3703,65 +3655,78 @@ export declare const setSpan: (name: string, options?: {
 export declare const useSpan: {
     <R, E, A>(name: string, evaluate: (span: Tracer.Span) => Effect<R, E, A>): Effect<R, E, A>;
     <R, E, A>(name: string, options: {
-        readonly attributes?: Record<string, Tracer.AttributeValue>;
+        readonly attributes?: Record<string, unknown>;
         readonly links?: ReadonlyArray<Tracer.SpanLink>;
         readonly parent?: Tracer.ParentSpan;
         readonly root?: boolean;
+        readonly sampled?: boolean;
         readonly context?: Context.Context<never>;
     }, evaluate: (span: Tracer.Span) => Effect<R, E, A>): Effect<R, E, A>;
 };
 /**
- * Create a new span for tracing, and automatically close it when the Scope
- * finalizes.
- *
- * The span is not added to the current span stack, so no child spans will be
- * created for it.
+ * Wraps the effect with a new span for tracing.
  *
  * @since 2.0.0
  * @category tracing
  */
-export declare const useSpanScoped: (name: string, options?: {
-    readonly attributes?: Record<string, Tracer.AttributeValue>;
-    readonly links?: ReadonlyArray<Tracer.SpanLink>;
-    readonly parent?: Tracer.ParentSpan;
-    readonly root?: boolean;
-    readonly context?: Context.Context<never>;
-}) => Effect<Scope.Scope, never, Tracer.Span>;
+export declare const withSpan: {
+    (name: string, options?: {
+        readonly attributes?: Record<string, unknown>;
+        readonly links?: ReadonlyArray<Tracer.SpanLink>;
+        readonly parent?: Tracer.ParentSpan;
+        readonly root?: boolean;
+        readonly sampled?: boolean;
+        readonly context?: Context.Context<never>;
+    }): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
+    <R, E, A>(self: Effect<R, E, A>, name: string, options?: {
+        readonly attributes?: Record<string, unknown>;
+        readonly links?: ReadonlyArray<Tracer.SpanLink>;
+        readonly parent?: Tracer.ParentSpan;
+        readonly root?: boolean;
+        readonly sampled?: boolean;
+        readonly context?: Context.Context<never>;
+    }): Effect<R, E, A>;
+};
 /**
  * Wraps the effect with a new span for tracing.
  *
+ * The span is ended when the Scope is finalized.
+ *
  * @since 2.0.0
  * @category tracing
  */
-export declare const withSpan: {
+export declare const withSpanScoped: {
     (name: string, options?: {
-        readonly attributes?: Record<string, Tracer.AttributeValue>;
+        readonly attributes?: Record<string, unknown>;
         readonly links?: ReadonlyArray<Tracer.SpanLink>;
         readonly parent?: Tracer.ParentSpan;
         readonly root?: boolean;
+        readonly sampled?: boolean;
         readonly context?: Context.Context<never>;
-    }): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
+    }): <R, E, A>(self: Effect<R, E, A>) => Effect<R | Scope.Scope, E, A>;
     <R, E, A>(self: Effect<R, E, A>, name: string, options?: {
-        readonly attributes?: Record<string, Tracer.AttributeValue>;
+        readonly attributes?: Record<string, unknown>;
         readonly links?: ReadonlyArray<Tracer.SpanLink>;
         readonly parent?: Tracer.ParentSpan;
         readonly root?: boolean;
+        readonly sampled?: boolean;
         readonly context?: Context.Context<never>;
-    }): Effect<R, E, A>;
+    }): Effect<Scope.Scope | R, E, A>;
 };
 /**
  * Create and add a span to the current span stack.
  *
- * The span is ended when the Scope is finalized.
+ * The span is ended & removed from the stack when the Scope is finalized.
  *
  * @since 2.0.0
  * @category tracing
  */
-export declare const withSpanScoped: (name: string, options?: {
-    readonly attributes?: Record<string, Tracer.AttributeValue>;
+export declare const setSpan: (name: string, options?: {
+    readonly attributes?: Record<string, unknown>;
     readonly links?: ReadonlyArray<Tracer.SpanLink>;
     readonly parent?: Tracer.ParentSpan;
     readonly root?: boolean;
+    readonly sampled?: boolean;
     readonly context?: Context.Context<never>;
 }) => Effect<Scope.Scope, never, void>;
 /**
@@ -3780,7 +3745,7 @@ export declare const withParentSpan: {
  * @since 2.0.0
  * @category tracing
  */
-export declare const withParentSpanScoped: (span: Tracer.ParentSpan) => Effect<Scope.Scope, never, void>;
+export declare const setParentSpan: (span: Tracer.ParentSpan) => Effect<Scope.Scope, never, void>;
 /**
  * Returns an effect that errors with `NoSuchElementException` if the value is
  * null or undefined, otherwise succeeds with the value.