/**
 * @since 1.0.0
 */
import * as ParseResult from "@effect/schema/ParseResult";
import * as Schema from "@effect/schema/Schema";
import * as Stream from "effect/Stream";
/**
 * An operating system port number.
 *
 * @example
 * import * as Schema from "@effect/schema/Schema"
 * import { Port } from "the-wireguard-effect/InternetSchemas"
 *
 * const port: Port = Port(8080)
 * assert.strictEqual(port, 8080)
 *
 * const decodePort = Schema.decodeSync(Port)
 * assert.strictEqual(decodePort(8080), 8080)
 *
 * assert.throws(() => decodePort(65536))
 * assert.doesNotThrow(() => decodePort(8080))
 *
 * @since 1.0.0
 * @category Datatypes
 */
export declare const Port: Schema.brand<Schema.Schema<number, number, never>, "Port">;
/** @since 1.0.0 */
export type Port = Schema.Schema.Type<typeof Port>;
/**
 * An IPv4 address.
 *
 * @example
 * import * as Schema from "@effect/schema/Schema"
 * import { IPv4 } from "the-wireguard-effect/InternetSchemas"
 *
 * const ipv4: IPv4 = IPv4("1.1.1.1")
 * assert.strictEqual(ipv4, "1.1.1.1")
 *
 * const decodeIPv4 = Schema.decodeSync(IPv4)
 * assert.strictEqual(decodeIPv4("1.1.1.1"), "1.1.1.1")
 *
 * assert.throws(() => decodeIPv4("1.1.a.1"))
 * assert.doesNotThrow(() => decodeIPv4("1.1.1.1"))
 *
 * @since 1.0.0
 * @category Datatypes
 */
export declare const IPv4: Schema.brand<Schema.Schema<string, string, never>, "IPv4">;
/** @since 1.0.0 */
export type IPv4 = Schema.Schema.Type<typeof IPv4>;
/**
 * An IPv6 address.
 *
 * @example
 * import * as Schema from "@effect/schema/Schema"
 * import { IPv6 } from "the-wireguard-effect/InternetSchemas"
 *
 * const ipv6: IPv6 = IPv6("2001:0db8:85a3:0000:0000:8a2e:0370:7334")
 * assert.strictEqual(ipv6, "2001:0db8:85a3:0000:0000:8a2e:0370:7334")
 *
 * const decodeIPv6 = Schema.decodeSync(IPv6)
 * assert.deepStrictEqual(
 *      decodeIPv6("2001:0db8:85a3:0000:0000:8a2e:0370:7334"),
 *      "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"))
 *
 * @since 1.0.0
 * @category Datatypes
 */
export declare const IPv6: Schema.brand<Schema.Schema<string, string, never>, "IPv6">;
/** @since 1.0.0 */
export type IPv6 = Schema.Schema.Type<typeof IPv6>;
/**
 * An IP address, which is either an IPv4 or IPv6 address.
 *
 * @see {@link IPv4}
 * @see {@link IPv6}
 *
 * @example
 * import * as Schema from "@effect/schema/Schema"
 * import { Address } from "the-wireguard-effect/InternetSchemas"
 *
 * const address1: Address = Address("1.1.1.1")
 * const address2: Address = Address("2001:0db8:85a3:0000:0000:8a2e:0370:7334")
 *
 * 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"))
 *
 * @since 1.0.0
 * @category Datatypes
 */
export declare const Address: Schema.brand<Schema.union<[Schema.brand<Schema.Schema<string, string, never>, "IPv4">, Schema.brand<Schema.Schema<string, string, never>, "IPv6">]>, "Address">;
/** @since 1.0.0 */
export type Address = Schema.Schema.Type<typeof Address>;
/**
 * An IPv4 address as a bigint, helpful for some cidr and subnet related calculations.
 *
 * @example
 * import * as Schema from "@effect/schema/Schema"
 * import { IPv4Bigint } from "the-wireguard-effect/InternetSchemas"
 *
 * const decodeIPv4Bigint = Schema.decodeSync(IPv4Bigint)
 * assert.deepStrictEqual(
 *      decodeIPv4Bigint("1.1.1.1"),
 *     { value: 16843009n, family: "ipv4" }
 * )
 *
 * const encodeIPv4Bigint = Schema.encodeSync(IPv4Bigint)
 * assert.strictEqual(
 *      encodeIPv4Bigint({ value: 16843009n, family: "ipv4" }),
 *      "1.1.1.1"
 * )
 *
 * assert.throws(() => decodeIPv4Bigint("1.1.1.1000"))
 * assert.doesNotThrow(() => decodeIPv4Bigint("2.2.2.2"))
 *
 * @since 1.0.0
 * @category Datatypes
 */
