export interface $Address extends Schema.Union<[$IPv4, $IPv6]> {}

export interface $AddressBigint extends Schema.Union<[$IPv4Bigint, $IPv6Bigint]> {}

export interface $CidrBlock extends Schema.Union<[$IPv4CidrBlock, $IPv6CidrBlock]> {}

export interface $CidrBlockFromString
  extends Schema.Annotable<
    $CidrBlockFromString,
    CidrBlockBase<"ipv4"> | CidrBlockBase<"ipv6">,
    `${string}/${number}`,
    never
  > {}

export interface $Endpoint extends Schema.Union<[$IPv4Endpoint, $IPv6Endpoint, $HostnameEndpoint]> {}

export interface $Family extends Schema.Union<[$IPv4Family, $IPv6Family]> {}

export interface $HostnameEndpoint
  extends Schema.Annotable<
    $HostnameEndpoint,
    { readonly host: string; readonly natPort: PortBrand; readonly listenPort: PortBrand },
    | `${string}:${number}`
    | `${string}:${number}:${number}`
    | { readonly host: string; readonly port: number }
    | { readonly host: string; readonly natPort: number; readonly listenPort: number },
    never
  > {}

export interface $HostnameIPv4SetupData extends Schema.Tuple<[$HostnameEndpoint, $IPv4]> {}

export interface $HostnameIPv6SetupData extends Schema.Tuple<[$HostnameEndpoint, $IPv6]> {}

export interface $IPv4
  extends Schema.transform<
    Schema.filter<typeof Schema.String>,
    Schema.Struct<{
      family: $IPv4Family
      ip: Schema.BrandSchema<IPv4Brand, Brand.Brand.Unbranded<IPv4Brand>, never>
    }>
  > {}

export interface $IPv4Bigint
  extends Schema.transformOrFail<
    $IPv4,
    Schema.Struct<{
      family: $IPv4Family
      value: Schema.BrandSchema<IPv4BigintBrand, Brand.Brand.Unbranded<IPv4BigintBrand>, never>
    }>,
    never
  > {}

export interface $IPv4CidrBlock
  extends Schema.Annotable<
    $IPv4CidrBlock,
    CidrBlockBase<"ipv4">,
    {
      readonly address: string
      readonly mask: number
    },
    never
  > {}

export interface $IPv4CidrBlockFromString
  extends Schema.Annotable<$IPv4CidrBlockFromString, CidrBlockBase<"ipv4">, `${string}/${number}`, never> {}

export interface $IPv4CidrMask
  extends Schema.Annotable<$IPv4CidrMask, IPv4CidrMaskBrand, Brand.Brand.Unbranded<IPv4CidrMaskBrand>, never> {}

export interface $IPv4Endpoint
  extends Schema.Annotable<
    $IPv4Endpoint,
    { readonly address: IPv4; readonly natPort: PortBrand; readonly listenPort: PortBrand },
    | `${string}:${number}`
    | `${string}:${number}:${number}`
    | { readonly ip: string; readonly port: number; readonly family: IPv4Family }
    | { readonly ip: string; readonly natPort: number; readonly listenPort: number; readonly family: IPv4Family },
    never
  > {}

export interface $IPv4Family extends Schema.Literal<["ipv4"]> {}

export interface $IPv4SetupData extends Schema.Tuple<[$IPv4Endpoint, $IPv4]> {}

export interface $IPv6
  extends Schema.transform<
    Schema.filter<typeof Schema.String>,
    Schema.Struct<{
      family: $IPv6Family
      ip: Schema.BrandSchema<IPv6Brand, Brand.Brand.Unbranded<IPv6Brand>, never>
    }>
  > {}

export interface $IPv6Bigint
  extends Schema.transformOrFail<
    $IPv6,
    Schema.Struct<{
      family: $IPv6Family
      value: Schema.BrandSchema<IPv6BigintBrand, Brand.Brand.Unbranded<IPv6BigintBrand>, never>
    }>,
    never
  > {}

