@aragon/gov-ui-kit 1.26.0 → 1.27.0

package/dist/types/node_modules/.pnpm/ox@0.11.3_typescript@5.9.3_zod@3.25.76/node_modules/ox/core/Address.d.ts

@@ -0,0 +1,228 @@
+import type { Address as abitype_Address } from 'abitype';
+import * as Bytes from './Bytes.js';
+import * as Errors from './Errors.js';
+import * as Hash from './Hash.js';
+import * as PublicKey from './PublicKey.js';
+/** Root type for Address. */
+export type Address = abitype_Address;
+/**
+ * Asserts that the given value is a valid {@link ox#Address.Address}.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Address } from 'ox'
+ *
+ * Address.assert('0xA0Cf798816D4b9b9866b5330EEa46a18382f251e')
+ * ```
+ *
+ * @example
+ * ```ts twoslash
+ * import { Address } from 'ox'
+ *
+ * Address.assert('0xdeadbeef')
+ * // @error: InvalidAddressError: Address "0xdeadbeef" is invalid.
+ * ```
+ *
+ * @param value - Value to assert if it is a valid address.
+ * @param options - Assertion options.
+ */
+export declare function assert(value: string, options?: assert.Options): asserts value is Address;
+export declare namespace assert {
+    type Options = {
+        /**
+         * Enables strict mode. Whether or not to compare the address against its checksum.
+         *
+         * @default true
+         */
+        strict?: boolean | undefined;
+    };
+    type ErrorType = InvalidAddressError | Errors.GlobalErrorType;
+}
+/**
+ * Computes the checksum address for the given {@link ox#Address.Address}.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Address } from 'ox'
+ *
+ * Address.checksum('0xa0cf798816d4b9b9866b5330eea46a18382f251e')
+ * // @log: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e'
+ * ```
+ *
+ * @param address - The address to compute the checksum for.
+ * @returns The checksummed address.
+ */
+export declare function checksum(address: string): Address;
+export declare namespace checksum {
+    type ErrorType = assert.ErrorType | Hash.keccak256.ErrorType | Bytes.fromString.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Converts a stringified address to a typed (optionally checksummed) {@link ox#Address.Address}.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Address } from 'ox'
+ *
+ * Address.from('0xa0cf798816d4b9b9866b5330eea46a18382f251e')
+ * // @log: '0xa0cf798816d4b9b9866b5330eea46a18382f251e'
+ * ```
+ *
+ * @example
+ * ```ts twoslash
+ * import { Address } from 'ox'
+ *
+ * Address.from('0xa0cf798816d4b9b9866b5330eea46a18382f251e', {
+ *   checksum: true
+ * })
+ * // @log: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e'
+ * ```
+ *
+ * @example
+ * ```ts twoslash
+ * import { Address } from 'ox'
+ *
+ * Address.from('hello')
+ * // @error: InvalidAddressError: Address "0xa" is invalid.
+ * ```
+ *
+ * @param address - An address string to convert to a typed Address.
+ * @param options - Conversion options.
+ * @returns The typed Address.
+ */
+export declare function from(address: string, options?: from.Options): Address;
+export declare namespace from {
+    type Options = {
+        /**
+         * Whether to checksum the address.
+         *
+         * @default false
+         */
+        checksum?: boolean | undefined;
+    };
+    type ErrorType = assert.ErrorType | checksum.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Converts an ECDSA public key to an {@link ox#Address.Address}.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Address, PublicKey } from 'ox'
+ *
+ * const publicKey = PublicKey.from(
+ *   '0x048318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed753547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5',
+ * )
+ * const address = Address.fromPublicKey(publicKey)
+ * // @log: '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266'
+ * ```
+ *
+ * @param publicKey - The ECDSA public key to convert to an {@link ox#Address.Address}.
+ * @param options - Conversion options.
+ * @returns The {@link ox#Address.Address} corresponding to the public key.
+ */
+export declare function fromPublicKey(publicKey: PublicKey.PublicKey, options?: fromPublicKey.Options): Address;
+export declare namespace fromPublicKey {
+    type Options = {
+        /**
+         * Whether to checksum the address.
+         *
+         * @default false
+         */
+        checksum?: boolean | undefined;
+    };
+    type ErrorType = Hash.keccak256.ErrorType | PublicKey.toHex.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Checks if two {@link ox#Address.Address} are equal.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Address } from 'ox'
+ *
+ * Address.isEqual(
+ *   '0xa0cf798816d4b9b9866b5330eea46a18382f251e',
+ *   '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e'
+ * )
+ * // @log: true
+ * ```
+ *
+ * @example
+ * ```ts twoslash
+ * import { Address } from 'ox'
+ *
+ * Address.isEqual(
+ *   '0xa0cf798816d4b9b9866b5330eea46a18382f251e',
+ *   '0xA0Cf798816D4b9b9866b5330EEa46a18382f251f'
+ * )
+ * // @log: false
+ * ```
+ *
+ * @param addressA - The first address to compare.
+ * @param addressB - The second address to compare.
+ * @returns Whether the addresses are equal.
+ */
+export declare function isEqual(addressA: Address, addressB: Address): boolean;
+export declare namespace isEqual {
+    type ErrorType = assert.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Checks if the given address is a valid {@link ox#Address.Address}.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Address } from 'ox'
+ *
+ * Address.validate('0xA0Cf798816D4b9b9866b5330EEa46a18382f251e')
+ * // @log: true
+ * ```
+ *
+ * @example
+ * ```ts twoslash
+ * import { Address } from 'ox'
+ *
+ * Address.validate('0xdeadbeef')
+ * // @log: false
+ * ```
+ *
+ * @param address - Value to check if it is a valid address.
+ * @param options - Check options.
+ * @returns Whether the address is a valid address.
+ */
+export declare function validate(address: string, options?: validate.Options): address is Address;
+export declare namespace validate {
+    type Options = {
+        /**
+         * Enables strict mode. Whether or not to compare the address against its checksum.
+         *
+         * @default true
+         */
+        strict?: boolean | undefined;
+    };
+}
+/**
+ * Thrown when an address is invalid.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Address } from 'ox'
+ *
+ * Address.from('0x123')
+ * // @error: Address.InvalidAddressError: Address `0x123` is invalid.
+ * ```
+ */
+export declare class InvalidAddressError<cause extends InvalidInputError | InvalidChecksumError = InvalidInputError | InvalidChecksumError> extends Errors.BaseError<cause> {
+    readonly name = "Address.InvalidAddressError";
+    constructor({ address, cause }: {
+        address: string;
+        cause: cause;
+    });
+}
+/** Thrown when an address is not a 20 byte (40 hexadecimal character) value. */
+export declare class InvalidInputError extends Errors.BaseError {
+    readonly name = "Address.InvalidInputError";
+    constructor();
+}
+/** Thrown when an address does not match its checksum counterpart. */
+export declare class InvalidChecksumError extends Errors.BaseError {
+    readonly name = "Address.InvalidChecksumError";
+    constructor();
+}

package/dist/types/node_modules/.pnpm/ox@0.11.3_typescript@5.9.3_zod@3.25.76/node_modules/ox/core/Base64.d.ts

@@ -0,0 +1,225 @@
+import * as Bytes from './Bytes.js';
+import type * as Errors from './Errors.js';
+import * as Hex from './Hex.js';
+/**
+ * Encodes a {@link ox#Bytes.Bytes} to a Base64-encoded string (with optional padding and/or URL-safe characters).
+ *
+ * @example
+ * ```ts twoslash
+ * import { Base64, Bytes } from 'ox'
+ *
+ * const value = Base64.fromBytes(Bytes.fromString('hello world'))
+ * // @log: 'aGVsbG8gd29ybGQ='
+ * ```
+ *
+ * @example
+ * ### No Padding
+ *
+ * Turn off [padding of encoded data](https://datatracker.ietf.org/doc/html/rfc4648#section-3.2) with the `pad` option:
+ *
+ * ```ts twoslash
+ * import { Base64, Bytes } from 'ox'
+ *
+ * const value = Base64.fromBytes(Bytes.fromString('hello world'), { pad: false })
+ * // @log: 'aGVsbG8gd29ybGQ'
+ * ```
+ *
+ * ### URL-safe Encoding
+ *
+ * Turn on [URL-safe encoding](https://datatracker.ietf.org/doc/html/rfc4648#section-5) (Base64 URL) with the `url` option:
+ *
+ * ```ts twoslash
+ * import { Base64, Bytes } from 'ox'
+ *
+ * const value = Base64.fromBytes(Bytes.fromString('hello wod'), { url: true })
+ * // @log: 'aGVsbG8gd29_77-9ZA=='
+ * ```
+ *
+ * @param value - The byte array to encode.
+ * @param options - Encoding options.
+ * @returns The Base64 encoded string.
+ */
+export declare function fromBytes(value: Bytes.Bytes, options?: fromBytes.Options): string;
+export declare namespace fromBytes {
+    type Options = {
+        /**
+         * Whether to [pad](https://datatracker.ietf.org/doc/html/rfc4648#section-3.2) the Base64 encoded string.
+         *
+         * @default true
+         */
+        pad?: boolean | undefined;
+        /**
+         * Whether to Base64 encode with [URL safe characters](https://datatracker.ietf.org/doc/html/rfc4648#section-5).
+         *
+         * @default false
+         */
+        url?: boolean | undefined;
+    };
+    type ErrorType = Errors.GlobalErrorType;
+}
+/**
+ * Encodes a {@link ox#Hex.Hex} to a Base64-encoded string (with optional padding and/or URL-safe characters).
+ *
+ * @example
+ * ```ts twoslash
+ * import { Base64, Hex } from 'ox'
+ *
+ * const value = Base64.fromHex(Hex.fromString('hello world'))
+ * // @log: 'aGVsbG8gd29ybGQ='
+ * ```
+ *
+ * @example
+ * ### No Padding
+ *
+ * Turn off [padding of encoded data](https://datatracker.ietf.org/doc/html/rfc4648#section-3.2) with the `pad` option:
+ *
+ * ```ts twoslash
+ * import { Base64, Hex } from 'ox'
+ *
+ * const value = Base64.fromHex(Hex.fromString('hello world'), { pad: false })
+ * // @log: 'aGVsbG8gd29ybGQ'
+ * ```
+ *
+ * ### URL-safe Encoding
+ *
+ * Turn on [URL-safe encoding](https://datatracker.ietf.org/doc/html/rfc4648#section-5) (Base64 URL) with the `url` option:
+ *
+ * ```ts twoslash
+ * import { Base64, Hex } from 'ox'
+ *
+ * const value = Base64.fromHex(Hex.fromString('hello wod'), { url: true })
+ * // @log: 'aGVsbG8gd29_77-9ZA=='
+ * ```
+ *
+ * @param value - The hex value to encode.
+ * @param options - Encoding options.
+ * @returns The Base64 encoded string.
+ */
+export declare function fromHex(value: Hex.Hex, options?: fromHex.Options): string;
+export declare namespace fromHex {
+    type Options = {
+        /**
+         * Whether to [pad](https://datatracker.ietf.org/doc/html/rfc4648#section-3.2) the Base64 encoded string.
+         *
+         * @default true
+         */
+        pad?: boolean | undefined;
+        /**
+         * Whether to Base64 encode with [URL safe characters](https://datatracker.ietf.org/doc/html/rfc4648#section-5).
+         *
+         * @default false
+         */
+        url?: boolean | undefined;
+    };
+    type ErrorType = fromBytes.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Encodes a string to a Base64-encoded string (with optional padding and/or URL-safe characters).
+ *
+ * @example
+ * ```ts twoslash
+ * import { Base64 } from 'ox'
+ *
+ * const value = Base64.fromString('hello world')
+ * // @log: 'aGVsbG8gd29ybGQ='
+ * ```
+ *
+ * @example
+ * ### No Padding
+ *
+ * Turn off [padding of encoded data](https://datatracker.ietf.org/doc/html/rfc4648#section-3.2) with the `pad` option:
+ *
+ * ```ts twoslash
+ * import { Base64 } from 'ox'
+ *
+ * const value = Base64.fromString('hello world', { pad: false })
+ * // @log: 'aGVsbG8gd29ybGQ'
+ * ```
+ *
+ * ### URL-safe Encoding
+ *
+ * Turn on [URL-safe encoding](https://datatracker.ietf.org/doc/html/rfc4648#section-5) (Base64 URL) with the `url` option:
+ *
+ * ```ts twoslash
+ * import { Base64 } from 'ox'
+ *
+ * const value = Base64.fromString('hello wod', { url: true })
+ * // @log: 'aGVsbG8gd29_77-9ZA=='
+ * ```
+ *
+ * @param value - The string to encode.
+ * @param options - Encoding options.
+ * @returns The Base64 encoded string.
+ */
+export declare function fromString(value: string, options?: fromString.Options): string;
+export declare namespace fromString {
+    type Options = {
+        /**
+         * Whether to [pad](https://datatracker.ietf.org/doc/html/rfc4648#section-3.2) the Base64 encoded string.
+         *
+         * @default true
+         */
+        pad?: boolean | undefined;
+        /**
+         * Whether to Base64 encode with [URL safe characters](https://datatracker.ietf.org/doc/html/rfc4648#section-5).
+         *
+         * @default false
+         */
+        url?: boolean | undefined;
+    };
+    type ErrorType = fromBytes.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Decodes a Base64-encoded string (with optional padding and/or URL-safe characters) to {@link ox#Bytes.Bytes}.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Base64, Bytes } from 'ox'
+ *
+ * const value = Base64.toBytes('aGVsbG8gd29ybGQ=')
+ * // @log: Uint8Array([104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100])
+ * ```
+ *
+ * @param value - The string, hex value, or byte array to encode.
+ * @returns The Base64 decoded {@link ox#Bytes.Bytes}.
+ */
+export declare function toBytes(value: string): Bytes.Bytes;
+export declare namespace toBytes {
+    type ErrorType = Errors.GlobalErrorType;
+}
+/**
+ * Decodes a Base64-encoded string (with optional padding and/or URL-safe characters) to {@link ox#Hex.Hex}.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Base64, Hex } from 'ox'
+ *
+ * const value = Base64.toHex('aGVsbG8gd29ybGQ=')
+ * // @log: 0x68656c6c6f20776f726c64
+ * ```
+ *
+ * @param value - The string, hex value, or byte array to encode.
+ * @returns The Base64 decoded {@link ox#Hex.Hex}.
+ */
+export declare function toHex(value: string): Hex.Hex;
+export declare namespace toHex {
+    type ErrorType = toBytes.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Decodes a Base64-encoded string (with optional padding and/or URL-safe characters) to a string.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Base64 } from 'ox'
+ *
+ * const value = Base64.toString('aGVsbG8gd29ybGQ=')
+ * // @log: 'hello world'
+ * ```
+ *
+ * @param value - The string, hex value, or byte array to encode.
+ * @returns The Base64 decoded string.
+ */
+export declare function toString(value: string): string;
+export declare namespace toString {
+    type ErrorType = toBytes.ErrorType | Errors.GlobalErrorType;
+}