export declare const IPv4Bigint: Schema.transformOrFail<Schema.brand<Schema.Schema<string, string, never>, "IPv4">, Schema.struct<{
    value: Schema.bigintFromSelf;
    family: Schema.literal<["ipv4"]>;
}>, never>;
/** @since 1.0.0 */
export type IPv4Bigint = Schema.Schema.Type<typeof IPv4Bigint>;
/**
 * An IPv6 address as a bigint, helpful for some cidr and subnet related calculations.
 *
 * @example
 * import * as Schema from "@effect/schema/Schema"
 * import { IPv6Bigint } from "the-wireguard-effect/InternetSchemas"
 *
 * const decodeIPv6Bigint = Schema.decodeSync(IPv6Bigint)
 * assert.deepStrictEqual(
 *      decodeIPv6Bigint("2001:db8:85a3::8a2e:370:7334"),
 *      { value: 42540766452641154071740215577757643572n, family: "ipv6" }
 * )
 *
 * const encodeIPv6Bigint = Schema.encodeSync(IPv6Bigint)
 * assert.strictEqual(
 *      encodeIPv6Bigint({ value: 42540766452641154071740215577757643572n, family: "ipv6" }),
 *      "2001:0db8:85a3:0000:0000:8a2e:0370:7334"
 * )
 *
 * assert.throws(() => decodeIPv6Bigint("2001:0db8:85a3:0000:0000:8a2e:0370:7334:"))
 * assert.doesNotThrow(() => decodeIPv6Bigint("2001:0db8:85a3:0000:0000:8a2e:0370:7334"))
 *
 * @since 1.0.0
 * @category Datatypes
 */
export declare const IPv6Bigint: Schema.transformOrFail<Schema.brand<Schema.Schema<string, string, never>, "IPv6">, Schema.struct<{
    value: Schema.bigintFromSelf;
    family: Schema.literal<["ipv6"]>;
}>, never>;
/** @since 1.0.0 */
export type IPv6Bigint = Schema.Schema.Type<typeof IPv6Bigint>;
/**
 * An IP address as a bigint, helpful for some cidr and subnet related calculations.
 *
 * @see {@link IPv4Bigint}
 * @see {@link IPv6Bigint}
 *
 * @example
 * import * as Schema from "@effect/schema/Schema"
 * import { BigintFromAddress } from "the-wireguard-effect/InternetSchemas"
 *
 * const address1 = Schema.decodeSync(BigintFromAddress)("1.1.1.1")
 * const address2 = Schema.decodeSync(BigintFromAddress)("2001:0db8:85a3:0000:0000:8a2e:0370:7334")
 *
 * @since 1.0.0
 * @category Datatypes
 */
export declare const BigintFromAddress: Schema.union<[Schema.transformOrFail<Schema.brand<Schema.Schema<string, string, never>, "IPv4">, Schema.struct<{
    value: Schema.bigintFromSelf;
    family: Schema.literal<["ipv4"]>;
}>, never>, Schema.transformOrFail<Schema.brand<Schema.Schema<string, string, never>, "IPv6">, Schema.struct<{
    value: Schema.bigintFromSelf;
    family: Schema.literal<["ipv6"]>;
}>, never>]>;
/** @since 1.0.0 */
export type BigintFromAddress = Schema.Schema.Type<typeof BigintFromAddress>;
/**
 * An ipv4 cidr mask, which is a number between 0 and 32.
 *
 * @example
 * import * as Schema from "@effect/schema/Schema"
 * import { IPv4CidrMask } from "the-wireguard-effect/InternetSchemas"
 *
 * const mask: IPv4CidrMask = IPv4CidrMask(24)
 * assert.strictEqual(mask, 24)
 *
 * const decodeMask = Schema.decodeSync(IPv4CidrMask)
 * assert.strictEqual(decodeMask(24), 24)
 *
 * assert.throws(() => IPv4CidrMask(33))
 * assert.doesNotThrow(() => IPv4CidrMask(0))
 * assert.doesNotThrow(() => IPv4CidrMask(32))
 *
 * @since 1.0.0
 * @category Datatypes
 */