export interface $IPv6CidrBlock
  extends Schema.transformOrFail<
    Schema.Struct<{
      address: $IPv6
      mask: $IPv6CidrMask
    }>,
    typeof CidrBlockBase<"ipv6">,
    never
  > {}

export interface $IPv6CidrBlockFromString
  extends Schema.Annotable<$IPv6CidrBlockFromString, CidrBlockBase<"ipv6">, `${string}/${number}`, never> {}

export interface $IPv6CidrMask
  extends Schema.Annotable<$IPv6CidrMask, IPv6CidrMaskBrand, Brand.Brand.Unbranded<IPv6CidrMaskBrand>, never> {}

export interface $IPv6Endpoint
  extends Schema.Annotable<
    $IPv6Endpoint,
    { readonly address: IPv6; readonly natPort: PortBrand; readonly listenPort: PortBrand },
    | `[${string}]:${number}`
    | `[${string}]:${number}:${number}`
    | { readonly ip: string; readonly port: number; family: IPv6Family }
    | { readonly ip: string; readonly natPort: number; readonly listenPort: number; family: IPv6Family },
    never
  > {}

export interface $IPv6Family extends Schema.Literal<["ipv6"]> {}

export interface $IPv6SetupData extends Schema.Tuple<[$IPv6Endpoint, $IPv6]> {}

export interface $Port extends Schema.Annotable<$Port, PortBrand, Brand.Brand.Unbranded<PortBrand>, never> {}

export interface $SetupData
  extends Schema.Union<[$IPv4SetupData, $IPv6SetupData, $HostnameIPv4SetupData, $HostnameIPv6SetupData]> {}

export declare class CidrBlockBase<_Family>

public networkAddress(): _Family extends IPv4Family
        ? Effect.Effect<IPv4, ParseResult.ParseError, never>
        : _Family extends IPv6Family
          ? Effect.Effect<IPv6, ParseResult.ParseError, never>
          : never

public broadcastAddress(): _Family extends IPv4Family
        ? Effect.Effect<IPv4, ParseResult.ParseError, never>
        : _Family extends IPv6Family
          ? Effect.Effect<IPv6, ParseResult.ParseError, never>
          : never

readonly family: "ipv4" | "ipv6"

export declare const IPv4BigintBrand: Brand.Brand.Constructor<IPv4BigintBrand>

export declare const IPv4Brand: Brand.Brand.Constructor<IPv4Brand>

export declare const IPv4CidrMaskBrand: Brand.Brand.Constructor<IPv4CidrMaskBrand>

export declare const IPv6BigintBrand: Brand.Brand.Constructor<IPv6BigintBrand>

export declare const IPv6Brand: Brand.Brand.Constructor<IPv6Brand>

export declare const IPv6CidrMaskBrand: Brand.Brand.Constructor<IPv6CidrMaskBrand>

export declare const PortBrand: Brand.Brand.Constructor<PortBrand>

export type IPv4BigintBrand = bigint & Brand.Brand<"IPv4Bigint">

export type IPv4Brand = string & Brand.Brand<"IPv4">

export type IPv4CidrMaskBrand = number & Brand.Brand<"IPv4CidrMask">

export type IPv6BigintBrand = bigint & Brand.Brand<"IPv6Bigint">

export type IPv6Brand = string & Brand.Brand<"IPv6">

export type IPv6CidrMaskBrand = number & Brand.Brand<"IPv6CidrMask">

export type PortBrand = number & Brand.Brand<"Port">

export type Address = Schema.Schema.Type<$Address>

export type AddressBigint = Schema.Schema.Type<$AddressBigint>

export type CidrBlockFromString = Schema.Schema.Type<$CidrBlockFromString>

export type Endpoint = Schema.Schema.Type<$Endpoint>

export type Family = Schema.Schema.Type<$Family>

export type HostnameEndpoint = Schema.Schema.Type<$HostnameEndpoint>

