NetAddress unstable

declare const ipv4Broadcast: Ipv4Address

declare const ipv4Loopback: Ipv4Address

declare const ipv4Unspecified: Ipv4Address

declare const ipv6Loopback: Ipv6Address

declare const ipv6Unspecified: Ipv6Address

declare const loopbackAddresses: readonly [Ipv4Address, Ipv6Address]

declare function inetAddress(address: IpAddress, port: number): Result<InetAddress, NetAddressError>

declare function inetAddressFromInput(input: InetAddressInput): Result<InetAddress, NetAddressError>

declare function inetAddressFromIpString(address: string, port: number): Result<InetAddress, NetAddressError>

declare function inetAddressV4(address: Ipv4Address, port: number): Result<InetAddressV4, NetAddressError>

declare function inetAddressV6(address: Ipv6Address, port: number, options?: {
  readonly scopeId?: number;
}): Result<InetAddressV6, NetAddressError>

declare function ipFromInput(input: IpAddressInput): Result<IpAddress, NetAddressError>

declare function ipv4FromInput(input: Ipv4AddressInput): Result<Ipv4Address, NetAddressError>

declare function ipv4FromOctets(octets: readonly [number, number, number, number]): Result<Ipv4Address, NetAddressError>

declare function ipv6FromInput(input: Ipv6AddressInput): Result<Ipv6Address, NetAddressError>

declare function ipv6FromSegments(segments: readonly [number, number, number, number, number, number, number, number]): Result<Ipv6Address, NetAddressError>

declare function macAddressFromInput(input: MacAddressInput): Result<MacAddress, NetAddressError>

declare function macAddressFromOctets(octets: readonly [number, number, number, number, number, number]): Result<MacAddress, NetAddressError>

declare function scopedIpv6LiteralFromInput(input: ScopedIpv6LiteralInput): Result<ScopedIpv6Literal, NetAddressError>

declare function socketAddressFromInput(input: Input): Result<SocketAddress, NetAddressError>

declare function unixPathAddress(path: string): UnixPathAddress

declare function toUrl(self: IpAddress | InetAddress, scheme: string): Result<URL, NetAddressError>

declare function fromIpv4Mapped(self: Ipv6Address): Option<Ipv4Address>

declare function scopeIdFromInterface(addresses: readonly Array<NetworkInterfaceAddress> | undefined): Option<number>

declare function scopeIdsFromInterfaces(interfaces: Iterable<readonly [string, readonly Array<NetworkInterfaceAddress> | undefined]>): Map<string, number>

declare function toIpv4Mapped(self: Ipv4Address): Ipv6Address

declare function inetAddressFromHostString(host: string, port: number, scopeIds?: ReadonlyMap<string, number>): Result<InetAddress, NetAddressError>

declare function inetAddressFromString(input: string): Result<InetAddress, NetAddressError>

declare function ipFromString(input: string): Result<IpAddress, NetAddressError>

declare function ipv4FromString(input: string): Result<Ipv4Address, NetAddressError>

declare function ipv6FromString(input: string): Result<Ipv6Address, NetAddressError>

declare function macAddressFromString(input: string): Result<MacAddress, NetAddressError>

declare function scopedIpv6LiteralFromString(input: string): Result<ScopedIpv6Literal, NetAddressError>

declare function formatHost(self: InetAddress): string

declare function formatInet(self: InetAddress): string

declare function formatIp(self: IpAddress): string

declare function formatMacAddress(self: MacAddress): string

declare function formatMulticastInterface(networkInterface: number | Ipv4Address, scopeIds: ReadonlyMap<string, number>, platform?: string): string

declare function formatNativeHost(self: InetAddress, scopeIds: ReadonlyMap<string, number>, platform?: string): string

declare function formatSocketAddress(self: SocketAddress): string

declare function formatUnixPath(self: UnixPathAddress): string

declare function formatUrl(self: IpAddress | SocketAddress, scheme: string): Result<string, NetAddressError>

declare function formatUrlHost(self: IpAddress): string

declare function formatUrlHostString(host: string): string

declare class NetAddressError extends YieldableError<this> & {
  readonly _tag: "NetAddressError";
} & Readonly<{
  readonly cause?: unknown;
  readonly input: unknown;
  readonly message: string;
}> {
  constructor(args: {
    readonly cause?: unknown;
    readonly input: unknown;
    readonly message: string;
  });
}

declare function familyOf(self: IpAddress | InetAddress): IpFamily

declare function ipv4ToOctets(self: Ipv4Address): readonly [number, number, number, number]

declare function ipv6ToOctets(self: Ipv6Address): readonly Array<number>

declare function ipv6ToSegments(self: Ipv6Address): readonly [number, number, number, number, number, number, number, number]