export declare const IPv4CidrMask: Schema.brand<Schema.Schema<number, number, never>, "IPv4CidrMask">;
/** @since 1.0.0 */
export type IPv4CidrMask = Schema.Schema.Type<typeof IPv4CidrMask>;
/**
 * An ipv6 cidr mask, which is a number between 0 and 128.
 *
 * @example
 * import * as Schema from "@effect/schema/Schema"
 * import { IPv6CidrMask } from "the-wireguard-effect/InternetSchemas"
 *
 * const mask: IPv6CidrMask = IPv6CidrMask(64)
 * assert.strictEqual(mask, 64)
 *
 * const decodeMask = Schema.decodeSync(IPv6CidrMask)
 * assert.strictEqual(decodeMask(64), 64)
 *
 * assert.throws(() => IPv6CidrMask(129))
 * assert.doesNotThrow(() => IPv6CidrMask(0))
 * assert.doesNotThrow(() => IPv6CidrMask(128))
 *
 * @since 1.0.0
 * @category Datatypes
 */
export declare const IPv6CidrMask: Schema.brand<Schema.Schema<number, number, never>, "IPv6CidrMask">;
/** @since 1.0.0 */
export type IPv6CidrMask = Schema.Schema.Type<typeof IPv6CidrMask>;
declare const CidrBlockInternal_base: Schema.Class<CidrBlockInternal, {
    ip: Schema.brand<Schema.union<[Schema.brand<Schema.Schema<string, string, never>, "IPv4">, Schema.brand<Schema.Schema<string, string, never>, "IPv6">]>, "Address">;
    mask: Schema.union<[Schema.brand<Schema.Schema<number, number, never>, "IPv4CidrMask">, Schema.brand<Schema.Schema<number, number, never>, "IPv6CidrMask">]>;
    family: Schema.union<[Schema.literal<["ipv4"]>, Schema.literal<["ipv6"]>]>;
    /**
     * The first address in the range given by this address' subnet, often referred to as the Network Address.
     */
    networkAddress: Schema.brand<Schema.union<[Schema.brand<Schema.Schema<string, string, never>, "IPv4">, Schema.brand<Schema.Schema<string, string, never>, "IPv6">]>, "Address">;
    /**
     * The last address in the range given by this address' subnet, often referred to as the Broadcast Address.
     */
    broadcastAddress: Schema.brand<Schema.union<[Schema.brand<Schema.Schema<string, string, never>, "IPv4">, Schema.brand<Schema.Schema<string, string, never>, "IPv6">]>, "Address">;
}, {
    readonly family: "ipv4" | "ipv6";
    readonly ip: ((string & import("effect/Brand").Brand<"IPv4">) | (string & import("effect/Brand").Brand<"IPv6">)) & import("effect/Brand").Brand<"Address">;
    readonly mask: (number & import("effect/Brand").Brand<"IPv4CidrMask">) | (number & import("effect/Brand").Brand<"IPv6CidrMask">);
    readonly networkAddress: ((string & import("effect/Brand").Brand<"IPv4">) | (string & import("effect/Brand").Brand<"IPv6">)) & import("effect/Brand").Brand<"Address">;
    readonly broadcastAddress: ((string & import("effect/Brand").Brand<"IPv4">) | (string & import("effect/Brand").Brand<"IPv6">)) & import("effect/Brand").Brand<"Address">;
}, {
    readonly family: "ipv4" | "ipv6";
    readonly ip: string;
    readonly mask: number;
    readonly networkAddress: string;
    readonly broadcastAddress: string;
}, never, {
    readonly family: "ipv4" | "ipv6";
    readonly ip: ((string & import("effect/Brand").Brand<"IPv4">) | (string & import("effect/Brand").Brand<"IPv6">)) & import("effect/Brand").Brand<"Address">;
    readonly mask: (number & import("effect/Brand").Brand<"IPv4CidrMask">) | (number & import("effect/Brand").Brand<"IPv6CidrMask">);
    readonly networkAddress: ((string & import("effect/Brand").Brand<"IPv4">) | (string & import("effect/Brand").Brand<"IPv6">)) & import("effect/Brand").Brand<"Address">;
    readonly broadcastAddress: ((string & import("effect/Brand").Brand<"IPv4">) | (string & import("effect/Brand").Brand<"IPv6">)) & import("effect/Brand").Brand<"Address">;
}, {}, {}>;
/**
 * Internal helper representation of a cidr range so that we can do
 * transformations to and from it as we cannot represent a stream
 * using @effect/schema.
 *
 * @since 1.0.0
 * @category Datatypes
 */