export type HostnameIPv4SetupData = Schema.Schema.Type<$HostnameIPv4SetupData>

export type HostnameIPv6SetupData = Schema.Schema.Type<$HostnameIPv6SetupData>

export type IPv4 = Schema.Schema.Type<$IPv4>

export type IPv4Bigint = Schema.Schema.Type<$IPv4Bigint>

export type IPv4CidrBlock = CidrBlockBase<"ipv4">

export type IPv4CidrBlockFromString = Schema.Schema.Type<$IPv4CidrBlockFromString>

export type IPv4CidrMask = Schema.Schema.Type<$IPv4CidrMask>

export type IPv4Endpoint = Schema.Schema.Type<$IPv4Endpoint>

export type IPv4Family = Schema.Schema.Type<$IPv4Family>

export type IPv4SetupData = Schema.Schema.Type<$IPv4SetupData>

export type IPv6 = Schema.Schema.Type<$IPv6>

export type IPv6Bigint = Schema.Schema.Type<$IPv6Bigint>

export type IPv6CidrBlock = CidrBlockBase<"ipv6">

export type IPv6CidrBlockFromString = Schema.Schema.Type<$IPv6CidrBlockFromString>

export type IPv6CidrMask = Schema.Schema.Type<$IPv6CidrMask>

export type IPv6Endpoint = Schema.Schema.Type<$IPv6Endpoint>

export type IPv6Family = Schema.Schema.Type<$IPv6Family>

export type IPv6SetupData = Schema.Schema.Type<$IPv6SetupData>

export type SetupData = Schema.Schema.Type<$SetupData>

export type AddressBigintEncoded = Schema.Schema.Encoded<$AddressBigint>

export type AddressEncoded = Schema.Schema.Encoded<$Address>

export type CidrBlockFromStringEncoded = Schema.Schema.Encoded<$CidrBlockFromString>

export type EndpointEncoded = Schema.Schema.Encoded<$Endpoint>

export type HostnameEndpointEncoded = Schema.Schema.Encoded<$HostnameEndpoint>

export type HostnameIPv4SetupDataEncoded = Schema.Schema.Encoded<$HostnameIPv4SetupData>

export type HostnameIPv6SetupDataEncoded = Schema.Schema.Encoded<$HostnameIPv6SetupData>

export type IPv4BigintEncoded = Schema.Schema.Encoded<$IPv4Bigint>

export type IPv4CidrBlockEncoded = Schema.Schema.Encoded<$IPv4CidrBlock>

export type IPv4CidrBlockFromStringEncoded = Schema.Schema.Encoded<$IPv4CidrBlockFromString>

export type IPv4CidrMaskEncoded = Schema.Schema.Encoded<$IPv4CidrMask>

export type IPv4Encoded = Schema.Schema.Encoded<$IPv4>

export type IPv4EndpointEncoded = Schema.Schema.Encoded<$IPv4Endpoint>

export type IPv4SetupDataEncoded = Schema.Schema.Encoded<$IPv4SetupData>

export type IPv6BigintEncoded = Schema.Schema.Encoded<$IPv6Bigint>

export type IPv6CidrBlockEncoded = Schema.Schema.Encoded<$IPv6CidrBlock>

export type IPv6CidrBlockFromStringEncoded = Schema.Schema.Encoded<$IPv6CidrBlockFromString>

export type IPv6CidrMaskEncoded = Schema.Schema.Encoded<$IPv6CidrMask>

export type IPv6Encoded = Schema.Schema.Encoded<$IPv6>

export type IPv6EndpointEncoded = Schema.Schema.Encoded<$IPv6Endpoint>

export type IPv6SetupDataEncoded = Schema.Schema.Encoded<$IPv6SetupData>

export type SetupDataEncoded = Schema.Schema.Encoded<$SetupData>

export declare const Address: $Address