declare function macAddressToOctets(self: MacAddress): readonly [number, number, number, number, number, number]

declare function width(address: IpAddress): 32 | 128

declare function isInetAddress(u: unknown): u is InetAddress

declare function isInetAddressV4(u: unknown): u is InetAddressV4

declare function isInetAddressV6(u: unknown): u is InetAddressV6

declare function isIpAddress(u: unknown): u is IpAddress

declare function isIpv4Address(u: unknown): u is Ipv4Address

declare function isIpv6Address(u: unknown): u is Ipv6Address

declare function isMacAddress(u: unknown): u is MacAddress

declare function isScopedIpv6Literal(u: unknown): u is ScopedIpv6Literal

declare function isSocketAddress(u: unknown): u is SocketAddress

declare function isUnixPathAddress(u: unknown): u is UnixPathAddress

type BroadcastAddress<A extends Ipv4Address | MacAddress = Ipv4Address | MacAddress> = A extends MacAddress ? Brand.Branded<MulticastAddress<A>, typeof BroadcastTypeId> : Brand.Branded<A, typeof BroadcastTypeId>

type Family<A extends IpAddress | InetAddress> = A extends Ipv4Address | InetAddressV4 ? Ipv4Address : Ipv6Address

type FamilyAddress<F extends IpFamily> = F extends "IPv4" ? Ipv4Address : Ipv6Address

type Inet<A extends IpAddress = IpAddress> = A extends Ipv4Address ? InetAddressV4 : InetAddressV6

type InetAddress = InetAddressV4 | InetAddressV6

type InetAddressInput = InetAddress | string | InetAddressParts

interface InetAddressParts<A extends IpAddressInput = IpAddressInput> {
  readonly address: A;
  readonly port: number;
  readonly scopeId?: number;
}

interface InetAddressV4 extends Equal, Hash, Inspectable {
  readonly _tag: "InetAddressV4";
  readonly "~effect/net/NetAddress": "~effect/net/NetAddress";
  readonly address: Ipv4Address;
  readonly port: number;
}

interface InetAddressV6 extends Equal, Hash, Inspectable {
  readonly _tag: "InetAddressV6";
  readonly "~effect/net/NetAddress": "~effect/net/NetAddress";
  readonly address: Ipv6Address;
  readonly port: number;
  readonly scopeId: number;
}

type IpAddress = Ipv4Address | Ipv6Address

type IpAddressInput = Ipv4AddressInput | Ipv6AddressInput

type IpFamily = "IPv4" | "IPv6"

interface Ipv4Address extends Equal, Hash, Inspectable {
  readonly _tag: "Ipv4Address";
  readonly "~effect/net/NetAddress": "~effect/net/NetAddress";
}

type Ipv4AddressInput = Ipv4Address | string | Ipv4Octets | Uint8Array

type Ipv4Octets = Readonly<TupleOf<4, number>>

interface Ipv6Address extends Equal, Hash, Inspectable {
  readonly _tag: "Ipv6Address";
  readonly "~effect/net/NetAddress": "~effect/net/NetAddress";
}

type Ipv6AddressInput = Ipv6Address | string | Ipv6Segments | Uint8Array

type Ipv6Segments = Readonly<TupleOf<8, number>>

type LinkLocalAddress<A extends IpAddress = IpAddress> = Brand.Branded<A, typeof LinkLocalTypeId>

type LocallyAdministeredAddress<A extends MacAddress = MacAddress> = Brand.Branded<A, typeof LocallyAdministeredTypeId>

type LoopbackAddress<A extends IpAddress = IpAddress> = Brand.Branded<A, typeof LoopbackTypeId>

interface MacAddress extends Equal, Hash, Inspectable {
  readonly _tag: "MacAddress";
  readonly "~effect/net/NetAddress": "~effect/net/NetAddress";
}

type MacAddressInput = MacAddress | string | MacAddressOctets

type MacAddressOctets = Readonly<TupleOf<6, number>>

type MulticastAddress<A extends IpAddress | MacAddress = IpAddress> = Brand.Branded<A, typeof MulticastTypeId>

type MulticastInterface<A extends IpAddress = IpAddress> = A extends Ipv4Address ? Ipv4Address : number

interface NetworkInterfaceAddress {
  readonly family: string;
  readonly scopeid?: number | null;
}

type PrivateAddress<A extends Ipv4Address = Ipv4Address> = Brand.Branded<A, typeof PrivateTypeId>

type ScopedIpv6Literal = Brand.Branded<string, "~effect/net/NetAddress/ScopedIpv6Literal">

type ScopedIpv6LiteralInput = ScopedIpv6Literal | string

type SocketAddress = InetAddress | UnixPathAddress

