@0xkaleab/sdk-js 0.2.7

package/dist/types/wallets/prompter.d.ts

@@ -0,0 +1,124 @@
+/**
+ * Default Signature Prompter for Keplr and other wallets
+ *
+ * This module provides a default UI-based signature prompter that handles
+ * the user gesture requirement for wallets like Keplr. It dynamically injects
+ * a prompt UI, waits for user confirmation, then triggers the signature request.
+ */
+import type { SignaturePrompter } from '../cascade/uploader';
+import type { TxOutcome } from '../cascade/ports';
+import type { EncodeObject } from '@cosmjs/proto-signing';
+/**
+ * Context for transaction prompt
+ */
+export interface TxPromptContext {
+    messages: readonly EncodeObject[];
+    memo?: string;
+}
+/**
+ * Transaction prompter type - wraps transaction submission in a user gesture
+ */
+export type TxPrompter = (context: TxPromptContext, submit: () => Promise<TxOutcome>) => Promise<TxOutcome>;
+/**
+ * Default signature prompter that creates a modal dialog
+ *
+ * This function creates a modal prompt that requests user confirmation
+ * before triggering the wallet signature request. This is necessary for wallets
+ * like Keplr that require signature requests to originate from explicit user gestures.
+ *
+ * The prompter:
+ * 1. Injects necessary CSS styles
+ * 2. Creates a modal overlay with a centered dialog containing Sign and Cancel buttons
+ * 3. Waits for user interaction (button click or overlay click)
+ * 4. Triggers the signature request on confirmation
+ * 5. Cleans up the modal from the DOM after completion or cancellation
+ *
+ * The modal is centered on the screen with a semi-transparent overlay. Clicking
+ * the overlay or Cancel button will reject the signature request. The modal is
+ * responsive and works well on different screen sizes.
+ *
+ * @param containerSelector - (Optional, deprecated) Previously used to specify a container.
+ *                            Now ignored as the modal is always appended to the body.
+ * @returns A SignaturePrompter function
+ *
+ * @example
+ * ```typescript
+ * const uploader = new CascadeUploader(...);
+ *
+ * await uploader.uploadFile(fileBytes, {
+ *   fileName: 'example.txt',
+ *   expirationTime: '...',
+ *   signaturePrompter: createDefaultSignaturePrompter()
+ * });
+ * ```
+ */
+export declare function createDefaultSignaturePrompter(containerSelector?: string): SignaturePrompter;
+/**
+ * Alias for createDefaultSignaturePrompter for backwards compatibility
+ */
+export declare const defaultSignaturePrompter: SignaturePrompter;
+/**
+ * Batched signature prompter that captures user gesture once for multiple signatures
+ *
+ * This function creates a signature prompter that shows a modal only on the first
+ * signature request, informing the user that multiple signatures are required.
+ * After the user clicks "Continue" on the initial modal, subsequent signature
+ * requests bypass the modal and proceed directly to the wallet.
+ *
+ * This solves the poor UX of requiring three separate user gestures for file upload,
+ * which involves three signatures: layout, index, and auth.
+ *
+ * The prompter:
+ * 1. On first signature request (layout): Shows a modal explaining three signatures are needed
+ * 2. Waits for user to click "Continue" (this grants the user gesture)
+ * 3. Sets an internal flag to bypass the modal for subsequent signatures
+ * 4. Subsequent signatures (index, auth) proceed directly without showing the modal
+ *
+ * @returns A SignaturePrompter function with batched gesture handling
+ *
+ * @example
+ * ```typescript
+ * const uploader = new CascadeUploader(...);
+ *
+ * await uploader.uploadFile(fileBytes, {
+ *   fileName: 'example.txt',
+ *   expirationTime: '...',
+ *   signaturePrompter: createBatchedSignaturePrompter()
+ * });
+ * ```
+ */
+export declare function createBatchedSignaturePrompter(): SignaturePrompter & {
+    reset: () => void;
+};
+/**
+ * Default transaction prompter that creates a modal dialog for transaction confirmation
+ *
+ * This function creates a modal prompt that requests user confirmation before
+ * triggering the wallet transaction (signAndBroadcast). This is necessary for wallets
+ * like Keplr that require transaction requests to originate from explicit user gestures.
+ *
+ * The prompter:
+ * 1. Injects necessary CSS styles (reuses signature prompt styles)
+ * 2. Creates a modal overlay with a centered dialog containing Confirm and Cancel buttons
+ * 3. Waits for user interaction (button click or overlay click)
+ * 4. Triggers the transaction submission on confirmation
+ * 5. Cleans up the modal from the DOM after completion or cancellation
+ *
+ * The modal is centered on the screen with a semi-transparent overlay. Clicking
+ * the overlay or Cancel button will reject the transaction request. The modal is
+ * responsive and works well on different screen sizes.
+ *
+ * @returns A TxPrompter function
+ *
+ * @example
+ * ```typescript
+ * const uploader = new CascadeUploader(...);
+ *
+ * await uploader.uploadFile(fileBytes, {
+ *   fileName: 'example.txt',
+ *   expirationTime: '...',
+ *   txPrompter: createDefaultTxPrompter()
+ * });
+ * ```
+ */
+export declare function createDefaultTxPrompter(): TxPrompter;

