(key: string, value: unknown): <A, E, R>(
effect: Effect<A, E, R>
) => Effect<A, E, R>
(values: Record<string, unknown>): <A, E, R>(
effect: Effect<A, E, R>
) => Effect<A, E, R>
<A, E, R>(effect: Effect<A, E, R>, key: string, value: unknown): Effect<
A,
E,
R
>
<A, E, R>(
effect: Effect<A, E, R>,
values: Record<string, unknown>
): Effect<A, E, R>Adds an annotation to each log line in this effect.
Example (Adding log annotations)
import { Effect } from "effect"
const program = Effect.gen(function*() {
yield* Effect.log("Starting operation")
yield* Effect.log("Processing data")
yield* Effect.log("Operation completed")
})
// Add annotations to all log messages
const annotatedProgram = Effect.annotateLogs(program, {
userId: "user123",
operation: "data-processing"
})
// Also supports single key-value annotations
const singleAnnotated = Effect.annotateLogs(program, "requestId", "req-456")
Effect.runPromise(annotatedProgram)
// All log messages will include the userId and operation annotationsexport const const annotateLogs: {
(key: string, value: unknown): <A, E, R>(
effect: Effect<A, E, R>
) => Effect<A, E, R>
(values: Record<string, unknown>): <A, E, R>(
effect: Effect<A, E, R>
) => Effect<A, E, R>
} & {
<A, E, R>(
effect: Effect<A, E, R>,
key: string,
value: unknown
): Effect<A, E, R>
<A, E, R>(
effect: Effect<A, E, R>,
values: Record<string, unknown>
): Effect<A, E, R>
}
Adds an annotation to each log line in this effect.
Example (Adding log annotations)
import { Effect } from "effect"
const program = Effect.gen(function*() {
yield* Effect.log("Starting operation")
yield* Effect.log("Processing data")
yield* Effect.log("Operation completed")
})
// Add annotations to all log messages
const annotatedProgram = Effect.annotateLogs(program, {
userId: "user123",
operation: "data-processing"
})
// Also supports single key-value annotations
const singleAnnotated = Effect.annotateLogs(program, "requestId", "req-456")
Effect.runPromise(annotatedProgram)
// All log messages will include the userId and operation annotations
annotateLogs = dual<{
(key: string, value: unknown): <A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, R>;
(values: Record<string, unknown>): <A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, R>;
}, {
<A, E, R>(effect: Effect<A, E, R>, key: string, value: unknown): Effect<A, E, R>;
<A, E, R>(effect: Effect<A, E, R>, values: Record<string, unknown>): Effect<A, E, R>;
}>(isDataFirst: (args: IArguments) => boolean, body: {
<A, E, R>(effect: Effect<A, E, R>, key: string, value: unknown): Effect<A, E, R>;
<A, E, R>(effect: Effect<A, E, R>, values: Record<string, unknown>): Effect<A, E, R>;
}): {
(key: string, value: unknown): <A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, R>;
(values: Record<string, unknown>): <A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, R>;
} & {
<A, E, R>(effect: Effect<A, E, R>, key: string, value: unknown): Effect<A, E, R>;
<A, E, R>(effect: Effect<A, E, R>, values: Record<string, unknown>): Effect<A, E, R>;
} (+1 overload)
Creates a function that can be called in data-first style or data-last
(pipe-friendly) style.
When to use
Use to expose one implementation through both direct and pipe-friendly
call styles.
Details
Pass either the arity of the uncurried function or a predicate that decides
whether the current call is data-first. Arity is the common case. Use a
predicate when optional arguments make arity ambiguous.
Example (Selecting data-first or data-last style by arity)
import { Function, pipe } from "effect"
const sum = Function.dual<
(that: number) => (self: number) => number,
(self: number, that: number) => number
>(2, (self, that) => self + that)
console.log(sum(2, 3)) // 5
console.log(pipe(2, sum(3))) // 5
Example (Defining overloads with call signatures)
import { Function, pipe } from "effect"
const sum: {
(that: number): (self: number) => number
(self: number, that: number): number
} = Function.dual(2, (self: number, that: number): number => self + that)
console.log(sum(2, 3)) // 5
console.log(pipe(2, sum(3))) // 5
Example (Selecting data-first or data-last style with a predicate)
import { Function, pipe } from "effect"
const sum = Function.dual<
(that: number) => (self: number) => number,
(self: number, that: number) => number
>(
(args) => args.length === 2,
(self, that) => self + that
)
console.log(sum(2, 3)) // 5
console.log(pipe(2, sum(3))) // 5
dual<
{
(
key: stringkey: string,
value: unknownvalue: unknown
): <function (type parameter) A in <A, E, R>(effect: Effect<A, E, R>): Effect<A, E, R>A, function (type parameter) E in <A, E, R>(effect: Effect<A, E, R>): Effect<A, E, R>E, function (type parameter) R in <A, E, R>(effect: Effect<A, E, R>): Effect<A, E, R>R>(effect: Effect<A, E, R>(parameter) effect: {
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
toString: () => string;
toJSON: () => unknown;
}
interface Effect<out A, out E = never, out R = never>The Effect interface defines a value that lazily describes a workflow or
job. The workflow requires some context R, and may fail with an error of
type E, or succeed with a value of type A.
When to use
Use when you need to represent a lazy, composable workflow that can require
services, fail with a typed error, or succeed with a typed value.
Details
Effect values model resourceful interaction with the outside world,
including synchronous, asynchronous, concurrent, and parallel interaction.
They use a fiber-based concurrency model, with built-in support for
scheduling, fine-grained interruption, structured concurrency, and high
scalability.
To run an Effect value, you need a Runtime, which is a type that is
capable of executing Effect values.
Effect<function (type parameter) A in <A, E, R>(effect: Effect<A, E, R>): Effect<A, E, R>A, function (type parameter) E in <A, E, R>(effect: Effect<A, E, R>): Effect<A, E, R>E, function (type parameter) R in <A, E, R>(effect: Effect<A, E, R>): Effect<A, E, R>R>) => interface Effect<out A, out E = never, out R = never>The Effect interface defines a value that lazily describes a workflow or
job. The workflow requires some context R, and may fail with an error of
type E, or succeed with a value of type A.
When to use
Use when you need to represent a lazy, composable workflow that can require
services, fail with a typed error, or succeed with a typed value.
Details
Effect values model resourceful interaction with the outside world,
including synchronous, asynchronous, concurrent, and parallel interaction.
They use a fiber-based concurrency model, with built-in support for
scheduling, fine-grained interruption, structured concurrency, and high
scalability.
To run an Effect value, you need a Runtime, which is a type that is
capable of executing Effect values.
Effect<function (type parameter) A in <A, E, R>(effect: Effect<A, E, R>): Effect<A, E, R>A, function (type parameter) E in <A, E, R>(effect: Effect<A, E, R>): Effect<A, E, R>E, function (type parameter) R in <A, E, R>(effect: Effect<A, E, R>): Effect<A, E, R>R>
(
values: Record<string, unknown>values: type Record<K extends keyof any, T> = {
[P in K]: T
}
Construct a type with a set of properties K of type T
Record<string, unknown>
): <function (type parameter) A in <A, E, R>(effect: Effect<A, E, R>): Effect<A, E, R>A, function (type parameter) E in <A, E, R>(effect: Effect<A, E, R>): Effect<A, E, R>E, function (type parameter) R in <A, E, R>(effect: Effect<A, E, R>): Effect<A, E, R>R>(effect: Effect<A, E, R>(parameter) effect: {
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
toString: () => string;
toJSON: () => unknown;
}
interface Effect<out A, out E = never, out R = never>The Effect interface defines a value that lazily describes a workflow or
job. The workflow requires some context R, and may fail with an error of
type E, or succeed with a value of type A.
When to use
Use when you need to represent a lazy, composable workflow that can require
services, fail with a typed error, or succeed with a typed value.
Details
Effect values model resourceful interaction with the outside world,
including synchronous, asynchronous, concurrent, and parallel interaction.
They use a fiber-based concurrency model, with built-in support for
scheduling, fine-grained interruption, structured concurrency, and high
scalability.
To run an Effect value, you need a Runtime, which is a type that is
capable of executing Effect values.
Effect<function (type parameter) A in <A, E, R>(effect: Effect<A, E, R>): Effect<A, E, R>A, function (type parameter) E in <A, E, R>(effect: Effect<A, E, R>): Effect<A, E, R>E, function (type parameter) R in <A, E, R>(effect: Effect<A, E, R>): Effect<A, E, R>R>) => interface Effect<out A, out E = never, out R = never>The Effect interface defines a value that lazily describes a workflow or
job. The workflow requires some context R, and may fail with an error of
type E, or succeed with a value of type A.
When to use
Use when you need to represent a lazy, composable workflow that can require
services, fail with a typed error, or succeed with a typed value.
Details
Effect values model resourceful interaction with the outside world,
including synchronous, asynchronous, concurrent, and parallel interaction.
They use a fiber-based concurrency model, with built-in support for
scheduling, fine-grained interruption, structured concurrency, and high
scalability.
To run an Effect value, you need a Runtime, which is a type that is
capable of executing Effect values.
Effect<function (type parameter) A in <A, E, R>(effect: Effect<A, E, R>): Effect<A, E, R>A, function (type parameter) E in <A, E, R>(effect: Effect<A, E, R>): Effect<A, E, R>E, function (type parameter) R in <A, E, R>(effect: Effect<A, E, R>): Effect<A, E, R>R>
},
{
<function (type parameter) A in <A, E, R>(effect: Effect<A, E, R>, key: string, value: unknown): Effect<A, E, R>A, function (type parameter) E in <A, E, R>(effect: Effect<A, E, R>, key: string, value: unknown): Effect<A, E, R>E, function (type parameter) R in <A, E, R>(effect: Effect<A, E, R>, key: string, value: unknown): Effect<A, E, R>R>(
effect: Effect<A, E, R>(parameter) effect: {
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
toString: () => string;
toJSON: () => unknown;
}
interface Effect<out A, out E = never, out R = never>The Effect interface defines a value that lazily describes a workflow or
job. The workflow requires some context R, and may fail with an error of
type E, or succeed with a value of type A.
When to use
Use when you need to represent a lazy, composable workflow that can require
services, fail with a typed error, or succeed with a typed value.
Details
Effect values model resourceful interaction with the outside world,
including synchronous, asynchronous, concurrent, and parallel interaction.
They use a fiber-based concurrency model, with built-in support for
scheduling, fine-grained interruption, structured concurrency, and high
scalability.
To run an Effect value, you need a Runtime, which is a type that is
capable of executing Effect values.
Effect<function (type parameter) A in <A, E, R>(effect: Effect<A, E, R>, key: string, value: unknown): Effect<A, E, R>A, function (type parameter) E in <A, E, R>(effect: Effect<A, E, R>, key: string, value: unknown): Effect<A, E, R>E, function (type parameter) R in <A, E, R>(effect: Effect<A, E, R>, key: string, value: unknown): Effect<A, E, R>R>,
key: stringkey: string,
value: unknownvalue: unknown
): interface Effect<out A, out E = never, out R = never>The Effect interface defines a value that lazily describes a workflow or
job. The workflow requires some context R, and may fail with an error of
type E, or succeed with a value of type A.
When to use
Use when you need to represent a lazy, composable workflow that can require
services, fail with a typed error, or succeed with a typed value.
Details
Effect values model resourceful interaction with the outside world,
including synchronous, asynchronous, concurrent, and parallel interaction.
They use a fiber-based concurrency model, with built-in support for
scheduling, fine-grained interruption, structured concurrency, and high
scalability.
To run an Effect value, you need a Runtime, which is a type that is
capable of executing Effect values.
Effect<function (type parameter) A in <A, E, R>(effect: Effect<A, E, R>, key: string, value: unknown): Effect<A, E, R>A, function (type parameter) E in <A, E, R>(effect: Effect<A, E, R>, key: string, value: unknown): Effect<A, E, R>E, function (type parameter) R in <A, E, R>(effect: Effect<A, E, R>, key: string, value: unknown): Effect<A, E, R>R>
<function (type parameter) A in <A, E, R>(effect: Effect<A, E, R>, values: Record<string, unknown>): Effect<A, E, R>A, function (type parameter) E in <A, E, R>(effect: Effect<A, E, R>, values: Record<string, unknown>): Effect<A, E, R>E, function (type parameter) R in <A, E, R>(effect: Effect<A, E, R>, values: Record<string, unknown>): Effect<A, E, R>R>(
effect: Effect<A, E, R>(parameter) effect: {
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
toString: () => string;
toJSON: () => unknown;
}
interface Effect<out A, out E = never, out R = never>The Effect interface defines a value that lazily describes a workflow or
job. The workflow requires some context R, and may fail with an error of
type E, or succeed with a value of type A.
When to use
Use when you need to represent a lazy, composable workflow that can require
services, fail with a typed error, or succeed with a typed value.
Details
Effect values model resourceful interaction with the outside world,
including synchronous, asynchronous, concurrent, and parallel interaction.
They use a fiber-based concurrency model, with built-in support for
scheduling, fine-grained interruption, structured concurrency, and high
scalability.
To run an Effect value, you need a Runtime, which is a type that is
capable of executing Effect values.
Effect<function (type parameter) A in <A, E, R>(effect: Effect<A, E, R>, values: Record<string, unknown>): Effect<A, E, R>A, function (type parameter) E in <A, E, R>(effect: Effect<A, E, R>, values: Record<string, unknown>): Effect<A, E, R>E, function (type parameter) R in <A, E, R>(effect: Effect<A, E, R>, values: Record<string, unknown>): Effect<A, E, R>R>,
values: Record<string, unknown>values: type Record<K extends keyof any, T> = {
[P in K]: T
}
Construct a type with a set of properties K of type T
Record<string, unknown>
): interface Effect<out A, out E = never, out R = never>The Effect interface defines a value that lazily describes a workflow or
job. The workflow requires some context R, and may fail with an error of
type E, or succeed with a value of type A.
When to use
Use when you need to represent a lazy, composable workflow that can require
services, fail with a typed error, or succeed with a typed value.
Details
Effect values model resourceful interaction with the outside world,
including synchronous, asynchronous, concurrent, and parallel interaction.
They use a fiber-based concurrency model, with built-in support for
scheduling, fine-grained interruption, structured concurrency, and high
scalability.
To run an Effect value, you need a Runtime, which is a type that is
capable of executing Effect values.
Effect<function (type parameter) A in <A, E, R>(effect: Effect<A, E, R>, values: Record<string, unknown>): Effect<A, E, R>A, function (type parameter) E in <A, E, R>(effect: Effect<A, E, R>, values: Record<string, unknown>): Effect<A, E, R>E, function (type parameter) R in <A, E, R>(effect: Effect<A, E, R>, values: Record<string, unknown>): Effect<A, E, R>R>
}
>(
(args: IArgumentsargs) => const isEffect: (
u: unknown
) => u is Effect<any, any, any>
Checks whether a value is an Effect.
Example (Checking whether a value is an Effect)
import { Effect } from "effect"
console.log(Effect.isEffect(Effect.succeed(1))) // true
console.log(Effect.isEffect("hello")) // false
isEffect(args: IArgumentsargs[0]),
<function (type parameter) A in <A, E, R>(effect: Effect<A, E, R>, ...args: [Record<string, unknown>] | [key: string, value: unknown]): Effect<A, E, R>A, function (type parameter) E in <A, E, R>(effect: Effect<A, E, R>, ...args: [Record<string, unknown>] | [key: string, value: unknown]): Effect<A, E, R>E, function (type parameter) R in <A, E, R>(effect: Effect<A, E, R>, ...args: [Record<string, unknown>] | [key: string, value: unknown]): Effect<A, E, R>R>(
effect: Effect<A, E, R>(parameter) effect: {
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
toString: () => string;
toJSON: () => unknown;
}
interface Effect<out A, out E = never, out R = never>The Effect interface defines a value that lazily describes a workflow or
job. The workflow requires some context R, and may fail with an error of
type E, or succeed with a value of type A.
When to use
Use when you need to represent a lazy, composable workflow that can require
services, fail with a typed error, or succeed with a typed value.
Details
Effect values model resourceful interaction with the outside world,
including synchronous, asynchronous, concurrent, and parallel interaction.
They use a fiber-based concurrency model, with built-in support for
scheduling, fine-grained interruption, structured concurrency, and high
scalability.
To run an Effect value, you need a Runtime, which is a type that is
capable of executing Effect values.
Effect<function (type parameter) A in <A, E, R>(effect: Effect<A, E, R>, ...args: [Record<string, unknown>] | [key: string, value: unknown]): Effect<A, E, R>A, function (type parameter) E in <A, E, R>(effect: Effect<A, E, R>, ...args: [Record<string, unknown>] | [key: string, value: unknown]): Effect<A, E, R>E, function (type parameter) R in <A, E, R>(effect: Effect<A, E, R>, ...args: [Record<string, unknown>] | [key: string, value: unknown]): Effect<A, E, R>R>,
...args: | [Record<string, unknown>]
| [key: string, value: unknown]
type Record<K extends keyof any, T> = {
[P in K]: T
}
Construct a type with a set of properties K of type T
Record<string, unknown>] | [stringkey: string, unknownvalue: unknown]
): interface Effect<out A, out E = never, out R = never>The Effect interface defines a value that lazily describes a workflow or
job. The workflow requires some context R, and may fail with an error of
type E, or succeed with a value of type A.
When to use
Use when you need to represent a lazy, composable workflow that can require
services, fail with a typed error, or succeed with a typed value.
Details
Effect values model resourceful interaction with the outside world,
including synchronous, asynchronous, concurrent, and parallel interaction.
They use a fiber-based concurrency model, with built-in support for
scheduling, fine-grained interruption, structured concurrency, and high
scalability.
To run an Effect value, you need a Runtime, which is a type that is
capable of executing Effect values.
Effect<function (type parameter) A in <A, E, R>(effect: Effect<A, E, R>, ...args: [Record<string, unknown>] | [key: string, value: unknown]): Effect<A, E, R>A, function (type parameter) E in <A, E, R>(effect: Effect<A, E, R>, ...args: [Record<string, unknown>] | [key: string, value: unknown]): Effect<A, E, R>E, function (type parameter) R in <A, E, R>(effect: Effect<A, E, R>, ...args: [Record<string, unknown>] | [key: string, value: unknown]): Effect<A, E, R>R> =>
import internalinternal.const updateService: {
<I, A>(
service: Context.Key<I, A>,
f: (value: A) => A
): <XA, E, R>(
self: Effect.Effect<XA, E, R>
) => Effect.Effect<XA, E, R | I>
<XA, E, R, I, A>(
self: Effect.Effect<XA, E, R>,
service: Context.Key<I, A>,
f: (value: A) => A
): Effect.Effect<XA, E, R | I>
}
effect: Effect<A, E, R>(parameter) effect: {
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
toString: () => string;
toJSON: () => unknown;
}
const CurrentLogAnnotations: Context.Reference<
ReadonlyRecord<string, unknown>
>
(alias) const CurrentLogAnnotations: {
defaultValue: () => Shape;
of: (this: void, self: ReadonlyRecord<string, unknown>) => ReadonlyRecord<string, unknown>;
context: (self: ReadonlyRecord<string, unknown>) => Context.Context<never>;
use: (f: (service: ReadonlyRecord<string, unknown>) => Effect<A, E, R>) => Effect<A, E, R>;
useSync: (f: (service: ReadonlyRecord<string, unknown>) => A) => Effect<A, never, never>;
Identifier: Identifier;
Service: Shape;
key: string;
stack: string | undefined;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
toString: () => string;
toJSON: () => unknown;
}
Context reference for managing log annotations that are automatically added to all log entries.
These annotations provide contextual metadata that appears in every log message.
When to use
Use to attach shared contextual metadata to every log entry emitted in the
current context.
Example (Managing log annotations)
import { Console, Effect, References } from "effect"
const logAnnotationExample = Effect.gen(function*() {
// Get current annotations (empty by default)
const current = yield* References.CurrentLogAnnotations
console.log(current) // {}
// Run with custom log annotations
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")
}),
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
}
)
})
CurrentLogAnnotations, (annotations: ReadonlyRecord<string, unknown>annotations) => {
const const newAnnotations: anynewAnnotations = { ...annotations: ReadonlyRecord<string, unknown>annotations }
if (args: | [Record<string, unknown>]
| [key: string, value: unknown]
length: 2 | 1length === 1) {
var Object: ObjectConstructorProvides functionality common to all JavaScript objects.
Object.ObjectConstructor.assign<any, Record<string, unknown>>(target: any, source: Record<string, unknown>): any (+3 overloads)Copy the values of all of the enumerable own properties from one or more source objects to a
target object. Returns the target object.
assign(const newAnnotations: anynewAnnotations, args: [Record<string, unknown>](parameter) args: {
0: Record<string, unknown>;
length: 1;
toString: () => string;
toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string };
pop: () => Record<string, unknown> | undefined;
push: (...items: Array<Record<string, unknown>>) => number;
concat: { (...items: Array<ConcatArray<Record<string, unknown>>>): Array<Record<string, unknown>>; (...items: Array<Record<string, unknown> | ConcatArray<Record<string, unknown>>>): Array<Record<string, unknown>> };
join: (separator?: string) => string;
reverse: () => Array<Record<string, unknown>>;
shift: () => Record<string, unknown> | undefined;
slice: (start?: number, end?: number) => Array<Record<string, unknown>>;
sort: (compareFn?: ((a: Record<string, unknown>, b: Record<string, unknown>) => number) | undefined) => [Record<string, unknown>];
splice: { (start: number, deleteCount?: number): Array<Record<string, unknown>>; (start: number, deleteCount: number, ...items: Array<Record<string, unknown>>): Array<Record<string, unknown>> };
unshift: (...items: Array<Record<string, unknown>>) => number;
indexOf: (searchElement: Record<string, unknown>, fromIndex?: number) => number;
lastIndexOf: (searchElement: Record<string, unknown>, fromIndex?: number) => number;
every: { (predicate: (value: Record<string, unknown>, index: number, array: Array<Record<string, unknown>>) => value is S, thisArg?: any): this is S[]; (predicate: (value: Record<string, unknown>, index: number, array: Array<Record<string, unknow…;
some: (predicate: (value: Record<string, unknown>, index: number, array: Array<Record<string, unknown>>) => unknown, thisArg?: any) => boolean;
forEach: (callbackfn: (value: Record<string, unknown>, index: number, array: Array<Record<string, unknown>>) => void, thisArg?: any) => void;
map: (callbackfn: (value: Record<string, unknown>, index: number, array: Array<Record<string, unknown>>) => U, thisArg?: any) => Array<U>;
filter: { (predicate: (value: Record<string, unknown>, index: number, array: Array<Record<string, unknown>>) => value is S, thisArg?: any): Array<S>; (predicate: (value: Record<string, unknown>, index: number, array: Array<Record<string, unknown>>…;
reduce: { (callbackfn: (previousValue: Record<string, unknown>, currentValue: Record<string, unknown>, currentIndex: number, array: Array<Record<string, unknown>>) => Record<string, unknown>): Record<string, unknown>; (callbackfn: (previousValue: …;
reduceRight: { (callbackfn: (previousValue: Record<string, unknown>, currentValue: Record<string, unknown>, currentIndex: number, array: Array<Record<string, unknown>>) => Record<string, unknown>): Record<string, unknown>; (callbackfn: (previousValue: …;
find: { (predicate: (value: Record<string, unknown>, index: number, obj: Array<Record<string, unknown>>) => value is S, thisArg?: any): S | undefined; (predicate: (value: Record<string, unknown>, index: number, obj: Array<Record<string, unknown>…;
findIndex: (predicate: (value: Record<string, unknown>, index: number, obj: Array<Record<string, unknown>>) => unknown, thisArg?: any) => number;
fill: (value: Record<string, unknown>, start?: number, end?: number) => [Record<string, unknown>];
copyWithin: (target: number, start: number, end?: number) => [Record<string, unknown>];
entries: () => ArrayIterator<[number, Record<string, unknown>]>;
keys: () => ArrayIterator<number>;
values: () => ArrayIterator<Record<string, unknown>>;
includes: (searchElement: Record<string, unknown>, fromIndex?: number) => boolean;
flatMap: (callback: (this: This, value: Record<string, unknown>, index: number, array: Array<Record<string, unknown>>) => U | ReadonlyArray<U>, thisArg?: This | undefined) => Array<U>;
flat: (this: A, depth?: D | undefined) => Array<FlatArray<A, D>>;
at: (index: number) => Record<string, unknown> | undefined;
findLast: { (predicate: (value: Record<string, unknown>, index: number, array: Array<Record<string, unknown>>) => value is S, thisArg?: any): S | undefined; (predicate: (value: Record<string, unknown>, index: number, array: Array<Record<string, unkn…;
findLastIndex: (predicate: (value: Record<string, unknown>, index: number, array: Array<Record<string, unknown>>) => unknown, thisArg?: any) => number;
toReversed: () => Array<Record<string, unknown>>;
toSorted: (compareFn?: ((a: Record<string, unknown>, b: Record<string, unknown>) => number) | undefined) => Array<Record<string, unknown>>;
toSpliced: { (start: number, deleteCount: number, ...items: Array<Record<string, unknown>>): Array<Record<string, unknown>>; (start: number, deleteCount?: number): Array<Record<string, unknown>> };
with: (index: number, value: Record<string, unknown>) => Array<Record<string, unknown>>;
}
const newAnnotations: anynewAnnotations[args: [key: string, value: unknown](parameter) args: {
0: string;
1: unknown;
length: 2;
toString: () => string;
toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string };
pop: () => unknown;
push: (...items: Array<unknown>) => number;
concat: { (...items: Array<ConcatArray<unknown>>): Array<unknown>; (...items: Array<unknown>): Array<unknown> };
join: (separator?: string) => string;
reverse: () => Array<unknown>;
shift: () => unknown;
slice: (start?: number, end?: number) => Array<unknown>;
sort: (compareFn?: ((a: unknown, b: unknown) => number) | undefined) => [key: string, value: unknown];
splice: { (start: number, deleteCount?: number): Array<unknown>; (start: number, deleteCount: number, ...items: Array<unknown>): Array<unknown> };
unshift: (...items: Array<unknown>) => number;
indexOf: (searchElement: unknown, fromIndex?: number) => number;
lastIndexOf: (searchElement: unknown, fromIndex?: number) => number;
every: { (predicate: (value: unknown, index: number, array: Array<unknown>) => value is S, thisArg?: any): this is S[]; (predicate: (value: unknown, index: number, array: Array<unknown>) => unknown, thisArg?: any): boolean };
some: (predicate: (value: unknown, index: number, array: Array<unknown>) => unknown, thisArg?: any) => boolean;
forEach: (callbackfn: (value: unknown, index: number, array: Array<unknown>) => void, thisArg?: any) => void;
map: (callbackfn: (value: unknown, index: number, array: Array<unknown>) => U, thisArg?: any) => Array<U>;
filter: { (predicate: (value: unknown, index: number, array: Array<unknown>) => value is S, thisArg?: any): Array<S>; (predicate: (value: unknown, index: number, array: Array<unknown>) => unknown, thisArg?: any): Array<unknown> };
reduce: { (callbackfn: (previousValue: unknown, currentValue: unknown, currentIndex: number, array: Array<unknown>) => unknown): unknown; (callbackfn: (previousValue: unknown, currentValue: unknown, currentIndex: number, array: Array<unknown>) => …;
reduceRight: { (callbackfn: (previousValue: unknown, currentValue: unknown, currentIndex: number, array: Array<unknown>) => unknown): unknown; (callbackfn: (previousValue: unknown, currentValue: unknown, currentIndex: number, array: Array<unknown>) => …;
find: { (predicate: (value: unknown, index: number, obj: Array<unknown>) => value is S, thisArg?: any): S | undefined; (predicate: (value: unknown, index: number, obj: Array<unknown>) => unknown, thisArg?: any): unknown };
findIndex: (predicate: (value: unknown, index: number, obj: Array<unknown>) => unknown, thisArg?: any) => number;
fill: (value: unknown, start?: number, end?: number) => [key: string, value: unknown];
copyWithin: (target: number, start: number, end?: number) => [key: string, value: unknown];
entries: () => ArrayIterator<[number, unknown]>;
keys: () => ArrayIterator<number>;
values: () => ArrayIterator<unknown>;
includes: (searchElement: unknown, fromIndex?: number) => boolean;
flatMap: (callback: (this: This, value: unknown, index: number, array: Array<unknown>) => U | ReadonlyArray<U>, thisArg?: This | undefined) => Array<U>;
flat: (this: A, depth?: D | undefined) => Array<FlatArray<A, D>>;
at: (index: number) => unknown;
findLast: { (predicate: (value: unknown, index: number, array: Array<unknown>) => value is S, thisArg?: any): S | undefined; (predicate: (value: unknown, index: number, array: Array<unknown>) => unknown, thisArg?: any): unknown };
findLastIndex: (predicate: (value: unknown, index: number, array: Array<unknown>) => unknown, thisArg?: any) => number;
toReversed: () => Array<unknown>;
toSorted: (compareFn?: ((a: unknown, b: unknown) => number) | undefined) => Array<unknown>;
toSpliced: { (start: number, deleteCount: number, ...items: Array<unknown>): Array<unknown>; (start: number, deleteCount?: number): Array<unknown> };
with: (index: number, value: unknown) => Array<unknown>;
}
args: [key: string, value: unknown](parameter) args: {
0: string;
1: unknown;
length: 2;
toString: () => string;
toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string };
pop: () => unknown;
push: (...items: Array<unknown>) => number;
concat: { (...items: Array<ConcatArray<unknown>>): Array<unknown>; (...items: Array<unknown>): Array<unknown> };
join: (separator?: string) => string;
reverse: () => Array<unknown>;
shift: () => unknown;
slice: (start?: number, end?: number) => Array<unknown>;
sort: (compareFn?: ((a: unknown, b: unknown) => number) | undefined) => [key: string, value: unknown];
splice: { (start: number, deleteCount?: number): Array<unknown>; (start: number, deleteCount: number, ...items: Array<unknown>): Array<unknown> };
unshift: (...items: Array<unknown>) => number;
indexOf: (searchElement: unknown, fromIndex?: number) => number;
lastIndexOf: (searchElement: unknown, fromIndex?: number) => number;
every: { (predicate: (value: unknown, index: number, array: Array<unknown>) => value is S, thisArg?: any): this is S[]; (predicate: (value: unknown, index: number, array: Array<unknown>) => unknown, thisArg?: any): boolean };
some: (predicate: (value: unknown, index: number, array: Array<unknown>) => unknown, thisArg?: any) => boolean;
forEach: (callbackfn: (value: unknown, index: number, array: Array<unknown>) => void, thisArg?: any) => void;
map: (callbackfn: (value: unknown, index: number, array: Array<unknown>) => U, thisArg?: any) => Array<U>;
filter: { (predicate: (value: unknown, index: number, array: Array<unknown>) => value is S, thisArg?: any): Array<S>; (predicate: (value: unknown, index: number, array: Array<unknown>) => unknown, thisArg?: any): Array<unknown> };
reduce: { (callbackfn: (previousValue: unknown, currentValue: unknown, currentIndex: number, array: Array<unknown>) => unknown): unknown; (callbackfn: (previousValue: unknown, currentValue: unknown, currentIndex: number, array: Array<unknown>) => …;
reduceRight: { (callbackfn: (previousValue: unknown, currentValue: unknown, currentIndex: number, array: Array<unknown>) => unknown): unknown; (callbackfn: (previousValue: unknown, currentValue: unknown, currentIndex: number, array: Array<unknown>) => …;
find: { (predicate: (value: unknown, index: number, obj: Array<unknown>) => value is S, thisArg?: any): S | undefined; (predicate: (value: unknown, index: number, obj: Array<unknown>) => unknown, thisArg?: any): unknown };
findIndex: (predicate: (value: unknown, index: number, obj: Array<unknown>) => unknown, thisArg?: any) => number;
fill: (value: unknown, start?: number, end?: number) => [key: string, value: unknown];
copyWithin: (target: number, start: number, end?: number) => [key: string, value: unknown];
entries: () => ArrayIterator<[number, unknown]>;
keys: () => ArrayIterator<number>;
values: () => ArrayIterator<unknown>;
includes: (searchElement: unknown, fromIndex?: number) => boolean;
flatMap: (callback: (this: This, value: unknown, index: number, array: Array<unknown>) => U | ReadonlyArray<U>, thisArg?: This | undefined) => Array<U>;
flat: (this: A, depth?: D | undefined) => Array<FlatArray<A, D>>;
at: (index: number) => unknown;
findLast: { (predicate: (value: unknown, index: number, array: Array<unknown>) => value is S, thisArg?: any): S | undefined; (predicate: (value: unknown, index: number, array: Array<unknown>) => unknown, thisArg?: any): unknown };
findLastIndex: (predicate: (value: unknown, index: number, array: Array<unknown>) => unknown, thisArg?: any) => number;
toReversed: () => Array<unknown>;
toSorted: (compareFn?: ((a: unknown, b: unknown) => number) | undefined) => Array<unknown>;
toSpliced: { (start: number, deleteCount: number, ...items: Array<unknown>): Array<unknown>; (start: number, deleteCount?: number): Array<unknown> };
with: (index: number, value: unknown) => Array<unknown>;
}
const newAnnotations: anynewAnnotations
})
)