NetAddress

declare const ipv4Broadcast: Ipv4Address

declare const ipv4Loopback: Ipv4Address

declare const ipv4Unspecified: Ipv4Address

declare const ipv6Loopback: Ipv6Address

declare const ipv6Unspecified: Ipv6Address

declare function inetAddress(address: IpAddress, port: number): 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 ipv4FromOctets(octets: readonly [number, number, number, number]): Result<Ipv4Address, NetAddressError>

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

declare function macAddressFromOctets(octets: readonly [number, number, number, number, number, number]): Result<MacAddress, 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 toCanonical(self: IpAddress): IpAddress

declare function toIpv4Mapped(self: Ipv4Address): Ipv6Address

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 formatInet(self: InetAddress): string

declare function formatIp(self: IpAddress): string

declare function formatMacAddress(self: MacAddress): 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 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 isSocketAddress(u: unknown): u is SocketAddress

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

type InetAddress = InetAddressV4 | InetAddressV6

interface InetAddressV4 extends Equal, Hash {
  readonly _tag: "InetAddressV4";
  readonly "~effect/net/NetAddress": "~effect/net/NetAddress";
  readonly address: Ipv4Address;
  readonly port: number;
  toJSON(): string;
  toString(): string;
}

interface InetAddressV6 extends Equal, Hash {
  readonly _tag: "InetAddressV6";
  readonly "~effect/net/NetAddress": "~effect/net/NetAddress";
  readonly address: Ipv6Address;
  readonly port: number;
  readonly scopeId: number;
  toJSON(): string;
  toString(): string;
}

type IpAddress = Ipv4Address | Ipv6Address

interface Ipv4Address extends Equal, Hash {
  readonly _tag: "Ipv4Address";
  readonly "~effect/net/NetAddress": "~effect/net/NetAddress";
  toJSON(): string;
  toString(): string;
}

interface Ipv6Address extends Equal, Hash {
  readonly _tag: "Ipv6Address";
  readonly "~effect/net/NetAddress": "~effect/net/NetAddress";
  toJSON(): string;
  toString(): string;
}

interface MacAddress extends Equal, Hash {
  readonly _tag: "MacAddress";
  readonly "~effect/net/NetAddress": "~effect/net/NetAddress";
  toJSON(): string;
  toString(): string;
}

type SocketAddress = InetAddress | UnixPathAddress

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

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(self: Ipv4Address): boolean

declare function isIpv4Mapped(self: Ipv6Address): boolean

declare function isLinkLocal(self: IpAddress): boolean

declare function isLoopback(self: IpAddress): boolean

declare function isMacBroadcast(self: MacAddress): boolean

declare function isMacLocallyAdministered(self: MacAddress): boolean

declare function isMacMulticast(self: MacAddress): boolean

declare function isMacUnicast(self: MacAddress): boolean

declare function isMacUniversallyAdministered(self: MacAddress): boolean

declare function isMulticast(self: IpAddress): boolean

declare function isPrivate(self: Ipv4Address): boolean

declare function isUniqueLocal(self: Ipv6Address): boolean

declare function isUnspecified(self: IpAddress): boolean

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

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

declare function inetAddressFromStringUnsafe(input: string): InetAddress

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

declare function ipFromStringUnsafe(input: string): IpAddress

declare function ipv4FromBytesUnsafe(bytes: Uint8Array): Ipv4Address

declare function ipv6FromBytesUnsafe(bytes: Uint8Array): Ipv6Address

declare function macAddressFromStringUnsafe(input: string): MacAddress

declare function socketAddressFromInputUnsafe(input: Input): SocketAddress