export declare class CidrBlockInternal extends CidrBlockInternal_base {
    private readonly networkAddressBigInt;
    private readonly broadcastAddressBigInt;
    /**
     * A stream of all addresses in the range given by this address' subnet.
     *
     * @since 1.0.0
     */
    get range(): Stream.Stream<Address, ParseResult.ParseError, never>;
    get total(): bigint;
}
/**
 * A cidr block, which is an IP address followed by a slash and then a subnet mask.
 *
 * @example
 * import * as Schema from "@effect/schema/Schema"
 *
 * import {
 *      CidrBlock,
 *      IPv4,
 *      IPv4CidrMask,
 *      IPv6,
 *      IPv6CidrMask
 * } from "the-wireguard-effect/InternetSchemas"
 *
 * const block1 = Schema.decodeSync(CidrBlock)("192.168.1.1/24")
 * assert.strictEqual(block1.mask, 24)
 * assert.strictEqual(block1.total, 256n)
 * assert.strictEqual(block1.family, "ipv4")
 * assert.strictEqual(block1.ip, "192.168.1.1")
 * assert.strictEqual(block1.networkAddress, "192.168.1.0")
 * assert.strictEqual(block1.broadcastAddress, "192.168.1.255")
 *
 * const block2 = Schema.decodeSync(CidrBlock)("2001:db8:85a3::8a2e:370:7334/64")
 * assert.strictEqual(block2.mask, 64)
 * assert.strictEqual(block2.family, "ipv6")
 * assert.strictEqual(block2.total, 18446744073709551616n)
 * assert.strictEqual(block2.ip, "2001:db8:85a3::8a2e:370:7334")
 * assert.strictEqual(block2.networkAddress, "2001:0db8:85a3:0000:0000:0000:0000:0000")
 * assert.strictEqual(block2.broadcastAddress, "2001:0db8:85a3:0000:ffff:ffff:ffff:ffff")
 *
 * @since 1.0.0
 * @category Datatypes
 */
export declare const CidrBlock: Schema.brand<Schema.transformOrFail<Schema.union<[Schema.struct<{
    ipv4: Schema.brand<Schema.Schema<string, string, never>, "IPv4">;
    mask: Schema.brand<Schema.Schema<number, number, never>, "IPv4CidrMask">;
}>, Schema.struct<{
    ipv6: Schema.brand<Schema.Schema<string, string, never>, "IPv6">;
    mask: Schema.brand<Schema.Schema<number, number, never>, "IPv6CidrMask">;
}>, Schema.Schema<`${string}/${number}`, `${string}/${number}`, never>]>, typeof CidrBlockInternal, never>, "CidrBlock">;
/** @since 1.0.0 */
export type CidrBlock = Schema.Schema.Type<typeof CidrBlock>;
/** @since 1.0.0 */
export type CidrBlockEncoded = Schema.Schema.Encoded<typeof CidrBlock>;
/**
 * An IPv4 wireguard endpoint, which consists of an IPv4 address followed by a
 * nat port then an optional local port. If only one port is provided, it is
 * assumed that the nat port and listen port are the same.
 *
 * @example
 * import * as Schema from "@effect/schema/Schema"
 *
 * import {
 *      Port,
 *      IPv4,
 *      IPv4Endpoint
 * } from "the-wireguard-effect/InternetSchemas"
 *
 * const endpoint1 = Schema.decodeSync(IPv4Endpoint)("1.2.3.4:51820")
 * const endpoint2 = Schema.decodeSync(IPv4Endpoint)("1.2.3.4:51820:41820")
 *
 * const endpoint3 = Schema.decodeSync(IPv4Endpoint)({
 *      ip: "1.2.3.4",
 *      port: 51820,
 * })
 *
 * const endpoint4: IPv4Endpoint = IPv4Endpoint({
 *      ip: IPv4("1.2.3.4"),
 *      natPort: Port(51820),
 *      listenPort: Port(41820)
 * })
 *
 * @since 1.0.0
 * @category Datatypes
 */