import * as Schema from "@effect/schema/Schema"
import { Address } from "the-wireguard-effect/InternetSchemas"

const decodeAddress = Schema.decodeSync(Address)

assert.throws(() => decodeAddress("1.1.b.1"))
assert.throws(() => decodeAddress("2001:0db8:85a3:0000:0000:8a2e:0370:7334:"))

assert.doesNotThrow(() => decodeAddress("1.1.1.2"))
assert.doesNotThrow(() => decodeAddress("2001:0db8:85a3:0000:0000:8a2e:0370:7334"))

export declare const AddressBigint: $AddressBigint

export declare const CidrBlock: $CidrBlock

export declare const CidrBlockFromString: $CidrBlockFromString

export declare class DurationFromSeconds

import * as Duration from "effect/Duration"
import * as Schema from "@effect/schema/Schema"
import { DurationFromSeconds } from "the-wireguard-effect/InternetSchemas"

const decodeDuration = Schema.decodeSync(DurationFromSeconds)
const duration = decodeDuration(11)
assert.strictEqual(Duration.toSeconds(duration), 11)

export declare class DurationFromSecondsString

import * as Duration from "effect/Duration"
import * as Schema from "@effect/schema/Schema"
import { DurationFromSecondsString } from "the-wireguard-effect/InternetSchemas"

const decodeDurationString = Schema.decodeSync(DurationFromSecondsString)
const duration = decodeDurationString("12")
assert.strictEqual(Duration.toSeconds(duration), 12)

export declare const Endpoint: $Endpoint

import * as Schema from "@effect/schema/Schema"

import { Endpoint } from "the-wireguard-effect/InternetSchemas"

const decodeEndpoint = Schema.decodeSync(Endpoint)
const endpoint1 = decodeEndpoint("1.2.3.4:51820")
const endpoint2 = decodeEndpoint("1.2.3.4:51820:41820")

const endpoint3 = decodeEndpoint({
  ip: "1.2.3.4",
  port: 51820,
  family: "ipv4"
})

const endpoint4: Endpoint = decodeEndpoint({
  ip: "1.2.3.4",
  natPort: 51820,
  listenPort: 41820,
  family: "ipv4"
})

const endpoint5 = decodeEndpoint("[2001:0db8:85a3:0000:0000:8a2e:0370:7334]:51820")
const endpoint6 = decodeEndpoint("[2001:0db8:85a3:0000:0000:8a2e:0370:7334]:51820:41820")

const endpoint7 = decodeEndpoint({
  ip: "2001:0db8:85a3:0000:0000:8a2e:0370:7334",
  port: 51820,
  family: "ipv6"
})

const endpoint8: Endpoint = decodeEndpoint({
  ip: "2001:0db8:85a3:0000:0000:8a2e:0370:7334",
  natPort: 51820,
  listenPort: 41820,
  family: "ipv6"
})

export declare const Family: $Family

export declare const HostnameEndpoint: $HostnameEndpoint

export declare const HostnameIPv4SetupData: $HostnameIPv4SetupData

export declare const HostnameIPv6SetupData: $HostnameIPv6SetupData

export declare const IPv4: $IPv4

import * as Schema from "@effect/schema/Schema"
import { IPv4 } from "the-wireguard-effect/InternetSchemas"

const decodeIPv4 = Schema.decodeSync(IPv4)
assert.deepEqual(decodeIPv4("1.1.1.1"), {
  family: "ipv4",
  ip: "1.1.1.1"
})

assert.throws(() => decodeIPv4("1.1.a.1"))
assert.doesNotThrow(() => decodeIPv4("1.1.1.2"))

export declare const IPv4Bigint: $IPv4Bigint

import * as Schema from "@effect/schema/Schema"
import { IPv4Bigint, IPv4BigintBrand } from "the-wireguard-effect/InternetSchemas"

const x: IPv4BigintBrand = IPv4BigintBrand(748392749382n)
assert.strictEqual(x, 748392749382n)

