@aragon/gov-ui-kit 1.28.0 → 1.29.1

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

@@ -1,82 +0,0 @@
-import * as Address from './Address.js';
-import * as Errors from './Errors.js';
-import * as Hex from './Hex.js';
-import type { Compute } from './internal/types.js';
-export type AccessList = Compute<readonly Item[]>;
-export type Item = Compute<{
-    address: Address.Address;
-    storageKeys: readonly Hex.Hex[];
-}>;
-export type ItemTuple = Compute<[
-    address: Address.Address,
-    storageKeys: readonly Hex.Hex[]
-]>;
-export type Tuple = readonly ItemTuple[];
-/**
- * Converts a list of Access List tuples into a object-formatted list.
- *
- * @example
- * ```ts twoslash
- * import { AccessList } from 'ox'
- *
- * const accessList = AccessList.fromTupleList([
- *   [
- *     '0x0000000000000000000000000000000000000000',
- *     [
- *       '0x0000000000000000000000000000000000000000000000000000000000000001',
- *       '0x60fdd29ff912ce880cd3edaf9f932dc61d3dae823ea77e0323f94adb9f6a72fe',
- *     ],
- *   ],
- * ])
- * // @log: [
- * // @log:   {
- * // @log:     address: '0x0000000000000000000000000000000000000000',
- * // @log:     storageKeys: [
- * // @log:       '0x0000000000000000000000000000000000000000000000000000000000000001',
- * // @log:       '0x60fdd29ff912ce880cd3edaf9f932dc61d3dae823ea77e0323f94adb9f6a72fe',
- * // @log:     ],
- * // @log:   },
- * // @log: ]
- * ```
- *
- * @param accessList - List of tuples.
- * @returns Access list.
- */
-export declare function fromTupleList(accessList: Tuple): AccessList;
-/**
- * Converts a structured Access List into a list of tuples.
- *
- * @example
- * ```ts twoslash
- * import { AccessList } from 'ox'
- *
- * const accessList = AccessList.toTupleList([
- *   {
- *     address: '0x0000000000000000000000000000000000000000',
- *     storageKeys: [
- *       '0x0000000000000000000000000000000000000000000000000000000000000001',
- *       '0x60fdd29ff912ce880cd3edaf9f932dc61d3dae823ea77e0323f94adb9f6a72fe'],
- *   },
- * ])
- * // @log: [
- * // @log:   [
- * // @log:     '0x0000000000000000000000000000000000000000',
- * // @log:     [
- * // @log:       '0x0000000000000000000000000000000000000000000000000000000000000001',
- * // @log:       '0x60fdd29ff912ce880cd3edaf9f932dc61d3dae823ea77e0323f94adb9f6a72fe',
- * // @log:     ],
- * // @log:   ],
- * // @log: ]
- * ```
- *
- * @param accessList - Access list.
- * @returns List of tuples.
- */
-export declare function toTupleList(accessList?: AccessList | undefined): Compute<Tuple>;
-/** Thrown when the size of a storage key is invalid. */
-export declare class InvalidStorageKeySizeError extends Errors.BaseError {
-    readonly name = "AccessList.InvalidStorageKeySizeError";
-    constructor({ storageKey }: {
-        storageKey: Hex.Hex;
-    });
-}

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

@@ -1,228 +0,0 @@
-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.12.1_typescript@5.9.3_zod@3.25.76/node_modules/ox/core/Base64.d.ts

@@ -1,225 +0,0 @@
-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;
-}