export declare const IPv4Endpoint: Schema.brand<Schema.transformOrFail<Schema.union<[Schema.struct<{
    ip: Schema.brand<Schema.Schema<string, string, never>, "IPv4">;
    port: Schema.brand<Schema.Schema<number, number, never>, "Port">;
}>, Schema.struct<{
    ip: Schema.brand<Schema.Schema<string, string, never>, "IPv4">;
    natPort: Schema.brand<Schema.Schema<number, number, never>, "Port">;
    listenPort: Schema.brand<Schema.Schema<number, number, never>, "Port">;
}>, Schema.Schema<`${string}:${number}`, `${string}:${number}`, never>, Schema.Schema<`${string}:${number}:${number}`, `${string}:${number}:${number}`, never>]>, Schema.struct<{
    ip: Schema.brand<Schema.Schema<string, string, never>, "IPv4">;
    natPort: Schema.brand<Schema.Schema<number, number, never>, "Port">;
    listenPort: Schema.brand<Schema.Schema<number, number, never>, "Port">;
}>, never>, "IPv4Endpoint">;
/** @since 1.0.0 */
export type IPv4Endpoint = Schema.Schema.Type<typeof IPv4Endpoint>;
/** @since 1.0.0 */
export type IPv4EndpointEncoded = Schema.Schema.Encoded<typeof IPv4Endpoint>;
/**
 * An IPv6 wireguard endpoint, which consists of an IPv6 address in square
 * brackets followed by a nat port then an optional local port. If only one
 * port is provided, it is assumed that the nat port and listen port are the
 * same.
 *
 * @example
 * import * as Schema from "@effect/schema/Schema"
 *
 * import {
 *      Port,
 *      IPv6,
 *      IPv6Endpoint
 * } from "the-wireguard-effect/InternetSchemas"
 *
 * const endpoint1 = Schema.decodeSync(IPv6Endpoint)("[2001:0db8:85a3:0000:0000:8a2e:0370:7334]:51820")
 * const endpoint2 = Schema.decodeSync(IPv6Endpoint)("[2001:0db8:85a3:0000:0000:8a2e:0370:7334]:51820:41820")
 *
 * const endpoint3 = Schema.decodeSync(IPv6Endpoint)({
 *      ip: "2001:0db8:85a3:0000:0000:8a2e:0370:7334",
 *      port: 51820,
 * })
 *
 * const endpoint4: IPv6Endpoint = IPv6Endpoint({
 *      ip: IPv6("2001:0db8:85a3:0000:0000:8a2e:0370:7334"),
 *      natPort: Port(51820),
 *      listenPort: Port(41820)
 * })
 *
 * @since 1.0.0
 * @category Datatypes
 */
