(u: unknown)

( confirm: string, message: string, leadingSymbol: string, trailingSymbol: string, options?: RenderO

( request: HttpServerRequest, description?: string, cause?: unknown )

( ctx: V.TestContext & object, args: TestArgs, self: Vitest.Vitest.TestFunction<A, E, R, TestArgs>

(self: SubscriptionRef<A>, value: A)

(n: number)

(timeout?: number | V.TestOptions)

()

( channel: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env> )

( f: (e: E, options: SchemaAST.ParseOptions) => Effect.Effect<T, SchemaIssue.Issue, R> )

(atom: Atom.Atom<A>, f?: (_: A) => A)

(value: A)

()

(request: HttpServerRequest, handler: PreResponseHandler)

(what: string)

( parser: (input: E, options?: SchemaAST.ParseOptions) => Effect.Effect<T, SchemaIssue.Issue, R> )

(attributes?: Metric.Attributes)

(_edit: number)

()

()

( cause: unknown, { message, operation }: SqliteClassifyOptions = {} )

(cause?: Error)

(self: Any, overrides?: Record<string, unknown>)

(...styles: Array<string>)

(...arrays: Array<Uint8Array>)

(str: string)

(error: ConfigError, hasInput: boolean)

(failure: E)

(message: string)

(line: Line, message: string)

( step: Effect< (now: number, input: Input) => Pull.Pull<[Output, Duration.Duration], ErrorX, Output, En

( options: Options | undefined, headers: Headers.Headers )

( module: SystemError["module"], method: string, pathOrDescriptor?: string | number )

(self: HttpIncomingMessage<E>, that: object)

(result: Result.Result<A, E>)

(self: HashSet<V>)

(value: string, params?: ReadonlyArray<unknown> | undefined)

( compare: (self: A, that: A) => -1 | 0 | 1 )

(combine: (self: A, that: A) => A)

(options: { readonly from: IndexedDbQuery.From<Table> readonly index: Index | undefined readonly only?:

(crypto: Crypto)

( role: Role, params: Omit<Extract<Message, { role: Role }>, typeof MessageTypeId | "role" | "options"> &

( options: { readonly identifier: Id readonly groups: Record.ReadonlyRecord<string, HttpApiGroup.Con

(filePath: string)

(filename: string)

(handlers: Handlers)

(group: Top)

(f: F)

(node: ast.Node)

(options: { readonly cause: Cause.Cause<unknown> readonly fiber: Fiber.Fiber<unknown, unknown> rea

(reply: Effect.Effect<Reply.Encoded, ClusterError.EntityNotAssignedToRunner>)

( sql: string, values?: ReadonlyArray<any>, rowsAsArray = false, method: "exec

(node: ts.TypeNode, context: SerializationContext)

(context: Context.Context<never>)

(value: A, options?: { readonly waiting?: boolean | undefined readonly timestamp?: number | undefined })

( name: string, run: () => unknown | PromiseLike<unknown> )

()

( schema: Schema.ConstraintCodec<T, E, RD, RE> )

( compression: HttpPlatform["Service"]["compression"], acceptEncoding: string | undefined, respons

( update: S["update"]["Type"] )

(f: (service: Shape) => A)

()

(bytes: SizeInput)

( tag: Tag )

(address: RunnerAddress.RunnerAddress)

(count, options = {})

( result: Result.Result<A, E>, expected: A, ..._: Array<never> )

(hash: number, shift: number)

( cause: unknown, message: string, operation: string )

(cause: unknown, message: string, operation: string)

(cause: unknown, message: string, operation: string)

( this: CompilerImpl, statement: Fragment, withoutTransform = false, placeholderOverride?: (u:

()

(text: string, columns: number)

(...args: ReadonlyArray<any>)

( sql: string, params: ReadonlyArray<unknown>, transformRows: (<A extends object>(row: ReadonlyArr

(defect: unknown)

(character: string)

(message: string)

( cause: Cause.Cause<E>, options?: { readonly previousSuccess?: Option.Option<Success<A, E>> | undefin

( fibers: A )

(self: MutableList<A>, f: (value: A, i: number) => boolean)

( fileInfos: ReadonlyMap<string, FileInfo>, fileInfo: FileInfo, diagnostics: Array<Diagnostic>, node:

()

(...args: ReadonlyArray<any>)

()

(reason: string, description: string | undefined, info: string)

(tag: string)

( step: Effect< (options: InputMetadata<Input>) => Pull.Pull<[Output, Duration.Duration], ErrorX, Output

(input: unknown)

(O: Order<A>)

( regExp: globalThis.RegExp, annotations?: Annotations.Filter )

(fa: Option.Option<A>)

(self: ReadonlyRecord<K, A>)

(self: Context<any>, key: string)

(isEquivalent: (self: A, that: A) => boolean)

( this: { new(...args: Args): X }, ...args: Args )