const decodeIPv4Bigint = Schema.decodeSync(IPv4Bigint)
const encodeIPv4Bigint = Schema.encodeSync(IPv4Bigint)

assert.deepEqual(decodeIPv4Bigint("1.1.1.1"), {
  family: "ipv4",
  value: 16843009n
})
assert.deepEqual(decodeIPv4Bigint("254.254.254.254"), {
  family: "ipv4",
  value: 4278124286n
})

assert.strictEqual(
  encodeIPv4Bigint({
    value: IPv4BigintBrand(16843009n),
    family: "ipv4"
  }),
  "1.1.1.1"
)
assert.strictEqual(
  encodeIPv4Bigint({
    value: IPv4BigintBrand(4278124286n),
    family: "ipv4"
  }),
  "254.254.254.254"
)

export declare const IPv4CidrBlock: $IPv4CidrBlock

export declare const IPv4CidrBlockFromString: $IPv4CidrBlockFromString

export declare const IPv4CidrMask: $IPv4CidrMask

import * as Schema from "@effect/schema/Schema"
import { IPv4CidrMask, IPv4CidrMaskBrand } from "the-wireguard-effect/InternetSchemas"

const mask: IPv4CidrMaskBrand = IPv4CidrMaskBrand(24)
assert.strictEqual(mask, 24)

const decodeMask = Schema.decodeSync(IPv4CidrMask)
assert.strictEqual(decodeMask(24), 24)

assert.throws(() => decodeMask(33))
assert.doesNotThrow(() => decodeMask(0))
assert.doesNotThrow(() => decodeMask(32))

export declare const IPv4Endpoint: $IPv4Endpoint

import * as Schema from "@effect/schema/Schema"
import { IPv4Endpoint } from "the-wireguard-effect/InternetSchemas"

const decodeEndpoint = Schema.decodeSync(IPv4Endpoint)
const endpoint1 = decodeEndpoint("1.2.3.4:51820")
const endpoint2 = decodeEndpoint("1.2.3.4:51820:41820")

const endpoint3 = decodeEndpoint({
  ip: "1.2.3.4",
  port: 51820,
  family: "ipv4"
})

const endpoint4 = decodeEndpoint({
  ip: "1.2.3.4",
  natPort: 51820,
  listenPort: 41820,
  family: "ipv4"
})

export declare const IPv4Family: $IPv4Family

export declare const IPv4SetupData: $IPv4SetupData

import * as Schema from "@effect/schema/Schema"
import { SetupData } from "the-wireguard-effect/InternetSchemas"

const decodeSetupData = Schema.decodeSync(SetupData)
const setupData = decodeSetupData(["1.1.1.1:51280", "10.0.0.1"])

export declare const IPv6: $IPv6

import * as Schema from "@effect/schema/Schema"
import { IPv6 } from "the-wireguard-effect/InternetSchemas"

const decodeIPv6 = Schema.decodeSync(IPv6)
assert.deepEqual(decodeIPv6("2001:0db8:85a3:0000:0000:8a2e:0370:7334"), {
  family: "ipv6",
  ip: "2001:0db8:85a3:0000:0000:8a2e:0370:7334"
})

assert.throws(() => decodeIPv6("2001:0db8:85a3:0000:0000:8a2e:0370:7334:"))
assert.throws(() => decodeIPv6("2001::85a3::0000::0370:7334"))
assert.doesNotThrow(() => decodeIPv6("2001:0db8:85a3:0000:0000:8a2e:0370:7334"))

export declare const IPv6Bigint: $IPv6Bigint

import * as Schema from "@effect/schema/Schema"
import { IPv6Bigint, IPv6BigintBrand } from "the-wireguard-effect/InternetSchemas"

const y: IPv6BigintBrand = IPv6BigintBrand(748392749382n)
assert.strictEqual(y, 748392749382n)

const decodeIPv6Bigint = Schema.decodeSync(IPv6Bigint)
const encodeIPv6Bigint = Schema.encodeSync(IPv6Bigint)