type UnicastAddress<A extends IpAddress | MacAddress = IpAddress | MacAddress> = Brand.Branded<A, typeof UnicastTypeId>

type UniqueLocalAddress<A extends Ipv6Address = Ipv6Address> = Brand.Branded<A, typeof UniqueLocalTypeId>

type UniversallyAdministeredAddress<A extends MacAddress = MacAddress> = Brand.Branded<A, typeof UniversallyAdministeredTypeId>

interface UnixPathAddress extends Equal, Hash, Inspectable {
  readonly _tag: "UnixPathAddress";
  readonly "~effect/net/NetAddress": "~effect/net/NetAddress";
  readonly path: string;
}

interface UnixPathAddressParts {
  readonly path: string;
}

type UnspecifiedAddress<A extends IpAddress = IpAddress> = Brand.Branded<A, typeof UnspecifiedTypeId>

declare function toCanonical(self: IpAddress): IpAddress
declare function toCanonical(self: InetAddress): InetAddress

declare const match: {
  <A, B>(options: {
    readonly onIpv4: (address: Ipv4Address) => A;
    readonly onIpv6: (address: Ipv6Address) => B;
  }): (self: IpAddress) => A | B;
  <A, B>(self: IpAddress, options: {
    readonly onIpv4: (address: Ipv4Address) => A;
    readonly onIpv6: (address: Ipv6Address) => B;
  }): A | B;
}

declare function isBroadcast<A extends MacAddress | Ipv4Address>(self: A): self is BroadcastAddress<A>

declare const isFamily: {
  (family: "IPv4"): <A extends IpAddress | InetAddress>(self: A) => self is Extract<A, Ipv4Address | InetAddressV4>;
  (family: "IPv6"): <A extends IpAddress | InetAddress>(self: A) => self is Extract<A, Ipv6Address | InetAddressV6>;
  (family: IpFamily): (self: IpAddress | InetAddress) => boolean;
  <A extends IpAddress | InetAddress>(self: A, family: "IPv4"): self is Extract<A, Ipv4Address | InetAddressV4>;
  <A extends IpAddress | InetAddress>(self: A, family: "IPv6"): self is Extract<A, Ipv6Address | InetAddressV6>;
  (self: IpAddress | InetAddress, family: IpFamily): boolean;
}

declare function isIpv4Mapped(self: Ipv6Address): boolean

declare function isLinkLocal<A extends IpAddress>(self: A): self is LinkLocalAddress<A>

declare function isLoopback<A extends IpAddress>(self: A): self is LoopbackAddress<A>

declare function isMacBroadcast<A extends MacAddress>(self: A): self is BroadcastAddress<A>

declare function isMacLocallyAdministered<A extends MacAddress>(self: A): self is LocallyAdministeredAddress<A>

declare function isMacMulticast<A extends MacAddress>(self: A): self is MulticastAddress<A>

declare function isMacUnicast<A extends MacAddress>(self: A): self is UnicastAddress<A>

declare function isMacUniversallyAdministered<A extends MacAddress>(self: A): self is UniversallyAdministeredAddress<A>

declare function isMulticast<A extends MacAddress | IpAddress>(self: A): self is MulticastAddress<A>

declare function isPrivate<A extends Ipv4Address>(self: A): self is PrivateAddress<A>

declare function isUnicast<A extends MacAddress | IpAddress>(self: A): self is UnicastAddress<A>

declare function isUniqueLocal<A extends Ipv6Address>(self: A): self is UniqueLocalAddress<A>

declare function isUnspecified<A extends IpAddress>(self: A): self is UnspecifiedAddress<A>

declare function formatUrlUnsafe(self: IpAddress | SocketAddress, scheme: string): string

declare function inetAddressFromInputUnsafe(input: InetAddressInput): InetAddress

declare function inetAddressFromIpStringUnsafe(address: string, port: number): InetAddress

declare function inetAddressFromNativeUnsafe(host: string, port: number, scopeIds?: ReadonlyMap<string, number>): InetAddress

declare function inetAddressFromStringUnsafe(input: string): InetAddress

declare function inetAddressUnsafe(address: IpAddress, port: number): InetAddress

declare function ipFromInputUnsafe(input: IpAddressInput): IpAddress

declare function ipFromStringUnsafe(input: string): IpAddress

declare function ipv4FromBytesUnsafe(bytes: Uint8Array): Ipv4Address

declare function ipv6FromBytesUnsafe(bytes: Uint8Array): Ipv6Address

declare function macAddressFromInputUnsafe(input: MacAddressInput): MacAddress

declare function macAddressFromStringUnsafe(input: string): MacAddress

declare function socketAddressFromInputUnsafe(input: Input): SocketAddress