effect 4.0.0-beta.4 → 4.0.0-beta.41

package/dist/References.js

@@ -10,9 +10,9 @@
  *
  * @since 4.0.0
  */
-import { constTrue, constUndefined } from "./Function.js";
-import { MaxOpsBeforeYield } from "./Scheduler.js";
-import * as ServiceMap from "./ServiceMap.js";
+import * as internalEffect from "./internal/effect.js";
+import * as references from "./internal/references.js";
+import { MaxOpsBeforeYield, PreventSchedulerYield } from "./Scheduler.js";
 import { CurrentTraceLevel, DisablePropagation, MinimumTraceLevel, Tracer } from "./Tracer.js";
 export {
 /**
@@ -35,6 +35,11 @@ MaxOpsBeforeYield,
  * @category references
  */
 MinimumTraceLevel,
+/**
+ * @since 4.0.0
+ * @category references
+ */
+PreventSchedulerYield,
 /**
  * @since 4.0.0
  * @category references
@@ -78,34 +83,95 @@ Tracer };
  * @category references
  * @since 4.0.0
  */
-export const CurrentConcurrency = /*#__PURE__*/ServiceMap.Reference("effect/References/CurrentConcurrency", {
-  defaultValue: () => "unbounded"
-});
-export {
+export const CurrentConcurrency = references.CurrentConcurrency;
 /**
- * Reference for the current scheduler implementation used by the Effect runtime.
- * Controls how Effects are scheduled and executed.
+ * Reference for managing log annotations that are automatically added to all log entries.
+ * These annotations provide contextual metadata that appears in every log message.
  *
  * @example
  * ```ts
- * import { Effect, References, Scheduler } from "effect"
+ * import { Console, Effect, References } from "effect"
  *
- * const customScheduling = Effect.gen(function*() {
- *   // Get current scheduler (default is MixedScheduler)
- *   const current = yield* References.Scheduler
- *   console.log(current) // MixedScheduler instance
+ * const logAnnotationExample = Effect.gen(function*() {
+ *   // Get current annotations (empty by default)
+ *   const current = yield* References.CurrentLogAnnotations
+ *   console.log(current) // {}
  *
- *   // Use a custom scheduler
+ *   // Run with custom log annotations
  *   yield* Effect.provideService(
  *     Effect.gen(function*() {
- *       const scheduler = yield* References.Scheduler
- *       console.log(scheduler) // Custom scheduler instance
+ *       const annotations = yield* References.CurrentLogAnnotations
+ *       console.log(annotations) // { requestId: "req-123", userId: "user-456", version: "1.0.0" }
  *
- *       // Effects will use the custom scheduler in this context
- *       yield* Effect.log("Using custom scheduler")
+ *       // All log entries will include these annotations
+ *       yield* Console.log("Starting operation")
+ *       yield* Console.info("Processing data")
  *     }),
- *     References.Scheduler,
- *     new Scheduler.MixedScheduler()
+ *     References.CurrentLogAnnotations,
+ *     {
+ *       requestId: "req-123",
+ *       userId: "user-456",
+ *       version: "1.0.0"
+ *     }
+ *   )
+ *
+ *   // Run with extended annotations
+ *   yield* Effect.provideService(
+ *     Effect.gen(function*() {
+ *       const extended = yield* References.CurrentLogAnnotations
+ *       console.log(extended) // { requestId: "req-123", userId: "user-456", version: "1.0.0", operation: "data-sync", timestamp: 1234567890 }
+ *
+ *       yield* Console.log("Operation completed with extended context")
+ *     }),
+ *     References.CurrentLogAnnotations,
+ *     {
+ *       requestId: "req-123",
+ *       userId: "user-456",
+ *       version: "1.0.0",
+ *       operation: "data-sync",
+ *       timestamp: 1234567890
+ *     }
+ *   )
+ * })
+ * ```
+ *
+ * @since 4.0.0
+ * @category references
+ */
+export const CurrentLogAnnotations = references.CurrentLogAnnotations;
+/**
+ * Reference for controlling the current log level for dynamic filtering.
+ *
+ * @example
+ * ```ts
+ * import { Console, Effect, References } from "effect"
+ *
+ * const dynamicLogging = Effect.gen(function*() {
+ *   // Get current log level (default is "Info")
+ *   const current = yield* References.CurrentLogLevel
+ *   console.log(current) // "Info"
+ *
+ *   // Set log level to Debug for detailed logging
+ *   yield* Effect.provideService(
+ *     Effect.gen(function*() {
+ *       const level = yield* References.CurrentLogLevel
+ *       console.log(level) // "Debug"
+ *       yield* Console.debug("This debug message will be shown")
+ *     }),
+ *     References.CurrentLogLevel,
+ *     "Debug"
+ *   )
+ *
+ *   // Change to Error level to reduce noise
+ *   yield* Effect.provideService(
+ *     Effect.gen(function*() {
+ *       const level = yield* References.CurrentLogLevel
+ *       console.log(level) // "Error"
+ *       yield* Console.info("This info message will be filtered out")
+ *       yield* Console.error("This error message will be shown")
+ *     }),
+ *     References.CurrentLogLevel,
+ *     "Error"
  *   )
  * })
  * ```
@@ -113,94 +179,157 @@ export {
  * @category references
  * @since 4.0.0
  */
-Scheduler } from "./Scheduler.js";
+export const CurrentLogLevel = references.CurrentLogLevel;
 /**
+ * Reference for managing log spans that track the duration and hierarchy of operations.
+ * Each span represents a labeled time period for performance analysis and debugging.
+ *
+ * @example
+ * ```ts
+ * import { Console, Effect, References } from "effect"
+ *
+ * const logSpanExample = Effect.gen(function*() {
+ *   // Get current spans (empty by default)
+ *   const current = yield* References.CurrentLogSpans
+ *   console.log(current.length) // 0
+ *
+ *   // Add a log span manually
+ *   const startTime = Date.now()
+ *   yield* Effect.provideService(
+ *     Effect.gen(function*() {
+ *       // Simulate some work
+ *       yield* Effect.sleep("100 millis")
+ *       yield* Console.log("Database operation in progress")
+ *
+ *       const spans = yield* References.CurrentLogSpans
+ *       console.log("Active spans:", spans.map(([label]) => label)) // ["database-connection"]
+ *     }),
+ *     References.CurrentLogSpans,
+ *     [["database-connection", startTime]]
+ *   )
+ *
+ *   // Add another span
+ *   yield* Effect.provideService(
+ *     Effect.gen(function*() {
+ *       const spans = yield* References.CurrentLogSpans
+ *       console.log("Active spans:", spans.map(([label]) => label)) // ["database-connection", "data-processing"]
+ *
+ *       yield* Console.log("Multiple operations in progress")
+ *     }),
+ *     References.CurrentLogSpans,
+ *     [
+ *       ["database-connection", startTime],
+ *       ["data-processing", Date.now()]
+ *     ]
+ *   )
+ *
+ *   // Clear spans when operations complete
+ *   yield* Effect.provideService(
+ *     Effect.gen(function*() {
+ *       const spans = yield* References.CurrentLogSpans
+ *       console.log("Active spans:", spans.length) // 0
+ *     }),
+ *     References.CurrentLogSpans,
+ *     []
+ *   )
+ * })
+ * ```
+ *
  * @since 4.0.0
  * @category references
  */
-export const CurrentStackFrame = /*#__PURE__*/ServiceMap.Reference("effect/References/CurrentStackFrame", {
-  defaultValue: constUndefined
-});
+export const CurrentLogSpans = references.CurrentLogSpans;
 /**
- * Reference for controlling whether tracing is enabled globally. When set to false,
- * spans will not be registered with the tracer and tracing overhead is minimized.
+ * @since 4.0.0
+ * @category references
+ */
+export const CurrentStackFrame = references.CurrentStackFrame;
+/**
+ * Reference for setting the minimum log level threshold. Log entries below this
+ * level will be filtered out completely.
  *
  * @example
  * ```ts
- * import { Effect, References } from "effect"
+ * import { Console, Effect, References } from "effect"
  *
- * const tracingControl = Effect.gen(function*() {
- *   // Check if tracing is enabled (default is true)
- *   const current = yield* References.TracerEnabled
- *   console.log(current) // true
+ * const configureMinimumLogging = Effect.gen(function*() {
+ *   // Get current minimum level (default is "Info")
+ *   const current = yield* References.MinimumLogLevel
+ *   console.log(current) // "Info"
  *
- *   // Disable tracing globally
+ *   // Set minimum level to Warn - Debug and Info will be filtered
  *   yield* Effect.provideService(
  *     Effect.gen(function*() {
- *       const isEnabled = yield* References.TracerEnabled
- *       console.log(isEnabled) // false
+ *       const minLevel = yield* References.MinimumLogLevel
+ *       console.log(minLevel) // "Warn"
  *
- *       // Spans will not be traced in this context
- *       yield* Effect.log("This will not be traced")
+ *       // These won't be processed at all
+ *       yield* Console.debug("Debug message") // Filtered out
+ *       yield* Console.info("Info message") // Filtered out
+ *
+ *       // These will be processed
+ *       yield* Console.warn("Warning message") // Shown
+ *       yield* Console.error("Error message") // Shown
  *     }),
- *     References.TracerEnabled,
- *     false
+ *     References.MinimumLogLevel,
+ *     "Warn"
  *   )
  *
- *   // Re-enable tracing
+ *   // Reset to default Info level
  *   yield* Effect.provideService(
  *     Effect.gen(function*() {
- *       const isEnabled = yield* References.TracerEnabled
- *       console.log(isEnabled) // true
+ *       const minLevel = yield* References.MinimumLogLevel
+ *       console.log(minLevel) // "Info"
  *
- *       // All subsequent spans will be traced
- *       yield* Effect.log("This will be traced")
+ *       // Now info messages will be processed
+ *       yield* Console.info("Info message") // Shown
  *     }),
- *     References.TracerEnabled,
- *     true
+ *     References.MinimumLogLevel,
+ *     "Info"
  *   )
  * })
  * ```
  *
- * @since 4.0.0
  * @category references
+ * @since 4.0.0
  */
-export const TracerEnabled = /*#__PURE__*/ServiceMap.Reference("effect/References/TracerEnabled", {
-  defaultValue: constTrue
-});
+export const MinimumLogLevel = references.MinimumLogLevel;
 /**
- * Reference for controlling whether trace timing is enabled globally. When set
- * to false, spans will not contain timing information (trace time will always
- * be set to zero).
+ * Reference for controlling whether tracing is enabled globally. When set to false,
+ * spans will not be registered with the tracer and tracing overhead is minimized.
  *
  * @example
  * ```ts
  * import { Effect, References } from "effect"
  *
  * const tracingControl = Effect.gen(function*() {
- *   // Check if trace timing is enabled (default is true)
- *   const current = yield* References.TracerTimingEnabled
+ *   // Check if tracing is enabled (default is true)
+ *   const current = yield* References.TracerEnabled
  *   console.log(current) // true
  *
- *   // Disable trace timing globally
+ *   // Disable tracing globally
  *   yield* Effect.provideService(
  *     Effect.gen(function*() {
- *       // Spans will not having timing information in this context
- *       const isEnabled = yield* References.TracerTimingEnabled
+ *       const isEnabled = yield* References.TracerEnabled
  *       console.log(isEnabled) // false
+ *
+ *       // Spans will not be traced in this context
+ *       yield* Effect.log("This will not be traced")
  *     }),
- *     References.TracerTimingEnabled,
+ *     References.TracerEnabled,
  *     false
  *   )
  *
- *   // Re-enable trace timing
+ *   // Re-enable tracing
  *   yield* Effect.provideService(
  *     Effect.gen(function*() {
- *       // Spans will have timing information in this context
- *       const isEnabled = yield* References.TracerTimingEnabled
+ *       const isEnabled = yield* References.TracerEnabled
  *       console.log(isEnabled) // true
+ *
+ *       // All subsequent spans will be traced
+ *       yield* Effect.log("This will be traced")
  *     }),
- *     References.TracerTimingEnabled,
+ *     References.TracerEnabled,
  *     true
  *   )
  * })
@@ -209,9 +338,7 @@ export const TracerEnabled = /*#__PURE__*/ServiceMap.Reference("effect/Reference
  * @since 4.0.0
  * @category references
  */
-export const TracerTimingEnabled = /*#__PURE__*/ServiceMap.Reference("effect/References/TracerTimingEnabled", {
-  defaultValue: constTrue
-});
+export const TracerEnabled = references.TracerEnabled;
 /**
  * Reference for managing span annotations that are automatically added to all new spans.
  * These annotations provide context and metadata that applies across multiple spans.
@@ -262,9 +389,7 @@ export const TracerTimingEnabled = /*#__PURE__*/ServiceMap.Reference("effect/Ref
  * @since 4.0.0
  * @category references
  */
-export const TracerSpanAnnotations = /*#__PURE__*/ServiceMap.Reference("effect/References/TracerSpanAnnotations", {
-  defaultValue: () => ({})
-});
+export const TracerSpanAnnotations = references.TracerSpanAnnotations;
 /**
  * Reference for managing span links that are automatically added to all new spans.
  * Span links connect related spans that are not in a parent-child relationship.
@@ -325,56 +450,41 @@ export const TracerSpanAnnotations = /*#__PURE__*/ServiceMap.Reference("effect/R
  * @since 4.0.0
  * @category references
  */
-export const TracerSpanLinks = /*#__PURE__*/ServiceMap.Reference("effect/References/TracerSpanLinks", {
-  defaultValue: () => []
-});
+export const TracerSpanLinks = references.TracerSpanLinks;
 /**
- * Reference for managing log annotations that are automatically added to all log entries.
- * These annotations provide contextual metadata that appears in every log message.
+ * Reference for controlling whether trace timing is enabled globally. When set
+ * to false, spans will not contain timing information (trace time will always
+ * be set to zero).
  *
  * @example
  * ```ts
- * import { Console, Effect, References } from "effect"
+ * import { Effect, References } from "effect"
  *
- * const logAnnotationExample = Effect.gen(function*() {
- *   // Get current annotations (empty by default)
- *   const current = yield* References.CurrentLogAnnotations
- *   console.log(current) // {}
+ * const tracingControl = Effect.gen(function*() {
+ *   // Check if trace timing is enabled (default is true)
+ *   const current = yield* References.TracerTimingEnabled
+ *   console.log(current) // true
  *
- *   // Run with custom log annotations
+ *   // Disable trace timing globally
  *   yield* Effect.provideService(
  *     Effect.gen(function*() {
- *       const annotations = yield* References.CurrentLogAnnotations
- *       console.log(annotations) // { requestId: "req-123", userId: "user-456", version: "1.0.0" }
- *
- *       // All log entries will include these annotations
- *       yield* Console.log("Starting operation")
- *       yield* Console.info("Processing data")
+ *       // Spans will not having timing information in this context
+ *       const isEnabled = yield* References.TracerTimingEnabled
+ *       console.log(isEnabled) // false
  *     }),
- *     References.CurrentLogAnnotations,
- *     {
- *       requestId: "req-123",
- *       userId: "user-456",
- *       version: "1.0.0"
- *     }
+ *     References.TracerTimingEnabled,
+ *     false
  *   )
  *
- *   // Run with extended annotations
+ *   // Re-enable trace timing
  *   yield* Effect.provideService(
  *     Effect.gen(function*() {
- *       const extended = yield* References.CurrentLogAnnotations
- *       console.log(extended) // { requestId: "req-123", userId: "user-456", version: "1.0.0", operation: "data-sync", timestamp: 1234567890 }
- *
- *       yield* Console.log("Operation completed with extended context")
+ *       // Spans will have timing information in this context
+ *       const isEnabled = yield* References.TracerTimingEnabled
+ *       console.log(isEnabled) // true
  *     }),
- *     References.CurrentLogAnnotations,
- *     {
- *       requestId: "req-123",
- *       userId: "user-456",
- *       version: "1.0.0",
- *       operation: "data-sync",
- *       timestamp: 1234567890
- *     }
+ *     References.TracerTimingEnabled,
+ *     true
  *   )
  * })
  * ```
@@ -382,173 +492,56 @@ export const TracerSpanLinks = /*#__PURE__*/ServiceMap.Reference("effect/Referen
  * @since 4.0.0
  * @category references
  */
-export const CurrentLogAnnotations = /*#__PURE__*/ServiceMap.Reference("effect/References/CurrentLogAnnotations", {
-  defaultValue: () => ({})
-});
+export const TracerTimingEnabled = references.TracerTimingEnabled;
 /**
- * Reference for controlling the current log level for dynamic filtering.
- *
- * @example
- * ```ts
- * import { Console, Effect, References } from "effect"
- *
- * const dynamicLogging = Effect.gen(function*() {
- *   // Get current log level (default is "Info")
- *   const current = yield* References.CurrentLogLevel
- *   console.log(current) // "Info"
- *
- *   // Set log level to Debug for detailed logging
- *   yield* Effect.provideService(
- *     Effect.gen(function*() {
- *       const level = yield* References.CurrentLogLevel
- *       console.log(level) // "Debug"
- *       yield* Console.debug("This debug message will be shown")
- *     }),
- *     References.CurrentLogLevel,
- *     "Debug"
- *   )
- *
- *   // Change to Error level to reduce noise
- *   yield* Effect.provideService(
- *     Effect.gen(function*() {
- *       const level = yield* References.CurrentLogLevel
- *       console.log(level) // "Error"
- *       yield* Console.info("This info message will be filtered out")
- *       yield* Console.error("This error message will be shown")
- *     }),
- *     References.CurrentLogLevel,
- *     "Error"
- *   )
- * })
- * ```
+ * The log level for unhandled errors. This reference allows you to set the log
+ * level for unhandled errors that occur during Effect execution.
  *
  * @category references
  * @since 4.0.0
  */
-export const CurrentLogLevel = /*#__PURE__*/ServiceMap.Reference("effect/References/CurrentLogLevel", {
-  defaultValue: () => "Info"
-});
+export const UnhandledLogLevel = references.UnhandledLogLevel;
 /**
- * Reference for setting the minimum log level threshold. Log entries below this
- * level will be filtered out completely.
- *
- * @example
- * ```ts
- * import { Console, Effect, References } from "effect"
- *
- * const configureMinimumLogging = Effect.gen(function*() {
- *   // Get current minimum level (default is "Info")
- *   const current = yield* References.MinimumLogLevel
- *   console.log(current) // "Info"
- *
- *   // Set minimum level to Warn - Debug and Info will be filtered
- *   yield* Effect.provideService(
- *     Effect.gen(function*() {
- *       const minLevel = yield* References.MinimumLogLevel
- *       console.log(minLevel) // "Warn"
- *
- *       // These won't be processed at all
- *       yield* Console.debug("Debug message") // Filtered out
- *       yield* Console.info("Info message") // Filtered out
- *
- *       // These will be processed
- *       yield* Console.warn("Warning message") // Shown
- *       yield* Console.error("Error message") // Shown
- *     }),
- *     References.MinimumLogLevel,
- *     "Warn"
- *   )
- *
- *   // Reset to default Info level
- *   yield* Effect.provideService(
- *     Effect.gen(function*() {
- *       const minLevel = yield* References.MinimumLogLevel
- *       console.log(minLevel) // "Info"
- *
- *       // Now info messages will be processed
- *       yield* Console.info("Info message") // Shown
- *     }),
- *     References.MinimumLogLevel,
- *     "Info"
- *   )
- * })
- * ```
- *
- * @category references
  * @since 4.0.0
+ * @category references
  */
-export const MinimumLogLevel = /*#__PURE__*/ServiceMap.Reference("effect/References/MinimumLogLevel", {
-  defaultValue: () => "Info"
-});
+export const CurrentLoggers = internalEffect.CurrentLoggers;
 /**
- * The log level for unhandled errors. This reference allows you to set the log
- * level for unhandled errors that occur during Effect execution.
- *
- * @category references
  * @since 4.0.0
+ * @category references
  */
-export const UnhandledLogLevel = /*#__PURE__*/ServiceMap.Reference("effect/References/UnhandledLogLevel", {
-  defaultValue: () => "Error"
-});
+export const LogToStderr = internalEffect.LogToStderr;
+export {
 /**
- * Reference for managing log spans that track the duration and hierarchy of operations.
- * Each span represents a labeled time period for performance analysis and debugging.
+ * Reference for the current scheduler implementation used by the Effect runtime.
+ * Controls how Effects are scheduled and executed.
  *
  * @example
  * ```ts
- * import { Console, Effect, References } from "effect"
- *
- * const logSpanExample = Effect.gen(function*() {
- *   // Get current spans (empty by default)
- *   const current = yield* References.CurrentLogSpans
- *   console.log(current.length) // 0
- *
- *   // Add a log span manually
- *   const startTime = Date.now()
- *   yield* Effect.provideService(
- *     Effect.gen(function*() {
- *       // Simulate some work
- *       yield* Effect.sleep("100 millis")
- *       yield* Console.log("Database operation in progress")
+ * import { Effect, References, Scheduler } from "effect"
  *
- *       const spans = yield* References.CurrentLogSpans
- *       console.log("Active spans:", spans.map(([label]) => label)) // ["database-connection"]
- *     }),
- *     References.CurrentLogSpans,
- *     [["database-connection", startTime]]
- *   )
+ * const customScheduling = Effect.gen(function*() {
+ *   // Get current scheduler (default is MixedScheduler)
+ *   const current = yield* References.Scheduler
+ *   console.log(current) // MixedScheduler instance
  *
- *   // Add another span
+ *   // Use a custom scheduler
  *   yield* Effect.provideService(
  *     Effect.gen(function*() {
- *       const spans = yield* References.CurrentLogSpans
- *       console.log("Active spans:", spans.map(([label]) => label)) // ["database-connection", "data-processing"]
- *
- *       yield* Console.log("Multiple operations in progress")
- *     }),
- *     References.CurrentLogSpans,
- *     [
- *       ["database-connection", startTime],
- *       ["data-processing", Date.now()]
- *     ]
- *   )
+ *       const scheduler = yield* References.Scheduler
+ *       console.log(scheduler) // Custom scheduler instance
  *
- *   // Clear spans when operations complete
- *   yield* Effect.provideService(
- *     Effect.gen(function*() {
- *       const spans = yield* References.CurrentLogSpans
- *       console.log("Active spans:", spans.length) // 0
+ *       // Effects will use the custom scheduler in this context
+ *       yield* Effect.log("Using custom scheduler")
  *     }),
- *     References.CurrentLogSpans,
- *     []
+ *     References.Scheduler,
+ *     new Scheduler.MixedScheduler()
  *   )
  * })
  * ```
  *
- * @since 4.0.0
  * @category references
+ * @since 4.0.0
  */
-export const CurrentLogSpans = /*#__PURE__*/ServiceMap.Reference("effect/References/CurrentLogSpans", {
-  defaultValue: () => []
-});
+Scheduler } from "./Scheduler.js";
 //# sourceMappingURL=References.js.map

package/dist/References.js.map

@@ -1 +1 @@
-{"version":3,"file":"References.js","names":["constTrue","constUndefined","MaxOpsBeforeYield","ServiceMap","CurrentTraceLevel","DisablePropagation","MinimumTraceLevel","Tracer","CurrentConcurrency","Reference","defaultValue","Scheduler","CurrentStackFrame","TracerEnabled","TracerTimingEnabled","TracerSpanAnnotations","TracerSpanLinks","CurrentLogAnnotations","CurrentLogLevel","MinimumLogLevel","UnhandledLogLevel","CurrentLogSpans"],"sources":["../src/References.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;;;;;;;;AAYA,SAASA,SAAS,EAAEC,cAAc,QAAQ,eAAe;AAGzD,SAASC,iBAAiB,QAAQ,gBAAgB;AAClD,OAAO,KAAKC,UAAU,MAAM,iBAAiB;AAC7C,SAASC,iBAAiB,EAAEC,kBAAkB,EAAEC,iBAAiB,EAAiBC,MAAM,QAAQ,aAAa;AAE7G;AACE;;;;AAIAH,iBAAiB;AACjB;;;;AAIAC,kBAAkB;AAClB;;;;AAIAH,iBAAiB;AACjB;;;;AAIAI,iBAAiB;AACjB;;;;AAIAC,MAAM;AAGR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,OAAO,MAAMC,kBAAkB,gBAAGL,UAAU,CAACM,SAAS,CAAuB,sCAAsC,EAAE;EACnHC,YAAY,EAAEA,CAAA,KAAM;CACrB,CAAC;AAEF;AACE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BAC,SAAS,QACJ,gBAAgB;AAYvB;;;;AAIA,OAAO,MAAMC,iBAAiB,gBAAGT,UAAU,CAACM,SAAS,CAAyB,qCAAqC,EAAE;EACnHC,YAAY,EAAET;CACf,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CA,OAAO,MAAMY,aAAa,gBAAGV,UAAU,CAACM,SAAS,CAAU,iCAAiC,EAAE;EAC5FC,YAAY,EAAEV;CACf,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,OAAO,MAAMc,mBAAmB,gBAAGX,UAAU,CAACM,SAAS,CAAU,uCAAuC,EAAE;EACxGC,YAAY,EAAEV;CACf,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDA,OAAO,MAAMe,qBAAqB,gBAAGZ,UAAU,CAACM,SAAS,CACvD,yCAAyC,EACzC;EAAEC,YAAY,EAAEA,CAAA,MAAO,EAAE;AAAC,CAAE,CAC7B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4DA,OAAO,MAAMM,eAAe,gBAAGb,UAAU,CAACM,SAAS,CAA0B,mCAAmC,EAAE;EAChHC,YAAY,EAAEA,CAAA,KAAM;CACrB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsDA,OAAO,MAAMO,qBAAqB,gBAAGd,UAAU,CAACM,SAAS,CACvD,yCAAyC,EACzC;EAAEC,YAAY,EAAEA,CAAA,MAAO,EAAE;AAAC,CAAE,CAC7B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,OAAO,MAAMQ,eAAe,gBAAmCf,UAAU,CAACM,SAAS,CACjF,mCAAmC,EACnC;EAAEC,YAAY,EAAEA,CAAA,KAAM;AAAM,CAAE,CAC/B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDA,OAAO,MAAMS,eAAe,gBAAGhB,UAAU,CAACM,SAAS,CAEjD,mCAAmC,EAAE;EAAEC,YAAY,EAAEA,CAAA,KAAM;AAAM,CAAE,CAAC;AAEtE;;;;;;;AAOA,OAAO,MAAMU,iBAAiB,gBAA+CjB,UAAU,CAACM,SAAS,CAC/F,qCAAqC,EACrC;EAAEC,YAAY,EAAEA,CAAA,KAA4B;AAAO,CAAE,CACtD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0DA,OAAO,MAAMW,eAAe,gBAAGlB,UAAU,CAACM,SAAS,CAEjD,mCAAmC,EAAE;EAAEC,YAAY,EAAEA,CAAA,KAAM;AAAE,CAAE,CAAC","ignoreList":[]}
+{"version":3,"file":"References.js","names":["internalEffect","references","MaxOpsBeforeYield","PreventSchedulerYield","CurrentTraceLevel","DisablePropagation","MinimumTraceLevel","Tracer","CurrentConcurrency","CurrentLogAnnotations","CurrentLogLevel","CurrentLogSpans","CurrentStackFrame","MinimumLogLevel","TracerEnabled","TracerSpanAnnotations","TracerSpanLinks","TracerTimingEnabled","UnhandledLogLevel","CurrentLoggers","LogToStderr","Scheduler"],"sources":["../src/References.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;;;;;;;;AAYA,OAAO,KAAKA,cAAc,MAAM,sBAAsB;AACtD,OAAO,KAAKC,UAAU,MAAM,0BAA0B;AAItD,SAASC,iBAAiB,EAAEC,qBAAqB,QAAQ,gBAAgB;AAEzE,SAASC,iBAAiB,EAAEC,kBAAkB,EAAEC,iBAAiB,EAAiBC,MAAM,QAAQ,aAAa;AAE7G;AACE;;;;AAIAH,iBAAiB;AACjB;;;;AAIAC,kBAAkB;AAClB;;;;AAIAH,iBAAiB;AACjB;;;;AAIAI,iBAAiB;AACjB;;;;AAIAH,qBAAqB;AACrB;;;;AAIAI,MAAM;AAGR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,OAAO,MAAMC,kBAAkB,GAA+CP,UAAU,CAACO,kBAAkB;AAE3G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsDA,OAAO,MAAMC,qBAAqB,GAChCR,UAAU,CAACQ,qBAAqB;AAElC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,OAAO,MAAMC,eAAe,GAAmCT,UAAU,CAACS,eAAe;AAEzF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0DA,OAAO,MAAMC,eAAe,GAC1BV,UAAU,CAACU,eAAe;AAE5B;;;;AAIA,OAAO,MAAMC,iBAAiB,GAAiDX,UAAU,CAACW,iBAAiB;AAE3G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDA,OAAO,MAAMC,eAAe,GAAmCZ,UAAU,CAACY,eAAe;AAEzF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CA,OAAO,MAAMC,aAAa,GAAkCb,UAAU,CAACa,aAAa;AAEpF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDA,OAAO,MAAMC,qBAAqB,GAChCd,UAAU,CAACc,qBAAqB;AAElC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4DA,OAAO,MAAMC,eAAe,GAAkDf,UAAU,CAACe,eAAe;AAExG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,OAAO,MAAMC,mBAAmB,GAAkChB,UAAU,CAACgB,mBAAmB;AAEhG;;;;;;;AAOA,OAAO,MAAMC,iBAAiB,GAA+CjB,UAAU,CAACiB,iBAAiB;AAYzG;;;;AAIA,OAAO,MAAMC,cAAc,GAA4DnB,cAAc,CAACmB,cAAc;AAEpH;;;;AAIA,OAAO,MAAMC,WAAW,GAAkCpB,cAAc,CAACoB,WAAW;AAEpF;AACE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BAC,SAAS,QACJ,gBAAgB","ignoreList":[]}

package/dist/Request.d.ts

@@ -79,7 +79,7 @@ export interface Variance<out A, out E, out R> {
  * @category models
  */
 export interface Constructor<R extends Request<any, any, any>, T extends keyof R = never> {
-    (args: Omit<R, T | keyof (Variance<any, any, any>)>): R;
+    (args: Types.VoidIfEmpty<Types.Simplify<Omit<R, T | keyof (Variance<any, any, any>)>>>): R;
 }
 /**
  * A utility type to extract the error type from a `Request`.