@hashgraphonline/standards-agent-kit 0.2.131 → 0.2.132

package/dist/cjs/tools/hcs10/natural-language-mapper.d.ts

@@ -1,4 +1,8 @@
 import { AIAgentCapability } from '@hashgraphonline/standards-sdk';
+/**
+ * Valid input types for parsing tags or capabilities
+ */
+type ParseInput = string | number[] | string[] | AIAgentCapability[];
 /**
  * Maps natural language terms to AIAgentCapability enum values
  */
@@ -11,9 +15,10 @@ export declare class NaturalLanguageMapper {
     /**
      * Parse tags/capabilities from various input formats
      */
-    static parseTagsOrCapabilities(input: any): AIAgentCapability[];
+    static parseTagsOrCapabilities(input: ParseInput): AIAgentCapability[];
     /**
      * Convert capability enum to human-readable name
      */
     static getCapabilityName(capability: AIAgentCapability): string;
 }
+export {};

package/dist/cjs/tools/hcs2/CreateRegistryTool.d.ts

@@ -27,22 +27,7 @@ declare const createRegistrySchema: z.ZodObject<{
 export declare class CreateRegistryTool extends BaseHCS2QueryTool<typeof createRegistrySchema> {
     name: string;
     description: string;
-    get specificInputSchema(): z.ZodObject<{
-        registryType: z.ZodOptional<z.ZodNativeEnum<typeof HCS2RegistryType>>;
-        ttl: z.ZodOptional<z.ZodNumber>;
-        adminKey: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-        submitKey: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
-    }, "strip", z.ZodTypeAny, {
-        registryType?: HCS2RegistryType | undefined;
-        ttl?: number | undefined;
-        adminKey?: string | boolean | undefined;
-        submitKey?: string | boolean | undefined;
-    }, {
-        registryType?: HCS2RegistryType | undefined;
-        ttl?: number | undefined;
-        adminKey?: string | boolean | undefined;
-        submitKey?: string | boolean | undefined;
-    }>;
+    get specificInputSchema(): typeof createRegistrySchema;
     protected executeQuery(params: z.infer<typeof createRegistrySchema>, _runManager?: CallbackManagerForToolRun): Promise<unknown>;
 }
 export {};

package/dist/cjs/tools/hcs2/DeleteEntryTool.d.ts

@@ -23,19 +23,7 @@ declare const deleteEntrySchema: z.ZodObject<{
 export declare class DeleteEntryTool extends BaseHCS2QueryTool<typeof deleteEntrySchema> {
     name: string;
     description: string;
-    get specificInputSchema(): z.ZodObject<{
-        registryTopicId: z.ZodString;
-        uid: z.ZodString;
-        memo: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        uid: string;
-        registryTopicId: string;
-        memo?: string | undefined;
-    }, {
-        uid: string;
-        registryTopicId: string;
-        memo?: string | undefined;
-    }>;
+    get specificInputSchema(): typeof deleteEntrySchema;
     protected executeQuery(params: z.infer<typeof deleteEntrySchema>, _runManager?: CallbackManagerForToolRun): Promise<unknown>;
 }
 export {};

package/dist/cjs/tools/hcs2/RegisterEntryTool.d.ts

@@ -26,22 +26,7 @@ declare const registerEntrySchema: z.ZodObject<{
 export declare class RegisterEntryTool extends BaseHCS2QueryTool<typeof registerEntrySchema> {
     name: string;
     description: string;
-    get specificInputSchema(): z.ZodObject<{
-        registryTopicId: z.ZodString;
-        targetTopicId: z.ZodString;
-        metadata: z.ZodOptional<z.ZodString>;
-        memo: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        registryTopicId: string;
-        targetTopicId: string;
-        metadata?: string | undefined;
-        memo?: string | undefined;
-    }, {
-        registryTopicId: string;
-        targetTopicId: string;
-        metadata?: string | undefined;
-        memo?: string | undefined;
-    }>;
+    get specificInputSchema(): typeof registerEntrySchema;
     protected executeQuery(params: z.infer<typeof registerEntrySchema>, _runManager?: CallbackManagerForToolRun): Promise<unknown>;
 }
 export {};

package/dist/cjs/tools/hcs2/UpdateEntryTool.d.ts

@@ -29,25 +29,7 @@ declare const updateEntrySchema: z.ZodObject<{
 export declare class UpdateEntryTool extends BaseHCS2QueryTool<typeof updateEntrySchema> {
     name: string;
     description: string;
-    get specificInputSchema(): z.ZodObject<{
-        registryTopicId: z.ZodString;
-        targetTopicId: z.ZodString;
-        uid: z.ZodString;
-        metadata: z.ZodOptional<z.ZodString>;
-        memo: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        uid: string;
-        registryTopicId: string;
-        targetTopicId: string;
-        metadata?: string | undefined;
-        memo?: string | undefined;
-    }, {
-        uid: string;
-        registryTopicId: string;
-        targetTopicId: string;
-        metadata?: string | undefined;
-        memo?: string | undefined;
-    }>;
+    get specificInputSchema(): typeof updateEntrySchema;
     protected executeQuery(params: z.infer<typeof updateEntrySchema>, _runManager?: CallbackManagerForToolRun): Promise<unknown>;
 }
 export {};

package/dist/cjs/tools/hcs6/CreateDynamicRegistryTool.d.ts

@@ -22,16 +22,7 @@ export type CreateDynamicRegistryInput = z.infer<typeof CreateDynamicRegistrySch
 export declare class CreateDynamicRegistryTool extends BaseHCS6QueryTool<typeof CreateDynamicRegistrySchema> {
     name: string;
     description: string;
-    get specificInputSchema(): z.ZodObject<{
-        ttl: z.ZodDefault<z.ZodNumber>;
-        submitKey: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodString]>>;
-    }, "strip", z.ZodTypeAny, {
-        ttl: number;
-        submitKey?: string | boolean | undefined;
-    }, {
-        ttl?: number | undefined;
-        submitKey?: string | boolean | undefined;
-    }>;
+    get specificInputSchema(): typeof CreateDynamicRegistrySchema;
     constructor(params: HCS6QueryToolParams);
     protected executeQuery(params: CreateDynamicRegistryInput, _runManager?: CallbackManagerForToolRun): Promise<unknown>;
 }

package/dist/cjs/tools/hedera/HederaCreateNftTool.d.ts

@@ -0,0 +1,72 @@
+import { z } from 'zod';
+import { BaseHederaTransactionTool, BaseServiceBuilder } from 'hedera-agent-kit';
+/**
+ * Enhanced NFT creation schema with render configurations
+ */
+export declare const HederaCreateNftSchema: import('../..').ZodSchemaWithRender<{
+    tokenName: string;
+    memo?: string | undefined;
+    adminKey?: string | undefined;
+    tokenSymbol?: string | undefined;
+    treasuryAccountId?: string | undefined;
+    kycKey?: string | undefined;
+    freezeKey?: string | undefined;
+    wipeKey?: string | undefined;
+    supplyKey?: string | undefined;
+    feeScheduleKey?: string | undefined;
+    pauseKey?: string | undefined;
+    autoRenewAccountId?: string | undefined;
+    autoRenewPeriod?: number | undefined;
+    freezeDefault?: boolean | undefined;
+    supplyType?: "FINITE" | "INFINITE" | undefined;
+    maxSupply?: string | number | undefined;
+    customFees?: ({
+        type: "FIXED" | "FIXED_FEE";
+        amount: string | number;
+        feeCollectorAccountId?: string | undefined;
+        denominatingTokenId?: string | undefined;
+    } | {
+        type: "FRACTIONAL" | "FRACTIONAL_FEE";
+        numerator: number;
+        denominator: number;
+        feeCollectorAccountId?: string | undefined;
+        minAmount?: string | number | undefined;
+        maxAmount?: string | number | undefined;
+        assessmentMethodInclusive?: boolean | undefined;
+    } | {
+        type: "ROYALTY" | "ROYALTY_FEE";
+        numerator: number;
+        denominator: number;
+        feeCollectorAccountId?: string | undefined;
+        fallbackFee?: {
+            amount: string | number;
+            feeCollectorAccountId?: string | undefined;
+            denominatingTokenId?: string | undefined;
+        } | undefined;
+    })[] | undefined;
+}>;
+/**
+ * Hedera Create NFT Tool with enhanced render configurations for form generation
+ */
+export declare class HederaCreateNftTool extends BaseHederaTransactionTool<any> {
+    name: string;
+    description: string;
+    specificInputSchema: any;
+    namespace: string;
+    /**
+     * Returns the service builder for HTS operations
+     */
+    protected getServiceBuilder(): BaseServiceBuilder;
+    /**
+     * Calls the builder method to create the NFT collection
+     */
+    protected callBuilderMethod(builder: BaseServiceBuilder, specificArgs: z.infer<typeof HederaCreateNftSchema>): Promise<void>;
+    /**
+     * Provides helpful notes for specific field values
+     */
+    protected getNoteForKey(key: string, schemaDefaultValue: unknown, actualValue: unknown): string | undefined;
+    /**
+     * Validates the configuration before execution
+     */
+    protected validateInput(args: z.infer<typeof HederaCreateNftSchema>): Promise<void>;
+}

package/dist/cjs/tools/hedera/index.d.ts

@@ -0,0 +1 @@
+export { HederaCreateNftTool, HederaCreateNftSchema } from './HederaCreateNftTool';

package/dist/cjs/tools/index.d.ts

@@ -2,3 +2,4 @@ export * from './hcs10';
 export * from './hcs2';
 export * from './hcs6';
 export * from './inscriber';
+export * from './hedera';

package/dist/cjs/tools/inscriber/InscribeHashinalTool.d.ts

@@ -1,62 +1,12 @@
 import { z } from 'zod';
 import { BaseInscriberQueryTool } from './base-inscriber-tools';
 import { CallbackManagerForToolRun } from '@langchain/core/callbacks/manager';
+import { InscriptionResponse } from '../../types/inscription-response';
+import { FormValidatable } from '../../interfaces/FormValidatable';
 /**
  * Schema for inscribing Hashinal NFT
  */
-declare const inscribeHashinalSchema: z.ZodObject<{
-    url: z.ZodOptional<z.ZodString>;
-    contentRef: z.ZodOptional<z.ZodString>;
-    base64Data: z.ZodOptional<z.ZodString>;
-    fileName: z.ZodOptional<z.ZodString>;
-    mimeType: z.ZodOptional<z.ZodString>;
-    name: z.ZodOptional<z.ZodString>;
-    creator: z.ZodOptional<z.ZodString>;
-    description: z.ZodOptional<z.ZodString>;
-    type: z.ZodOptional<z.ZodString>;
-    attributes: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        trait_type: z.ZodString;
-        value: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
-    }, "strip", z.ZodTypeAny, {
-        value: string | number;
-        trait_type: string;
-    }, {
-        value: string | number;
-        trait_type: string;
-    }>, "many">>;
-    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    jsonFileURL: z.ZodOptional<z.ZodString>;
-    fileStandard: z.ZodDefault<z.ZodOptional<z.ZodEnum<["1", "6"]>>>;
-    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    chunkSize: z.ZodOptional<z.ZodNumber>;
-    waitForConfirmation: z.ZodOptional<z.ZodBoolean>;
-    timeoutMs: z.ZodOptional<z.ZodNumber>;
-    apiKey: z.ZodOptional<z.ZodString>;
-    quoteOnly: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-}, "strip", z.ZodTypeAny, {
-    quoteOnly: boolean;
-    fileStandard: "1" | "6";
-    url?: string | undefined;
-    type?: string | undefined;
-    name?: string | undefined;
-    description?: string | undefined;
-    tags?: string[] | undefined;
-    creator?: string | undefined;
-    properties?: Record<string, unknown> | undefined;
-    mimeType?: string | undefined;
-    chunkSize?: number | undefined;
-    waitForConfirmation?: boolean | undefined;
-    timeoutMs?: number | undefined;
-    apiKey?: string | undefined;
-    fileName?: string | undefined;
-    base64Data?: string | undefined;
-    attributes?: {
-        value: string | number;
-        trait_type: string;
-    }[] | undefined;
-    contentRef?: string | undefined;
-    jsonFileURL?: string | undefined;
-}, {
+declare const inscribeHashinalSchema: import('../..').ZodSchemaWithRender<{
     url?: string | undefined;
     type?: string | undefined;
     name?: string | undefined;
@@ -68,7 +18,6 @@ declare const inscribeHashinalSchema: z.ZodObject<{
     chunkSize?: number | undefined;
     waitForConfirmation?: boolean | undefined;
     timeoutMs?: number | undefined;
-    apiKey?: string | undefined;
     quoteOnly?: boolean | undefined;
     fileName?: string | undefined;
     base64Data?: string | undefined;
@@ -79,91 +28,52 @@ declare const inscribeHashinalSchema: z.ZodObject<{
     contentRef?: string | undefined;
     jsonFileURL?: string | undefined;
     fileStandard?: "1" | "6" | undefined;
+    withHashLinkBlocks?: boolean | undefined;
+    renderForm?: boolean | undefined;
 }>;
 /**
  * Tool for inscribing Hashinal NFTs
  */
-export declare class InscribeHashinalTool extends BaseInscriberQueryTool<typeof inscribeHashinalSchema> {
+export declare class InscribeHashinalTool extends BaseInscriberQueryTool implements FormValidatable {
     name: string;
     description: string;
-    get specificInputSchema(): z.ZodObject<{
-        url: z.ZodOptional<z.ZodString>;
-        contentRef: z.ZodOptional<z.ZodString>;
-        base64Data: z.ZodOptional<z.ZodString>;
-        fileName: z.ZodOptional<z.ZodString>;
-        mimeType: z.ZodOptional<z.ZodString>;
-        name: z.ZodOptional<z.ZodString>;
-        creator: z.ZodOptional<z.ZodString>;
-        description: z.ZodOptional<z.ZodString>;
-        type: z.ZodOptional<z.ZodString>;
-        attributes: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            trait_type: z.ZodString;
-            value: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
-        }, "strip", z.ZodTypeAny, {
-            value: string | number;
-            trait_type: string;
-        }, {
-            value: string | number;
-            trait_type: string;
-        }>, "many">>;
-        properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        jsonFileURL: z.ZodOptional<z.ZodString>;
-        fileStandard: z.ZodDefault<z.ZodOptional<z.ZodEnum<["1", "6"]>>>;
-        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        chunkSize: z.ZodOptional<z.ZodNumber>;
-        waitForConfirmation: z.ZodOptional<z.ZodBoolean>;
-        timeoutMs: z.ZodOptional<z.ZodNumber>;
-        apiKey: z.ZodOptional<z.ZodString>;
-        quoteOnly: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    }, "strip", z.ZodTypeAny, {
-        quoteOnly: boolean;
-        fileStandard: "1" | "6";
-        url?: string | undefined;
-        type?: string | undefined;
-        name?: string | undefined;
-        description?: string | undefined;
-        tags?: string[] | undefined;
-        creator?: string | undefined;
-        properties?: Record<string, unknown> | undefined;
-        mimeType?: string | undefined;
-        chunkSize?: number | undefined;
-        waitForConfirmation?: boolean | undefined;
-        timeoutMs?: number | undefined;
-        apiKey?: string | undefined;
-        fileName?: string | undefined;
-        base64Data?: string | undefined;
-        attributes?: {
-            value: string | number;
-            trait_type: string;
-        }[] | undefined;
-        contentRef?: string | undefined;
-        jsonFileURL?: string | undefined;
-    }, {
-        url?: string | undefined;
-        type?: string | undefined;
-        name?: string | undefined;
-        description?: string | undefined;
-        tags?: string[] | undefined;
-        creator?: string | undefined;
-        properties?: Record<string, unknown> | undefined;
-        mimeType?: string | undefined;
-        chunkSize?: number | undefined;
-        waitForConfirmation?: boolean | undefined;
-        timeoutMs?: number | undefined;
-        apiKey?: string | undefined;
-        quoteOnly?: boolean | undefined;
-        fileName?: string | undefined;
-        base64Data?: string | undefined;
-        attributes?: {
-            value: string | number;
-            trait_type: string;
-        }[] | undefined;
-        contentRef?: string | undefined;
-        jsonFileURL?: string | undefined;
-        fileStandard?: "1" | "6" | undefined;
-    }>;
-    protected executeQuery(params: z.infer<typeof inscribeHashinalSchema>, _runManager?: CallbackManagerForToolRun): Promise<unknown>;
+    get specificInputSchema(): z.ZodObject<z.ZodRawShape>;
+    private _schemaWithRenderConfig?;
+    get schema(): z.ZodObject<z.ZodRawShape>;
+    /**
+     * Implementation of FormValidatable interface
+     * Determines if a form should be generated for the given input
+     */
+    shouldGenerateForm(input: unknown): boolean;
+    /**
+     * Implementation of FormValidatable interface
+     * Returns the focused schema for form generation
+     */
+    getFormSchema(): z.ZodObject<z.ZodRawShape>;
+    /**
+     * Implementation of FormValidatable interface
+     * Validates metadata quality and provides detailed feedback
+     */
+    validateMetadataQuality(input: unknown): {
+        needsForm: boolean;
+        reason: string;
+    };
+    protected executeQuery(params: z.infer<typeof inscribeHashinalSchema>, _runManager?: CallbackManagerForToolRun): Promise<InscriptionResponse>;
+    /**
+     * Creates HashLink block reference for inscription display
+     */
+    private createHashLinkBlock;
     private resolveContent;
     private handleDirectContent;
+    /**
+     * Implementation of FormValidatable interface
+     * Returns essential fields that should always be shown in forms
+     */
+    getEssentialFields(): string[];
+    /**
+     * Implementation of FormValidatable interface
+     * Determines if a field value should be considered empty for this tool
+     */
+    isFieldEmpty(fieldName: string, value: unknown): boolean;
 }
 export {};

package/dist/cjs/tools/inscriber/RetrieveInscriptionTool.d.ts

@@ -14,6 +14,25 @@ declare const retrieveInscriptionSchema: z.ZodObject<{
     transactionId: string;
     apiKey?: string | undefined;
 }>;
+/**
+ * Type definition for inscription retrieval result
+ */
+interface InscriptionRetrievalResult {
+    inscriptionId?: string;
+    transactionId: string;
+    topicId?: string;
+    status?: string;
+    holderId?: string;
+    metadata?: unknown;
+    tags?: unknown;
+    mode?: string;
+    chunks?: unknown;
+    createdAt?: string;
+    completedAt?: string;
+    fileUrl?: string;
+    mimeType?: string;
+    fileSize?: number;
+}
 /**
  * Tool for retrieving inscriptions
  */
@@ -30,6 +49,6 @@ export declare class RetrieveInscriptionTool extends BaseInscriberQueryTool<type
         transactionId: string;
         apiKey?: string | undefined;
     }>;
-    protected executeQuery(params: z.infer<typeof retrieveInscriptionSchema>, _runManager?: CallbackManagerForToolRun): Promise<unknown>;
+    protected executeQuery(params: z.infer<typeof retrieveInscriptionSchema>, _runManager?: CallbackManagerForToolRun): Promise<InscriptionRetrievalResult>;
 }
 export {};

package/dist/cjs/types/inscription-response.d.ts

@@ -0,0 +1,172 @@
+/**
+ * Structured response interface for inscription tools
+ * Provides a consistent, user-friendly format for inscription results
+ */
+export interface InscriptionSuccessResponse {
+    success: true;
+    type: 'inscription';
+    title: string;
+    message: string;
+    inscription: {
+        /** The HRL (Hashinal Reference Link) for minting - e.g., "hcs://1/0.0.123456" */
+        hrl: string;
+        /** Topic ID where the inscription was stored */
+        topicId: string;
+        /** Type of Hashinal - Static (HCS-5) or Dynamic (HCS-6) */
+        standard: 'Static' | 'Dynamic';
+        /** CDN URL for direct access to the inscribed content */
+        cdnUrl?: string;
+        /** Transaction ID of the inscription */
+        transactionId?: string;
+    };
+    metadata: {
+        /** Name/title of the inscribed content */
+        name?: string;
+        /** Creator of the content */
+        creator?: string;
+        /** Description of the content */
+        description?: string;
+        /** Content type (image, text, etc.) */
+        type?: string;
+        /** Additional attributes */
+        attributes?: Array<{
+            trait_type: string;
+            value: string | number;
+        }>;
+    };
+    nextSteps: {
+        /** Primary action the user should take next */
+        primary: string;
+        /** Additional context or options */
+        context?: string;
+        /** Specific metadata value to use for minting */
+        mintingMetadata: string;
+    };
+    /** HashLink block data (only present when withHashLinkBlocks=true) */
+    hashLinkBlock?: {
+        /** Block topic ID on HCS */
+        blockId: string;
+        /** HashLink reference to the block */
+        hashLink: string;
+        /** Template topic ID */
+        template: string;
+        /** Block attributes for rendering */
+        attributes: BlockAttributes;
+    };
+}
+export interface InscriptionQuoteResponse {
+    success: true;
+    type: 'quote';
+    title: string;
+    message: string;
+    quote: {
+        /** Total cost in HBAR */
+        totalCostHbar: string;
+        /** When the quote expires */
+        validUntil: string;
+        /** Cost breakdown details */
+        breakdown?: CostBreakdown;
+    };
+    content: {
+        /** Name of the content to be inscribed */
+        name?: string;
+        /** Creator of the content */
+        creator?: string;
+        /** Type of content */
+        type?: string;
+    };
+}
+export interface InscriptionErrorResponse {
+    success: false;
+    type: 'error';
+    title: string;
+    message: string;
+    error: {
+        /** Error code for programmatic handling */
+        code: string;
+        /** Detailed error message */
+        details: string;
+        /** Suggestions for fixing the error */
+        suggestions?: string[];
+    };
+}
+export type InscriptionResponse = InscriptionSuccessResponse | InscriptionQuoteResponse | InscriptionErrorResponse;
+/**
+ * Helper function to create a successful inscription response
+ */
+export declare function createInscriptionSuccess(params: {
+    hrl: string;
+    topicId: string;
+    standard: 'Static' | 'Dynamic';
+    cdnUrl?: string;
+    transactionId?: string;
+    metadata: {
+        name?: string;
+        creator?: string;
+        description?: string;
+        type?: string;
+        attributes?: Array<{
+            trait_type: string;
+            value: string | number;
+        }>;
+    };
+}): InscriptionSuccessResponse;
+/**
+ * Block attributes for HashLink rendering
+ */
+interface BlockAttributes {
+    /** Display name */
+    name?: string;
+    /** Description text */
+    description?: string;
+    /** Image URL */
+    image?: string;
+    /** Content type */
+    contentType?: string;
+    /** Size in bytes */
+    size?: number;
+    /** Custom metadata */
+    metadata?: Record<string, string | number | boolean>;
+}
+/**
+ * Transfer details in cost breakdown
+ */
+interface TransferDetails {
+    to: string;
+    amount: string;
+    description: string;
+}
+/**
+ * Cost breakdown details for inscription quote
+ */
+interface CostBreakdown {
+    transfers: TransferDetails[];
+    baseFee?: number;
+    sizeFee?: number;
+    networkFee?: number;
+    serviceFee?: number;
+    totalFee?: number;
+    currency?: string;
+}
+/**
+ * Helper function to create a quote response
+ */
+export declare function createInscriptionQuote(params: {
+    totalCostHbar: string;
+    validUntil: string;
+    breakdown?: CostBreakdown;
+    content: {
+        name?: string;
+        creator?: string;
+        type?: string;
+    };
+}): InscriptionQuoteResponse;
+/**
+ * Helper function to create an error response
+ */
+export declare function createInscriptionError(params: {
+    code: string;
+    details: string;
+    suggestions?: string[];
+}): InscriptionErrorResponse;
+export {};

package/dist/cjs/validation/hip412-schemas.d.ts

@@ -122,4 +122,4 @@ export declare const hip412MetadataSchema: z.ZodObject<{
 /**
  * Validates metadata against HIP-412 standard
  */
-export declare function validateHIP412Metadata(metadata: any): z.infer<typeof hip412MetadataSchema>;
+export declare function validateHIP412Metadata(metadata: unknown): z.infer<typeof hip412MetadataSchema>;