package/dist/types/wallets/signer.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Unified signer interface for Cosmos wallets.
+ *
+ * This module provides a standardized interface for wallet interactions that
+ * combines CosmJS transaction signing capabilities with off-chain message
+ * signing via ADR-036. This allows a single interface to handle both on-chain
+ * transactions and off-chain authentication/signatures.
+ *
+ * @module wallets/signer
+ */
+import type { AminoSignResponse, OfflineAminoSigner } from "@cosmjs/amino";
+import type { OfflineDirectSigner, AccountData, DirectSignResponse } from "@cosmjs/proto-signing";
+import type { SignDoc } from "cosmjs-types/cosmos/tx/v1beta1/tx";
+/**
+ * ADR-036 arbitrary message signing result.
+ *
+ * Contains the signed data and the signature produced by the wallet.
+ */
+export interface ArbitrarySignResponse {
+    /** The signed data (may be modified by the wallet) */
+    signed: string;
+    /** Base64-encoded signature */
+    signature: string;
+    /** Public key used for signing */
+    pub_key: {
+        type: string;
+        value: string;
+    };
+}
+/**
+ * Universal signer interface combining on-chain and off-chain signing.
+ *
+ * This interface extends CosmJS's `OfflineAminoSigner` and `OfflineDirectSigner`
+ * interfaces to support transaction signing, while also adding ADR-036
+ * `signArbitrary` for off-chain message signing (used for LEP-1 layout/index
+ * signatures and Cascade upload/download authentication).
+ *
+ * @example
+ * ```typescript
+ * // Get signer from Keplr
+ * const signer = await getKeplrSigner("lumera-testnet-2");
+ *
+ * // Sign a transaction (CosmJS)
+ * const accounts = await signer.getAccounts();
+ * const signDoc = { ... };
+ * const result = await signer.signDirect(accounts[0].address, signDoc);
+ *
+ * // Sign off-chain message (ADR-036)
+ * const dataHash = "abc123...";
+ * const signature = await signer.signArbitrary(
+ *   "lumera-testnet-2",
+ *   accounts[0].address,
+ *   dataHash
+ * );
+ * ```
+ */
+export interface UniversalSigner extends OfflineAminoSigner, OfflineDirectSigner {
+    /**
+     * Get accounts available from this signer.
+     *
+     * Returns the list of accounts that can sign transactions and messages.
+     * For browser wallets like Keplr/Leap, this typically returns a single account
+     * after the user has connected and authorized the chain.
+     *
+     * @returns Array of account data including address and public key
+     */
+    getAccounts(): Promise<readonly AccountData[]>;
+    /**
+     * Sign a transaction using Amino encoding (legacy).
+     *
+     * @param signerAddress - Address of the account signing the transaction
+     * @param signDoc - Amino sign document
+     * @returns Signed transaction in Amino format
+     */
+    signAmino(signerAddress: string, signDoc: any): Promise<AminoSignResponse>;
+    /**
+     * Sign a transaction using Protobuf encoding (Direct).
+     *
+     * @param signerAddress - Address of the account signing the transaction
+     * @param signDoc - Protobuf sign document
+     * @returns Signed transaction in Direct format
+     */
+    signDirect(signerAddress: string, signDoc: SignDoc): Promise<DirectSignResponse>;
+    /**
+     * Sign an arbitrary message using ADR-036.
+     *
+     * This method is used for off-chain signing, such as:
+     * - LEP-1 layout and index signatures
+     * - Cascade upload start signatures (signing the file hash)
+     * - Cascade download authorization (signing the action ID)
+     *
+     * The message is signed directly without blockchain context, making it suitable
+     * for authentication and data integrity verification off-chain.
+     *
+     * @param chainId - Chain identifier (e.g., "lumera-testnet-2")
+     * @param signerAddress - Bech32 address of the signer
+     * @param data - Data to sign (typically a hash or identifier)
+     * @returns Signature response with signed data and signature
+     * @throws {Error} If the wallet doesn't support signArbitrary or signing fails
+     */
+    signArbitrary(chainId: string, signerAddress: string, data: string): Promise<ArbitrarySignResponse>;
+}
+/**
+ * Type guard to check if a signer supports arbitrary message signing.
+ *
+ * @param signer - Potential UniversalSigner
+ * @returns True if the signer implements signArbitrary
+ */
+export declare function isUniversalSigner(signer: any): signer is UniversalSigner;