assert.deepEqual(decodeIPv6Bigint("4cbd:ff70:e62b:a048:686c:4e7e:a68a:c377"), {
  value: 102007852745154114519525620108359287671n,
  family: "ipv6"
})
assert.deepEqual(decodeIPv6Bigint("d8c6:3feb:46e6:b80c:5a07:6227:ac19:caf6"), {
  value: 288142618299897818094313964584331496182n,
  family: "ipv6"
})

assert.deepEqual(
  encodeIPv6Bigint({
    value: IPv6BigintBrand(102007852745154114519525620108359287671n),
    family: "ipv6"
  }),
  "4cbd:ff70:e62b:a048:686c:4e7e:a68a:c377"
)
assert.deepEqual(
  encodeIPv6Bigint({
    value: IPv6BigintBrand(288142618299897818094313964584331496182n),
    family: "ipv6"
  }),
  "d8c6:3feb:46e6:b80c:5a07:6227:ac19:caf6"
)

export declare const IPv6CidrBlock: $IPv6CidrBlock

export declare const IPv6CidrBlockFromString: $IPv6CidrBlockFromString

export declare const IPv6CidrMask: $IPv6CidrMask

import * as Schema from "@effect/schema/Schema"
import { IPv6CidrMask, IPv6CidrMaskBrand } from "the-wireguard-effect/InternetSchemas"

const mask: IPv6CidrMaskBrand = IPv6CidrMaskBrand(64)
assert.strictEqual(mask, 64)

const decodeMask = Schema.decodeSync(IPv6CidrMask)
assert.strictEqual(decodeMask(64), 64)

assert.throws(() => decodeMask(129))
assert.doesNotThrow(() => decodeMask(0))
assert.doesNotThrow(() => decodeMask(128))

export declare const IPv6Endpoint: $IPv6Endpoint

import * as Schema from "@effect/schema/Schema"
import { IPv6Endpoint } from "the-wireguard-effect/InternetSchemas"

const decodeEndpoint = Schema.decodeSync(IPv6Endpoint)
const endpoint1 = decodeEndpoint("[2001:0db8:85a3:0000:0000:8a2e:0370:7334]:51820")
const endpoint2 = decodeEndpoint("[2001:0db8:85a3:0000:0000:8a2e:0370:7334]:51820:41820")

const endpoint3 = decodeEndpoint({
  ip: "2001:0db8:85a3:0000:0000:8a2e:0370:7334",
  port: 51820,
  family: "ipv6"
})

const endpoint4 = decodeEndpoint({
  ip: "2001:0db8:85a3:0000:0000:8a2e:0370:7334",
  natPort: 51820,
  listenPort: 41820,
  family: "ipv6"
})

export declare const IPv6Family: $IPv6Family

export declare const IPv6SetupData: $IPv6SetupData

import * as Schema from "@effect/schema/Schema"
import { SetupData } from "the-wireguard-effect/InternetSchemas"

const decodeSetupData = Schema.decodeSync(SetupData)
const setupData = decodeSetupData(["1.1.1.1:51280", "10.0.0.1"])

export declare const Port: $Port

import * as Schema from "@effect/schema/Schema"
import { Port, PortBrand } from "the-wireguard-effect/InternetSchemas"

const port: PortBrand = PortBrand(8080)
assert.strictEqual(port, 8080)

const decodePort = Schema.decodeSync(Port)
assert.strictEqual(decodePort(8080), 8080)

assert.throws(() => decodePort(65536))
assert.doesNotThrow(() => decodePort(8080))

export declare const SetupData: $SetupData

import * as Schema from "@effect/schema/Schema"
import { SetupData } from "the-wireguard-effect/InternetSchemas"

const decodeSetupData = Schema.decodeSync(SetupData)
const setupData = decodeSetupData(["1.1.1.1:51280", "10.0.0.1"])