export declare const IPv6Endpoint: Schema.brand<Schema.transformOrFail<Schema.union<[Schema.struct<{
    ip: Schema.brand<Schema.Schema<string, string, never>, "IPv6">;
    port: Schema.brand<Schema.Schema<number, number, never>, "Port">;
}>, Schema.struct<{
    ip: Schema.brand<Schema.Schema<string, string, never>, "IPv6">;
    natPort: Schema.brand<Schema.Schema<number, number, never>, "Port">;
    listenPort: Schema.brand<Schema.Schema<number, number, never>, "Port">;
}>, Schema.Schema<`[${string}]:${number}`, `[${string}]:${number}`, never>, Schema.Schema<`[${string}]:${number}:${number}`, `[${string}]:${number}:${number}`, never>]>, Schema.struct<{
    ip: Schema.brand<Schema.Schema<string, string, never>, "IPv6">;
    natPort: Schema.brand<Schema.Schema<number, number, never>, "Port">;
    listenPort: Schema.brand<Schema.Schema<number, number, never>, "Port">;
}>, never>, "IPv6Endpoint">;
/** @since 1.0.0 */
export type IPv6Endpoint = Schema.Schema.Type<typeof IPv6Endpoint>;
/** @since 1.0.0 */
export type IPv6EndpointEncoded = Schema.Schema.Encoded<typeof IPv6Endpoint>;
/**
 * A wireguard endpoint, which is either an IPv4 or IPv6 endpoint.
 *
 * @see {@link IPv4Endpoint}
 * @see {@link IPv6Endpoint}
 *
 * @example
 * import * as Schema from "@effect/schema/Schema"
 *
 * import {
 *      Endpoint,
 *      IPv4,
 *      IPv6,
 *      Port
 * } from "the-wireguard-effect/InternetSchemas"
 *
 * const endpoint1 = Schema.decodeSync(Endpoint)("1.2.3.4:51820")
 * const endpoint2 = Schema.decodeSync(Endpoint)("1.2.3.4:51820:41820")
 *
 * const endpoint3 = Schema.decodeSync(Endpoint)({
 *      ip: "1.2.3.4",
 *      port: 51820,
 * })
 *
 * const endpoint4: Endpoint = Endpoint({
 *      ip: IPv4("1.2.3.4"),
 *      natPort: Port(51820),
 *      listenPort: Port(41820),
 * })
 *
 * const endpoint5 = Schema.decodeSync(Endpoint)("[2001:0db8:85a3:0000:0000:8a2e:0370:7334]:51820")
 * const endpoint6 = Schema.decodeSync(Endpoint)("[2001:0db8:85a3:0000:0000:8a2e:0370:7334]:51820:41820")
 *
 * const endpoint7 = Schema.decodeSync(Endpoint)({
 *      ip: "2001:0db8:85a3:0000:0000:8a2e:0370:7334",
 *      port: 51820,
 * })
 *
 * const endpoint8: Endpoint = Endpoint({
 *      ip: IPv6("2001:0db8:85a3:0000:0000:8a2e:0370:7334"),
 *      natPort: Port(51820),
 *      listenPort: Port(41820),
 * })
 *
 * @since 1.0.0
 * @category Datatypes
 */
export declare const Endpoint: Schema.brand<Schema.union<[Schema.brand<Schema.transformOrFail<Schema.union<[Schema.struct<{
    ip: Schema.brand<Schema.Schema<string, string, never>, "IPv4">;
    port: Schema.brand<Schema.Schema<number, number, never>, "Port">;
}>, Schema.struct<{
    ip: Schema.brand<Schema.Schema<string, string, never>, "IPv4">;
    natPort: Schema.brand<Schema.Schema<number, number, never>, "Port">;
    listenPort: Schema.brand<Schema.Schema<number, number, never>, "Port">;
}>, Schema.Schema<`${string}:${number}`, `${string}:${number}`, never>, Schema.Schema<`${string}:${number}:${number}`, `${string}:${number}:${number}`, never>]>, Schema.struct<{
    ip: Schema.brand<Schema.Schema<string, string, never>, "IPv4">;
    natPort: Schema.brand<Schema.Schema<number, number, never>, "Port">;
    listenPort: Schema.brand<Schema.Schema<number, number, never>, "Port">;
}>, never>, "IPv4Endpoint">, Schema.brand<Schema.transformOrFail<Schema.union<[Schema.struct<{
    ip: Schema.brand<Schema.Schema<string, string, never>, "IPv6">;
    port: Schema.brand<Schema.Schema<number, number, never>, "Port">;
}>, Schema.struct<{
    ip: Schema.brand<Schema.Schema<string, string, never>, "IPv6">;
    natPort: Schema.brand<Schema.Schema<number, number, never>, "Port">;
    listenPort: Schema.brand<Schema.Schema<number, number, never>, "Port">;
}>, Schema.Schema<`[${string}]:${number}`, `[${string}]:${number}`, never>, Schema.Schema<`[${string}]:${number}:${number}`, `[${string}]:${number}:${number}`, never>]>, Schema.struct<{
    ip: Schema.brand<Schema.Schema<string, string, never>, "IPv6">;
    natPort: Schema.brand<Schema.Schema<number, number, never>, "Port">;
    listenPort: Schema.brand<Schema.Schema<number, number, never>, "Port">;
}>, never>, "IPv6Endpoint">]>, "Endpoint">;
/** @since 1.0.0 */
export type Endpoint = Schema.Schema.Type<typeof Endpoint>;
/** @since 1.0.0 */
export type EndpointEncoded = Schema.Schema.Encoded<typeof Endpoint>;
/**
 * A wireguard setup data, which consists of an endpoint followed by an address.
 *
 * @see {@link Endpoint}
 * @see {@link Address}
 *
 * @example
 * import * as Schema from "@effect/schema/Schema"
 *
 * import {
 *      Address,
 *      Endpoint,
 *      SetupData
 * } from "the-wireguard-effect/InternetSchemas"
 *
 * const setupData1 = Schema.decodeSync(SetupData)(["1.1.1.1:51280", "10.0.0.1"])
 *
 * const address = Schema.decodeSync(Address)("10.0.0.1")
 * const endpoint = Schema.decodeSync(Endpoint)("1.1.1.1:51820")
 * const setupData2: SetupData = SetupData([endpoint, address])
 *
 * @since 1.0.0
 * @category Datatypes
 */