package/dist/types/wasm/lep1.d.ts

@@ -0,0 +1,135 @@
+/**
+ * LEP-1 Helper Functions for RaptorQ Layout Operations
+ *
+ * This module implements the LEP-1 (Lumera Enhancement Proposal 1) specification
+ * for RaptorQ layout generation and index file construction. LEP-1 defines how
+ * Cascade uploads derive layout IDs and construct the index file metadata.
+ *
+ * @see https://github.com/LumeraProtocol/LEPs/blob/main/LEP-1.md
+ */
+import type { Layout, IndexFile } from './types.js';
+/**
+ * Creates a single-block RaptorQ layout from file bytes.
+ *
+ * This function generates a deterministic RaptorQ layout suitable for encoding
+ * the provided file data into a single source block. The layout is computed by
+ * the rq-wasm library and includes all parameters needed for encoding and decoding.
+ *
+ * @param fileBytes - The complete file content as a Uint8Array
+ * @returns A promise that resolves to the raw layout file bytes (JSON format)
+ *
+ * @throws {Error} If the WASM module fails to initialize or layout creation fails
+ *
+ * @remarks
+ * - The layout generation is deterministic: identical input always produces identical output
+ * - This is critical for LEP-1 compliance and data integrity verification
+ * - The layout bytes are what should be signed for LEP-1 compliance
+ * - Use parseLayoutFile() to parse the bytes into a Layout object if needed for verification
+ *
+ * @example
+ * ```typescript
+ * const fileData = new TextEncoder().encode('Hello, Lumera!');
+ * const layoutBytes = await createSingleBlockLayout(fileData);
+ *
+ * // Parse if needed for verification
+ * const layout = parseLayoutFile(layoutBytes);
+ * console.log('Transfer length:', layout.transfer_length);
+ * console.log('Symbol size:', layout.symbol_size);
+ * ```
+ */
+export declare function createSingleBlockLayout(fileBytes: Uint8Array): Promise<Uint8Array>;
+/**
+ * Parses raw layout file bytes into a Layout object.
+ *
+ * This utility function decodes and parses the JSON layout file returned by
+ * createSingleBlockLayout. It's useful when you need to inspect layout properties
+ * for verification or debugging purposes.
+ *
+ * @param layoutBytes - The raw layout file bytes (UTF-8 encoded JSON)
+ * @returns The parsed Layout object
+ *
+ * @throws {Error} If the bytes cannot be decoded or parsed as valid JSON
+ *
+ * @example
+ * ```typescript
+ * const layoutBytes = await createSingleBlockLayout(fileData);
+ * const layout = parseLayoutFile(layoutBytes);
+ * console.log('Transfer length:', layout.transfer_length);
+ * console.log('Symbol size:', layout.symbol_size);
+ * console.log('Number of source blocks:', layout.num_source_blocks);
+ * ```
+ */
+export declare function parseLayoutFile(layoutBytes: Uint8Array): Layout;
+/**
+ * Derives a sequence of layout IDs according to LEP-1 specification.
+ *
+ * This function generates a deterministic sequence of layout IDs by:
+ * 1. Creating layout_with_signature = Base64(layout_file) + "." + Base64(layout_signature)
+ * 2. For each index i in [0, rq_ids_max):
+ *    - counter_i = rq_ids_ic + i
+ *    - layout_id_i = Base58(BLAKE3(zstd(layout_with_signature + "." + decimal(counter_i))))
+ *
+ * @param layoutFileB64 - The RaptorQ layout file as a Base64 string
+ * @param layoutSignatureB64 - The cryptographic signature over the layout data as a Base64 string
+ * @param rq_ids_ic - The initial counter value from blockchain action parameters
+ * @param rq_ids_max - The number of layout IDs to generate
+ * @returns A promise resolving to an array of Base58-encoded layout IDs
+ *
+ * @throws {Error} If rq_ids_max is zero or negative
+ * @throws {Error} If layoutFile or layoutSignature is empty
+ *
+ * @remarks
+ * - The derivation is deterministic and must match on-chain validation
+ * - LEP-1 specifies count=50 for standard Cascade uploads
+ * - Uses zstd compression, BLAKE3 hashing, and Base58 encoding
+ *
+ * @example
+ * ```typescript
+ * const layoutFile = new Uint8Array([...]);
+ * const layoutSignature = new Uint8Array([...]);
+ * const layoutIds = await generateIds(layoutFile, layoutSignature, 1000, 50);
+ * console.log('First ID:', layoutIds[0]);
+ * console.log('Last ID:', layoutIds[49]);
+ * ```
+ */
+export declare function generateIds(layoutFileB64: string, layoutSignatureB64: string, rq_ids_ic: number, rq_ids_max: number): Promise<string[]>;
+/**
+ * Constructs the index file for a LEP-1 Cascade upload.
+ *
+ * The index file contains metadata about the RaptorQ layout and includes
+ * a cryptographic signature to ensure data integrity. It must be serialized
+ * using canonical JSON when computing signatures or transmitting to the chain.
+ *
+ * @param layout_ids - Array of derived layout IDs (typically 50 for LEP-1)
+ * @param layout_signature - Cryptographic signature over the layout data (Base64-encoded bytes)
+ * @returns The constructed index file object
+ *
+ * @throws {Error} If layout_ids is empty
+ * @throws {Error} If layout_signature is empty
+ *
+ * @remarks
+ * - The version is currently fixed at 1 per LEP-1 specification
+ * - layout_ids must be derived using {@link generateIds}
+ * - layout_signature is computed by signing the canonical JSON bytes of the layout
+ *   using ADR-036 signArbitrary with the uploader's wallet
+ * - The index file must be serialized deterministically (canonical JSON) for on-chain verification
+ *
+ * @example
+ * ```typescript
+ * // Typical LEP-1 workflow
+ * const layoutIds = await generateIds(layoutFile, layoutSignature, rq_ids_ic, rq_ids_max);
+ *
+ * // Sign the layout (done by wallet via ADR-036 signArbitrary)
+ * const layoutBytes = canonicalJsonBytes(layout);
+ * const signature = await wallet.signArbitrary(chainId, signerAddress, layoutBytes);
+ * const signatureBytes = fromBase64(signature.signature);
+ *
+ * // Build the index file
+ * const indexFile = buildIndexFile(layoutIds, signatureBytes);
+ * ```
+ */
+export declare function buildIndexFile(layout_ids: string[], layout_signature: string): IndexFile;
+/**
+ * Re-export types for convenience
+ */
+export type { Layout, IndexFile, SourceBlock } from "./types.js";

