Brunobkr/llama.cpp_AlgMor24_github

1import * as common from './common';2/**3 * Represents an IPv4 address4 * @param {string} address - An IPv4 address string5 */6export declare class Address4 {7    address: string;8    addressMinusSuffix: string;9    groups: number;10    parsedAddress: string[];11    parsedSubnet: string;12    subnet: string;13    subnetMask: number;14    v4: boolean;15    private _binaryZeroPad?;16    constructor(address: string);17    /**18     * Returns true if the given string is a valid IPv4 address (with optional19     * CIDR subnet), false otherwise. Host bits in the subnet portion are20     * allowed (e.g. `192.168.1.5/24` is valid); for strict network-address21     * validation compare `correctForm()` to `startAddress().correctForm()`,22     * or use `networkForm()`.23     */24    static isValid(address: string): boolean;25    /**26     * Parses an IPv4 address string into its four octet groups and stores the27     * result on `this.parsedAddress`. Called automatically by the constructor;28     * you typically don't need to call it directly. Throws `AddressError` if29     * the input is not a valid IPv4 address.30     */31    parse(address: string): string[];32    /**33     * Returns the address in correct form: octets joined with `.` and any34     * leading zeros stripped (e.g. `192.168.1.1`). For IPv4 this matches the35     * canonical dotted-decimal representation.36     */37    correctForm(): string;38    /**39     * Returns true if the address is correct, false otherwise40     * @returns {Boolean}41     */42    isCorrect: (this: Address4 | import("./ipv6").Address6) => boolean;43    /**44     * Construct an `Address4` from an address and a dotted-decimal subnet45     * mask given as separate strings (e.g. as returned by Node's46     * `os.networkInterfaces()`). Throws `AddressError` if the mask is47     * non-contiguous (e.g. `255.0.255.0`).48     * @example49     * var address = Address4.fromAddressAndMask('192.168.1.1', '255.255.255.0');50     * address.subnetMask; // 2451     */52    static fromAddressAndMask(address: string, mask: string): Address4;53    /**54     * Construct an `Address4` from an address and a Cisco-style wildcard mask55     * given as separate strings (e.g. `0.0.0.255` for a `/24`). The wildcard56     * mask is the bitwise inverse of the subnet mask. Throws `AddressError`57     * if the mask is non-contiguous (e.g. `0.255.0.255`).58     * @example59     * var address = Address4.fromAddressAndWildcardMask('10.0.0.1', '0.0.0.255');60     * address.subnetMask; // 2461     */62    static fromAddressAndWildcardMask(address: string, wildcardMask: string): Address4;63    /**64     * Construct an `Address4` from a wildcard pattern with trailing `*`65     * octets. The number of trailing wildcards determines the prefix66     * length: each `*` represents 8 bits.67     *68     * Only trailing whole-octet wildcards are supported. Partial-octet69     * wildcards (e.g. `192.168.0.1*`) and interior wildcards (e.g.70     * `192.*.0.1`) throw `AddressError`.71     * @example72     * Address4.fromWildcard('192.168.0.*').subnet;   // '/24'73     * Address4.fromWildcard('192.168.*.*').subnet;   // '/16'74     * Address4.fromWildcard('*.*.*.*').subnet;       // '/0'75     */76    static fromWildcard(input: string): Address4;77    /**78     * Converts a hex string to an IPv4 address object. Accepts 8 hex digits79     * with optional `:` separators (e.g. `'7f000001'` or `'7f:00:00:01'`).80     * Throws `AddressError` for any other length or for non-hex characters.81     * @param {string} hex - a hex string to convert82     * @returns {Address4}83     */84    static fromHex(hex: string): Address4;85    /**86     * Converts an integer into a IPv4 address object. The integer must be a87     * non-negative safe integer in the range `[0, 2**32 - 1]`; otherwise88     * `AddressError` is thrown.89     * @param {integer} integer - a number to convert90     * @returns {Address4}91     */92    static fromInteger(integer: number): Address4;93    /**94     * Return an address from in-addr.arpa form95     * @param {string} arpaFormAddress - an 'in-addr.arpa' form ipv4 address96     * @returns {Adress4}97     * @example98     * var address = Address4.fromArpa(42.2.0.192.in-addr.arpa.)99     * address.correctForm(); // '192.0.2.42'100     */101    static fromArpa(arpaFormAddress: string): Address4;102    /**103     * Converts an IPv4 address object to a hex string104     * @returns {String}105     */106    toHex(): string;107    /**108     * Converts an IPv4 address object to an array of bytes.109     *110     * To get a Node.js `Buffer`, wrap the result: `Buffer.from(address.toArray())`.111     * @returns {Array}112     */113    toArray(): number[];114    /**115     * Converts an IPv4 address object to an IPv6 address group116     * @returns {String}117     */118    toGroup6(): string;119    /**120     * Returns the address as a `bigint`121     * @returns {bigint}122     */123    bigInt(): bigint;124    /**125     * Helper function getting start address.126     * @returns {bigint}127     */128    _startAddress(): bigint;129    /**130     * The first address in the range given by this address' subnet.131     * Often referred to as the Network Address.132     * @returns {Address4}133     */134    startAddress(): Address4;135    /**136     * The first host address in the range given by this address's subnet ie137     * the first address after the Network Address138     * @returns {Address4}139     */140    startAddressExclusive(): Address4;141    /**142     * Helper function getting end address.143     * @returns {bigint}144     */145    _endAddress(): bigint;146    /**147     * The last address in the range given by this address' subnet148     * Often referred to as the Broadcast149     * @returns {Address4}150     */151    endAddress(): Address4;152    /**153     * The last host address in the range given by this address's subnet ie154     * the last address prior to the Broadcast Address155     * @returns {Address4}156     */157    endAddressExclusive(): Address4;158    /**159     * The dotted-decimal form of the subnet mask, e.g. `255.255.240.0` for160     * a `/20`. Returns an `Address4`; call `.correctForm()` for the string.161     * @returns {Address4}162     */163    subnetMaskAddress(): Address4;164    /**165     * The Cisco-style wildcard mask, e.g. `0.0.0.255` for a `/24`. This is166     * the bitwise inverse of `subnetMaskAddress()`. Returns an `Address4`;167     * call `.correctForm()` for the string.168     * @returns {Address4}169     */170    wildcardMask(): Address4;171    /**172     * The network address in CIDR string form, e.g. `192.168.1.0/24` for173     * `192.168.1.5/24`. For an address with no explicit subnet the prefix is174     * `/32`, e.g. `networkForm()` on `192.168.1.5` returns `192.168.1.5/32`.175     * @returns {string}176     */177    networkForm(): string;178    /**179     * Converts a BigInt to a v4 address object. The value must be in the180     * range `[0, 2**32 - 1]`; otherwise `AddressError` is thrown.181     * @param {bigint} bigInt - a BigInt to convert182     * @returns {Address4}183     */184    static fromBigInt(bigInt: bigint): Address4;185    /**186     * Convert a byte array to an Address4 object.187     *188     * To convert from a Node.js `Buffer`, spread it: `Address4.fromByteArray([...buf])`.189     * @param {Array<number>} bytes - an array of 4 bytes (0-255)190     * @returns {Address4}191     */192    static fromByteArray(bytes: Array<number>): Address4;193    /**194     * Convert an unsigned byte array to an Address4 object195     * @param {Array<number>} bytes - an array of 4 unsigned bytes (0-255)196     * @returns {Address4}197     */198    static fromUnsignedByteArray(bytes: Array<number>): Address4;199    /**200     * Returns the first n bits of the address, defaulting to the201     * subnet mask202     * @returns {String}203     */204    mask(mask?: number): string;205    /**206     * Returns the bits in the given range as a base-2 string207     * @returns {string}208     */209    getBitsBase2(start: number, end: number): string;210    /**211     * Return the reversed ip6.arpa form of the address212     * @param {Object} options213     * @param {boolean} options.omitSuffix - omit the "in-addr.arpa" suffix214     * @returns {String}215     */216    reverseForm(options?: common.ReverseFormOptions): string;217    /**218     * Returns true if the given address is in the subnet of the current address219     * @returns {boolean}220     */221    isInSubnet: typeof common.isInSubnet;222    /**223     * Returns true if this address's host bits fall inside the given subnet,224     * ignoring this address's own subnet mask. See225     * {@link common.isHostInSubnet}.226     * @returns {boolean}227     */228    isHostInSubnet: typeof common.isHostInSubnet;229    /**230     * Returns true if the given address is a multicast address231     * @returns {boolean}232     */233    isMulticast(): boolean;234    /**235     * Returns true if the address is in one of the [RFC 1918](https://datatracker.ietf.org/doc/html/rfc1918) private address ranges (`10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`).236     * @returns {boolean}237     */238    isPrivate(): boolean;239    /**240     * Returns true if the address is in the loopback range `127.0.0.0/8` ([RFC 1122](https://datatracker.ietf.org/doc/html/rfc1122)).241     * @returns {boolean}242     */243    isLoopback(): boolean;244    /**245     * Returns true if the address is in the link-local range `169.254.0.0/16` ([RFC 3927](https://datatracker.ietf.org/doc/html/rfc3927)).246     * @returns {boolean}247     */248    isLinkLocal(): boolean;249    /**250     * Returns true if the address is the unspecified address `0.0.0.0`.251     * @returns {boolean}252     */253    isUnspecified(): boolean;254    /**255     * Returns true if the address is the limited broadcast address `255.255.255.255` ([RFC 919](https://datatracker.ietf.org/doc/html/rfc919)).256     * @returns {boolean}257     */258    isBroadcast(): boolean;259    /**260     * Returns true if the address is in the carrier-grade NAT range `100.64.0.0/10` ([RFC 6598](https://datatracker.ietf.org/doc/html/rfc6598)).261     * @returns {boolean}262     */263    isCGNAT(): boolean;264    /**265     * Returns a zero-padded base-2 string representation of the address266     * @returns {string}267     */268    binaryZeroPad(): string;269    /**270     * Groups an IPv4 address for inclusion at the end of an IPv6 address271     * @returns {String}272     */273    groupForV6(): string;274}275