export declare const SetupData: Schema.brand<Schema.tuple<[Schema.brand<Schema.union<[Schema.brand<Schema.transformOrFail<Schema.union<[Schema.struct<{
    ip: Schema.brand<Schema.Schema<string, string, never>, "IPv4">;
    port: Schema.brand<Schema.Schema<number, number, never>, "Port">;
}>, Schema.struct<{
    ip: Schema.brand<Schema.Schema<string, string, never>, "IPv4">;
    natPort: Schema.brand<Schema.Schema<number, number, never>, "Port">;
    listenPort: Schema.brand<Schema.Schema<number, number, never>, "Port">;
}>, Schema.Schema<`${string}:${number}`, `${string}:${number}`, never>, Schema.Schema<`${string}:${number}:${number}`, `${string}:${number}:${number}`, never>]>, Schema.struct<{
    ip: Schema.brand<Schema.Schema<string, string, never>, "IPv4">;
    natPort: Schema.brand<Schema.Schema<number, number, never>, "Port">;
    listenPort: Schema.brand<Schema.Schema<number, number, never>, "Port">;
}>, never>, "IPv4Endpoint">, Schema.brand<Schema.transformOrFail<Schema.union<[Schema.struct<{
    ip: Schema.brand<Schema.Schema<string, string, never>, "IPv6">;
    port: Schema.brand<Schema.Schema<number, number, never>, "Port">;
}>, Schema.struct<{
    ip: Schema.brand<Schema.Schema<string, string, never>, "IPv6">;
    natPort: Schema.brand<Schema.Schema<number, number, never>, "Port">;
    listenPort: Schema.brand<Schema.Schema<number, number, never>, "Port">;
}>, Schema.Schema<`[${string}]:${number}`, `[${string}]:${number}`, never>, Schema.Schema<`[${string}]:${number}:${number}`, `[${string}]:${number}:${number}`, never>]>, Schema.struct<{
    ip: Schema.brand<Schema.Schema<string, string, never>, "IPv6">;
    natPort: Schema.brand<Schema.Schema<number, number, never>, "Port">;
    listenPort: Schema.brand<Schema.Schema<number, number, never>, "Port">;
}>, never>, "IPv6Endpoint">]>, "Endpoint">, Schema.brand<Schema.union<[Schema.brand<Schema.Schema<string, string, never>, "IPv4">, Schema.brand<Schema.Schema<string, string, never>, "IPv6">]>, "Address">]>, "SetupData">;
/** @since 1.0.0 */
export type SetupData = Schema.Schema.Type<typeof SetupData>;
/** @since 1.0.0 */
export type SetupDataEncoded = Schema.Schema.Encoded<typeof SetupData>;
export {};
//# sourceMappingURL=InternetSchemas.d.ts.map