package/dist/types/wasm/raptorq-proxy.d.ts

@@ -0,0 +1,154 @@
+/**
+ * RaptorQ WASM Proxy
+ *
+ * This module provides a proxy layer to the RaptorQ WASM library (rq-library-wasm).
+ * It handles initialization, in-memory filesystem operations, and provides a clean
+ * interface for RaptorQ operations.
+ */
+import type { Layout } from "./types.js";
+declare function getRqModule(): Promise<typeof import("rq-library-wasm")>;
+/**
+ * Proxy to the rq-library-wasm package for RaptorQ operations.
+ *
+ * This class handles initialization of the WASM module and provides a clean API
+ * for creating RaptorQ layouts using in-memory filesystem operations.
+ *
+ * @remarks
+ * The proxy implements the singleton pattern to ensure only one WASM instance
+ * is created. Files are stored in browser's in-memory filesystem before processing.
+ *
+ * @example
+ * ```typescript
+ * const proxy = RaptorQProxy.getInstance();
+ * await proxy.initialize();
+ *
+ * // Create a layout from file data
+ * const layoutBytes = await proxy.createSingleBlockLayout(fileBytes);
+ * ```
+ */
+export declare class RaptorQProxy {
+    private static instance;
+    private initPromise;
+    private initialized;
+    /**
+     * Default RaptorQ session parameters
+     */
+    private static readonly DEFAULT_SYMBOL_SIZE;
+    private static readonly DEFAULT_REDUNDANCY_FACTOR;
+    private static readonly DEFAULT_MAX_MEMORY_MB;
+    private static readonly DEFAULT_CONCURRENCY_LIMIT;
+    private static readonly DEFAULT_BLOCK_SIZE;
+    /**
+     * Private constructor to enforce singleton pattern.
+     */
+    private constructor();
+    /**
+     * Gets the singleton instance of the RaptorQProxy.
+     *
+     * @returns The RaptorQProxy singleton instance
+     */
+    static getInstance(): RaptorQProxy;
+    /**
+     * Resets the singleton instance.
+     *
+     * @remarks
+     * Primarily useful for testing purposes. Should not be used in production code.
+     *
+     * @internal
+     */
+    static resetInstance(): void;
+    /**
+     * Ensures the WASM module is initialized.
+     *
+     * @remarks
+     * This method is idempotent - multiple calls will only initialize once.
+     *
+     * @private
+     */
+    private ensureInitialized;
+    /**
+     * Initializes the WASM module.
+     *
+     * @remarks
+     * This loads the WASM module using the rq-library-wasm package.
+     * The package handles all platform-specific initialization automatically.
+     *
+     * @throws {Error} If the WASM module cannot be loaded
+     */
+    initialize(): Promise<void>;
+    /**
+     * Creates a RaptorQ session with the specified parameters.
+     *
+     * @param symbolSize - Size of each symbol in bytes (default: 65535)
+     * @param redundancyFactor - Redundancy factor for encoding (default: 10)
+     * @param maxMemoryMb - Maximum memory in MB (default: 1024)
+     * @param concurrencyLimit - Concurrency limit (default: 4)
+     * @returns A new RaptorQSession instance
+     *
+     * @throws {Error} If WASM module is not initialized
+     */
+    createSession(symbolSize?: number, redundancyFactor?: number, maxMemoryMb?: bigint, concurrencyLimit?: bigint): Promise<InstanceType<Awaited<ReturnType<typeof getRqModule>>["RaptorQSession"]>>;
+    /**
+     * Creates a single-block RaptorQ layout from file bytes.
+     *
+     * This generates metadata for a file by:
+     * 1. Writing the file bytes to the in-memory filesystem
+     * 2. Creating a RaptorQ session
+     * 3. Calling create_metadata to generate the layout
+     * 4. Reading the layout file from in-memory filesystem
+     * 5. Cleaning up temporary files
+     *
+     * @param fileBytes - The file content as a Uint8Array
+     * @returns A promise that resolves to the raw layout file bytes (JSON format)
+     *
+     * @throws {Error} If layout creation fails
+     *
+     * @remarks
+     * **IMPORTANT**: The file MUST be loaded into in-memory FS before creating RaptorQSession.
+     * This method follows the correct workflow:
+     * - Save file to in-memory FS
+     * - Create session
+     * - Call create_metadata
+     * - Read and return the layout file
+     */
+    createSingleBlockLayout(fileBytes: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Gets the recommended block size for a given file size.
+     *
+     * @param fileSize - The file size in bytes
+     * @returns The recommended block size
+     *
+     * @throws {Error} If WASM module is not initialized
+     */
+    getRecommendedBlockSize(fileSize: number): Promise<number>;
+    /**
+     * Gets the RaptorQ library version.
+     *
+     * @returns The library version string
+     *
+     * @throws {Error} If WASM module is not initialized
+     */
+    getVersion(): Promise<string>;
+    /**
+     * Checks if the WASM module is currently initialized.
+     *
+     * @returns True if the module is initialized, false otherwise
+     */
+    isInitialized(): boolean;
+}
+/**
+ * Parse layout file bytes into a Layout object.
+ *
+ * @param layoutBytes - The raw layout file bytes (JSON format)
+ * @returns The parsed Layout object
+ * @throws {Error} If parsing fails
+ */
+export declare function parseLayoutFile(layoutBytes: Uint8Array): Layout;
+export type { RaptorQSession } from "rq-library-wasm";
+export declare function writeFileChunk(...args: Parameters<typeof import("rq-library-wasm").writeFileChunk>): Promise<void>;
+export declare function readFileChunk(...args: Parameters<typeof import("rq-library-wasm").readFileChunk>): Promise<Uint8Array<ArrayBufferLike>>;
+export declare function getFileSize(...args: Parameters<typeof import("rq-library-wasm").getFileSize>): Promise<number>;
+export declare function createDirAll(...args: Parameters<typeof import("rq-library-wasm").createDirAll>): Promise<void>;
+export declare function dirExists(...args: Parameters<typeof import("rq-library-wasm").dirExists>): Promise<boolean>;
+export declare function syncDirExists(...args: Parameters<typeof import("rq-library-wasm").syncDirExists>): Promise<boolean>;
+export declare function flushFile(...args: Parameters<typeof import("rq-library-wasm").flushFile>): Promise<void>;

package/dist/types/wasm/types.d.ts

@@ -0,0 +1,98 @@
+/**
+ * WASM Layer Types for LEP-1 Operations
+ *
+ * This module defines the core types used by the WASM layer for RaptorQ
+ * layout generation and LEP-1 (Lumera Enhancement Proposal 1) operations.
+ */
+/**
+ * RaptorQ layout generated by rq-wasm for a single block.
+ *
+ * This layout contains the parameters needed for RaptorQ encoding/decoding,
+ * including the transfer length, symbol size, and block structure.
+ *
+ * @remarks
+ * The layout is deterministic based on the input file bytes and is used
+ * to derive layout IDs according to LEP-1 specifications.
+ */
+export interface Layout {
+    /**
+     * Total transfer length in bytes
+     */
+    transfer_length: number;
+    /**
+     * Size of each symbol in bytes
+     */
+    symbol_size: number;
+    /**
+     * Number of source blocks
+     */
+    num_source_blocks: number;
+    /**
+     * Number of sub-blocks
+     */
+    num_sub_blocks: number;
+    /**
+     * Symbol alignment in bytes
+     */
+    symbol_alignment: number;
+    /**
+     * Source block parameters for each block
+     */
+    source_blocks: SourceBlock[];
+}
+/**
+ * Parameters for a single source block in a RaptorQ layout.
+ */
+export interface SourceBlock {
+    /**
+     * Number of source symbols in this block
+     */
+    source_symbols: number;
+    /**
+     * Number of sub-symbols per symbol
+     */
+    sub_symbols: number;
+    /**
+     * Size of each sub-symbol in bytes
+     */
+    sub_symbol_size: number;
+}
+/**
+ * Index file structure for LEP-1 Cascade uploads.
+ *
+ * The index file contains metadata about the RaptorQ layout and is signed
+ * by the uploader to ensure data integrity. It includes 50 derived layout IDs
+ * and a cryptographic signature over the layout data.
+ *
+ * @remarks
+ * This structure must be serialized deterministically (canonical JSON) when
+ * computing signatures to ensure cross-platform compatibility.
+ */
+export interface IndexFile {
+    /**
+     * LEP-1 protocol version
+     *
+     * @remarks
+     * Currently fixed at 1 for LEP-1 specification
+     */
+    version: number;
+    /**
+     * Array of 50 derived layout IDs.
+     *
+     * @remarks
+     * Derived using the LEP-1 algorithm:
+     * Base58(BLAKE3(zstd(layout_with_signature + "." + counter)))
+     * where layout_with_signature = Base64(layout_file) + "." + Base64(layout_signature)
+     * and counter = rq_ids_ic + i for i in [0, rq_ids_max)
+     */
+    layout_ids: string[];
+    /**
+     * Cryptographic signature over the layout data.
+     *
+     * @remarks
+     * Generated by signing the canonical JSON bytes of the layout
+     * using ADR-036 signArbitrary with the uploader's wallet.
+     * Stored as Base64-encoded bytes.
+     */
+    layout_signature: string;
+}

package/docs/api/.nojekyll

@@ -0,0 +1 @@
+TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.

package/docs/api/assets/hierarchy.js

@@ -0,0 +1 @@
+window.hierarchyData = "eJyVksFuAiEURf/lrbEKI3WGnZ0fME13xgUBzKAMGB4mTcz8e4ONxmrp1A0LuC/ncOEEMYSEINb1nLBFQ+iGQDRbZ1SywSOIE9C8eNkbEPDx2TprfAICe+s1CMZfCRyjAwHWJxO3UhmcXmIvXeodEFBOIoKAhHqS5ybXbD7srNPReBBrypvNQKCe3yDfXFB71Unr/4W+jz+tUPGsQCt+49AG7Hf4flBFGcrqi8yZZHBaHCoqfW9kOm8e6A/VF5Gj7V85bPGDI1FJbdpsugpxrOn7+LNNVzOWm65m7NfXXp5/4FLLQzLxr0sXRsZuPwxfIvH/QA=="